1 /*
2 ** Copyright 2008-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 "AudioHardwareTegra"
21 #include <utils/Log.h>
22 #include <utils/String8.h>
23
24 #include <stdio.h>
25 #include <unistd.h>
26 #include <sys/ioctl.h>
27 #include <sys/types.h>
28 #include <sys/stat.h>
29 #include <dlfcn.h>
30 #include <fcntl.h>
31
32 #include "AudioHardware.h"
33 #include <audio_effects/effect_aec.h>
34 #include <audio_effects/effect_ns.h>
35
36 namespace android_audio_legacy {
37 const uint32_t AudioHardware::inputSamplingRates[] = {
38 8000, 11025, 12000, 16000, 22050, 32000, 44100, 48000
39 };
40
41 // number of times to attempt init() before giving up
42 const uint32_t MAX_INIT_TRIES = 10;
43
44 // When another thread wants to acquire the Mutex on the input or output stream, a short sleep
45 // period is forced in the read or write function to release the processor before acquiring the
46 // Mutex. Otherwise, as the read/write thread sleeps most of the time waiting for DMA buffers with
47 // the Mutex locked, the other thread could wait quite long before being able to acquire the Mutex.
48 #define FORCED_SLEEP_TIME_US 10000
49
50 // ----------------------------------------------------------------------------
51
52 // always succeeds, must call init() immediately after
AudioHardware()53 AudioHardware::AudioHardware() :
54 mInit(false), mMicMute(false), mBluetoothNrec(true), mBluetoothId(0),
55 mOutput(0), /*mCurOut/InDevice*/ mCpcapCtlFd(-1), mHwOutRate(0), mHwInRate(0),
56 mMasterVol(1.0), mVoiceVol(1.0),
57 /*mCpcapGain*/
58 mSpkrVolume(-1), mMicVolume(-1), mEcnsEnabled(0), mEcnsRequested(0), mBtScoOn(false)
59 {
60 ALOGV("AudioHardware constructor");
61 }
62
63 // designed to be called multiple times for retries
init()64 status_t AudioHardware::init() {
65
66 if (mInit) {
67 return NO_ERROR;
68 }
69
70 mCpcapCtlFd = ::open("/dev/audio_ctl", O_RDWR);
71 if (mCpcapCtlFd < 0) {
72 ALOGE("open /dev/audio_ctl failed: %s", strerror(errno));
73 goto error;
74 }
75
76 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_OUT_GET_OUTPUT, &mCurOutDevice) < 0) {
77 ALOGE("could not get output device: %s", strerror(errno));
78 goto error;
79 }
80 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_IN_GET_INPUT, &mCurInDevice) < 0) {
81 ALOGE("could not get input device: %s", strerror(errno));
82 goto error;
83 }
84 // For bookkeeping only
85 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_OUT_GET_RATE, &mHwOutRate) < 0) {
86 ALOGE("could not get output rate: %s", strerror(errno));
87 goto error;
88 }
89 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_IN_GET_RATE, &mHwInRate) < 0) {
90 ALOGE("could not get input rate: %s", strerror(errno));
91 goto error;
92 }
93
94 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
95 // Init the MM Audio Post Processing
96 mAudioPP.setAudioDev(&mCurOutDevice, &mCurInDevice, false, false, false);
97 #endif
98
99 readHwGainFile();
100
101 mInit = true;
102 return NO_ERROR;
103
104 error:
105 if (mCpcapCtlFd >= 0) {
106 (void) ::close(mCpcapCtlFd);
107 mCpcapCtlFd = -1;
108 }
109 return NO_INIT;
110 }
111
~AudioHardware()112 AudioHardware::~AudioHardware()
113 {
114 ALOGV("AudioHardware destructor");
115 for (size_t index = 0; index < mInputs.size(); index++) {
116 closeInputStream((AudioStreamIn*)mInputs[index]);
117 }
118 mInputs.clear();
119 closeOutputStream((AudioStreamOut*)mOutput);
120 if (mCpcapCtlFd >= 0) {
121 (void) ::close(mCpcapCtlFd);
122 mCpcapCtlFd = -1;
123 }
124 }
125
readHwGainFile()126 void AudioHardware::readHwGainFile()
127 {
128 int fd;
129 int rc=0;
130 int i;
131 uint32_t format, version, barker;
132 fd = open("/system/etc/cpcap_gain.bin", O_RDONLY);
133 if (fd>=0) {
134 ::read(fd, &format, sizeof(uint32_t));
135 ::read(fd, &version, sizeof(uint32_t));
136 ::read(fd, &barker, sizeof(uint32_t));
137 rc = ::read(fd, mCpcapGain, sizeof(mCpcapGain));
138 ALOGD("Read gain file, format %X version %X", format, version);
139 ::close(fd);
140 }
141 if (rc != sizeof(mCpcapGain) || format != 0x30303032) {
142 int gain;
143 ALOGE("CPCAP gain file not valid. Using defaults.");
144 for (int i=0; i<AUDIO_HW_GAIN_NUM_DIRECTIONS; i++) {
145 if (i==AUDIO_HW_GAIN_SPKR_GAIN)
146 gain = 11;
147 else
148 gain = 31;
149 for (int j=0; j<AUDIO_HW_GAIN_NUM_USECASES; j++)
150 for (int k=0; k<AUDIO_HW_GAIN_NUM_PATHS; k++)
151 mCpcapGain[i][j][k]=gain;
152 }
153 }
154 return;
155 }
156
initCheck()157 status_t AudioHardware::initCheck()
158 {
159 return mInit ? NO_ERROR : NO_INIT;
160 }
161
openOutputStream(uint32_t devices,int * format,uint32_t * channels,uint32_t * sampleRate,status_t * status)162 AudioStreamOut* AudioHardware::openOutputStream(
163 uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status)
164 {
165 { // scope for the lock
166 Mutex::Autolock lock(mLock);
167
168 // only one output stream allowed
169 if (mOutput) {
170 if (status) {
171 *status = INVALID_OPERATION;
172 }
173 return 0;
174 }
175
176 // create new output stream
177 AudioStreamOutTegra* out = new AudioStreamOutTegra();
178 for (unsigned tries = 0; tries < MAX_INIT_TRIES; ++tries) {
179 if (NO_ERROR == out->init())
180 break;
181 ALOGW("AudioStreamOutTegra::init failed soft, retrying");
182 sleep(1);
183 }
184 status_t lStatus;
185 lStatus = out->initCheck();
186 if (NO_ERROR != lStatus) {
187 ALOGE("AudioStreamOutTegra::init failed hard");
188 } else {
189 lStatus = out->set(this, devices, format, channels, sampleRate);
190 }
191 if (status) {
192 *status = lStatus;
193 }
194 if (lStatus == NO_ERROR) {
195 mOutput = out;
196 } else {
197 mLock.unlock();
198 delete out;
199 out = NULL;
200 mLock.lock();
201 }
202 }
203 return mOutput;
204 }
205
closeOutputStream(AudioStreamOut * out)206 void AudioHardware::closeOutputStream(AudioStreamOut* out) {
207 Mutex::Autolock lock(mLock);
208 if (mOutput == 0 || mOutput != out) {
209 ALOGW("Attempt to close invalid output stream");
210 }
211 else {
212 // AudioStreamOutTegra destructor calls standby which locks
213 mOutput = 0;
214 mLock.unlock();
215 delete out;
216 mLock.lock();
217 }
218 }
219
openInputStream(uint32_t devices,int * format,uint32_t * channels,uint32_t * sampleRate,status_t * status,AudioSystem::audio_in_acoustics acoustic_flags)220 AudioStreamIn* AudioHardware::openInputStream(
221 uint32_t devices, int *format, uint32_t *channels, uint32_t *sampleRate, status_t *status,
222 AudioSystem::audio_in_acoustics acoustic_flags)
223 {
224 // check for valid input source
225 if (!AudioSystem::isInputDevice((AudioSystem::audio_devices)devices)) {
226 return 0;
227 }
228
229 Mutex::Autolock lock(mLock);
230
231 AudioStreamInTegra* in = new AudioStreamInTegra();
232 // this serves a similar purpose as init()
233 status_t lStatus = in->set(this, devices, format, channels, sampleRate, acoustic_flags);
234 if (status) {
235 *status = lStatus;
236 }
237 if (lStatus != NO_ERROR) {
238 mLock.unlock();
239 delete in;
240 mLock.lock();
241 return 0;
242 }
243
244 mInputs.add(in);
245
246 return in;
247 }
248
closeInputStream(AudioStreamIn * in)249 void AudioHardware::closeInputStream(AudioStreamIn* in)
250 {
251 Mutex::Autolock lock(mLock);
252
253 ssize_t index = mInputs.indexOf((AudioStreamInTegra *)in);
254 if (index < 0) {
255 ALOGW("Attempt to close invalid input stream");
256 } else {
257 mInputs.removeAt(index);
258 mLock.unlock();
259 delete in;
260 mLock.lock();
261 }
262 }
263
setMode(int mode)264 status_t AudioHardware::setMode(int mode)
265 {
266 AutoMutex lock(mLock);
267 bool wasInCall = isInCall();
268 ALOGV("setMode() : new %d, old %d", mode, mMode);
269 status_t status = AudioHardwareBase::setMode(mode);
270 if (status == NO_ERROR) {
271 if (wasInCall ^ isInCall()) {
272 doRouting_l();
273 if (wasInCall) {
274 setMicMute_l(false);
275 }
276 }
277 }
278
279 return status;
280 }
281
282 // Must be called with mLock held
doStandby(int stop_fd,bool output,bool enable)283 status_t AudioHardware::doStandby(int stop_fd, bool output, bool enable)
284 {
285 status_t status = NO_ERROR;
286 struct cpcap_audio_stream standby;
287
288 ALOGV("AudioHardware::doStandby() putting %s in %s mode",
289 output ? "output" : "input",
290 enable ? "standby" : "online" );
291
292 // Debug code
293 if (!mLock.tryLock()) {
294 ALOGE("doStandby called without mLock held.");
295 mLock.unlock();
296 }
297 // end Debug code
298
299 if (output) {
300 standby.id = CPCAP_AUDIO_OUT_STANDBY;
301 standby.on = enable;
302
303 if (enable) {
304 /* Flush the queued playback data. Putting the output in standby
305 * will cause CPCAP to not drive the i2s interface, and write()
306 * will block until playback is resumed.
307 */
308 if (mOutput)
309 mOutput->flush();
310 }
311
312 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_OUT_SET_OUTPUT, &standby) < 0) {
313 ALOGE("could not turn off current output device: %s",
314 strerror(errno));
315 status = errno;
316 }
317
318 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_OUT_GET_OUTPUT, &mCurOutDevice) < 0) {
319 ALOGE("could not get current output device after standby: %s",
320 strerror(errno));
321 }
322 ALOGV("%s: after standby %s, output device %d is %s", __FUNCTION__,
323 enable ? "enable" : "disable", mCurOutDevice.id,
324 mCurOutDevice.on ? "on" : "off");
325 } else {
326 standby.id = CPCAP_AUDIO_IN_STANDBY;
327 standby.on = enable;
328
329 if (enable && stop_fd >= 0) {
330 /* Stop recording, if ongoing. Muting the microphone will cause
331 * CPCAP to not send data through the i2s interface, and read()
332 * will block until recording is resumed.
333 */
334 ALOGV("%s: stop recording", __FUNCTION__);
335 if (::ioctl(stop_fd, TEGRA_AUDIO_IN_STOP) < 0) {
336 ALOGE("could not stop recording: %s",
337 strerror(errno));
338 }
339 }
340
341 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_IN_SET_INPUT, &standby) < 0) {
342 ALOGE("could not turn off current input device: %s",
343 strerror(errno));
344 status = errno;
345 }
346 ::ioctl(mCpcapCtlFd, CPCAP_AUDIO_IN_GET_INPUT, &mCurInDevice);
347 ALOGV("%s: after standby %s, input device %d is %s", __FUNCTION__,
348 enable ? "enable" : "disable", mCurInDevice.id,
349 mCurInDevice.on ? "on" : "off");
350 }
351
352 return status;
353 }
354
setMicMute(bool state)355 status_t AudioHardware::setMicMute(bool state)
356 {
357 Mutex::Autolock lock(mLock);
358 return setMicMute_l(state);
359 }
360
setMicMute_l(bool state)361 status_t AudioHardware::setMicMute_l(bool state)
362 {
363 if (mMicMute != state) {
364 mMicMute = state;
365 ALOGV("setMicMute() %s", (state)?"ON":"OFF");
366 }
367 return NO_ERROR;
368 }
369
getMicMute(bool * state)370 status_t AudioHardware::getMicMute(bool* state)
371 {
372 *state = mMicMute;
373 return NO_ERROR;
374 }
375
setParameters(const String8 & keyValuePairs)376 status_t AudioHardware::setParameters(const String8& keyValuePairs)
377 {
378 AudioParameter param = AudioParameter(keyValuePairs);
379 String8 value;
380 String8 key;
381 const char BT_NREC_KEY[] = "bt_headset_nrec";
382 const char BT_NAME_KEY[] = "bt_headset_name";
383 const char BT_NREC_VALUE_ON[] = "on";
384
385
386 ALOGV("setParameters() %s", keyValuePairs.string());
387
388 if (keyValuePairs.length() == 0) return BAD_VALUE;
389
390 key = String8(BT_NREC_KEY);
391 if (param.get(key, value) == NO_ERROR) {
392 if (value == BT_NREC_VALUE_ON) {
393 mBluetoothNrec = true;
394 ALOGD("Turn on bluetooth NREC");
395 } else {
396 mBluetoothNrec = false;
397 ALOGD("Turning noise reduction and echo cancellation off for BT "
398 "headset");
399 }
400 doRouting();
401 }
402 key = String8(BT_NAME_KEY);
403 if (param.get(key, value) == NO_ERROR) {
404 mBluetoothId = 0;
405 #if 0
406 for (int i = 0; i < mNumSndEndpoints; i++) {
407 if (!strcasecmp(value.string(), mSndEndpoints[i].name)) {
408 mBluetoothId = mSndEndpoints[i].id;
409 ALOGD("Using custom acoustic parameters for %s", value.string());
410 break;
411 }
412 }
413 #endif
414 if (mBluetoothId == 0) {
415 ALOGD("Using default acoustic parameters "
416 "(%s not in acoustic database)", value.string());
417 doRouting();
418 }
419 }
420 return NO_ERROR;
421 }
422
getParameters(const String8 & keys)423 String8 AudioHardware::getParameters(const String8& keys)
424 {
425 AudioParameter request = AudioParameter(keys);
426 AudioParameter reply = AudioParameter();
427 String8 value;
428 String8 key;
429
430 ALOGV("getParameters() %s", keys.string());
431
432 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
433 key = "ec_supported";
434 if (request.get(key, value) == NO_ERROR) {
435 value = "yes";
436 reply.add(key, value);
437 }
438 #endif
439
440 return reply.toString();
441 }
442
getInputBufferSize(uint32_t sampleRate,int format,int channelCount)443 size_t AudioHardware::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
444 {
445 size_t bufsize;
446
447 if (format != AudioSystem::PCM_16_BIT) {
448 ALOGW("getInputBufferSize bad format: %d", format);
449 return 0;
450 }
451 if (channelCount < 1 || channelCount > 2) {
452 ALOGW("getInputBufferSize bad channel count: %d", channelCount);
453 return 0;
454 }
455
456 // Return 20 msec input buffer size.
457 bufsize = sampleRate * sizeof(int16_t) * channelCount / 50;
458 if (bufsize & 0x7) {
459 // Not divisible by 8.
460 bufsize +=8;
461 bufsize &= ~0x7;
462 }
463 ALOGV("%s: returns %d for rate %d", __FUNCTION__, bufsize, sampleRate);
464 return bufsize;
465 }
466
467 //setVoiceVolume is only useful for setting sidetone gains with a baseband
468 //controlling volume. Don't adjust hardware volume with this API.
469 //
470 //(On Stingray, don't use mVoiceVol for anything.)
setVoiceVolume(float v)471 status_t AudioHardware::setVoiceVolume(float v)
472 {
473 if (v < 0.0)
474 v = 0.0;
475 else if (v > 1.0)
476 v = 1.0;
477
478 ALOGV("Setting unused in-call vol to %f",v);
479 mVoiceVol = v;
480
481 return NO_ERROR;
482 }
483
setMasterVolume(float v)484 status_t AudioHardware::setMasterVolume(float v)
485 {
486 if (v < 0.0)
487 v = 0.0;
488 else if (v > 1.0)
489 v = 1.0;
490
491 ALOGV("Set master vol to %f.", v);
492 mMasterVol = v;
493 Mutex::Autolock lock(mLock);
494 int useCase = AUDIO_HW_GAIN_USECASE_MM;
495 AudioStreamInTegra *input = getActiveInput_l();
496 if (input) {
497 if (isInCall() && mOutput && !mOutput->getStandby() &&
498 input->source() == AUDIO_SOURCE_VOICE_COMMUNICATION) {
499 useCase = AUDIO_HW_GAIN_USECASE_VOICE;
500 } else if (input->source() == AUDIO_SOURCE_VOICE_RECOGNITION) {
501 useCase = AUDIO_HW_GAIN_USECASE_VOICE_REC;
502 }
503 }
504 setVolume_l(v, useCase);
505 return NO_ERROR;
506 }
507
508 // Call with mLock held.
setVolume_l(float v,int usecase)509 status_t AudioHardware::setVolume_l(float v, int usecase)
510 {
511 int spkr = getGain(AUDIO_HW_GAIN_SPKR_GAIN, usecase);
512 int mic = getGain(AUDIO_HW_GAIN_MIC_GAIN, usecase);
513
514 if (spkr==0) {
515 // no device to set volume on. Ignore request.
516 return -1;
517 }
518
519 spkr = ceil(v * spkr);
520 if (mSpkrVolume != spkr) {
521 ALOGV("Set tx volume to %d", spkr);
522 int ret = ::ioctl(mCpcapCtlFd, CPCAP_AUDIO_OUT_SET_VOLUME, spkr);
523 if (ret < 0) {
524 ALOGE("could not set spkr volume: %s", strerror(errno));
525 return ret;
526 }
527 mSpkrVolume = spkr;
528 }
529 if (mMicVolume != mic) {
530 ALOGV("Set rx volume to %d", mic);
531 int ret = ::ioctl(mCpcapCtlFd, CPCAP_AUDIO_IN_SET_VOLUME, mic);
532 if (ret < 0) {
533 ALOGE("could not set mic volume: %s", strerror(errno));
534 return ret;
535 }
536 mMicVolume = mic;
537 }
538
539 return NO_ERROR;
540 }
541
getGain(int direction,int usecase)542 uint8_t AudioHardware::getGain(int direction, int usecase)
543 {
544 int path;
545 AudioStreamInTegra *input = getActiveInput_l();
546 uint32_t inDev = (input == NULL) ? 0 : input->devices();
547 if (!mOutput) {
548 ALOGE("No output device.");
549 return 0;
550 }
551 uint32_t outDev = mOutput->devices();
552
553 // In case of an actual phone, with an actual earpiece, uncomment.
554 // if (outDev & AudioSystem::DEVICE_OUT_EARPIECE)
555 // path = AUDIO_HW_GAIN_EARPIECE;
556 // else
557 if (outDev & AudioSystem::DEVICE_OUT_WIRED_HEADPHONE)
558 path = AUDIO_HW_GAIN_HEADSET_NO_MIC;
559 else if (outDev & AudioSystem::DEVICE_OUT_WIRED_HEADSET)
560 path = AUDIO_HW_GAIN_HEADSET_W_MIC;
561 else if (outDev & AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET)
562 path = AUDIO_HW_GAIN_EMU_DEVICE;
563 else
564 path = AUDIO_HW_GAIN_SPEAKERPHONE;
565
566 ALOGV("Picked gain[%d][%d][%d] which is %d.",direction, usecase, path,
567 mCpcapGain[direction][usecase][path]);
568
569 return mCpcapGain[direction][usecase][path];
570 }
571
getActiveInputRate()572 int AudioHardware::getActiveInputRate()
573 {
574 AudioStreamInTegra *input = getActiveInput_l();
575 return (input != NULL) ? input->sampleRate() : 0;
576 }
577
doRouting()578 status_t AudioHardware::doRouting()
579 {
580 Mutex::Autolock lock(mLock);
581 return doRouting_l();
582 }
583
584 // Call this with mLock held.
doRouting_l()585 status_t AudioHardware::doRouting_l()
586 {
587 if (!mOutput) {
588 return NO_ERROR;
589 }
590 uint32_t outputDevices = mOutput->devices();
591 AudioStreamInTegra *input = getActiveInput_l();
592 uint32_t inputDevice = (input == NULL) ? 0 : input->devices();
593 uint32_t btScoOutDevices = outputDevices & (
594 AudioSystem::DEVICE_OUT_BLUETOOTH_SCO |
595 AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_HEADSET |
596 AudioSystem::DEVICE_OUT_BLUETOOTH_SCO_CARKIT );
597 uint32_t spdifOutDevices = outputDevices & (
598 AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET |
599 AudioSystem::DEVICE_OUT_AUX_DIGITAL );
600 uint32_t speakerOutDevices = outputDevices ^ btScoOutDevices ^ spdifOutDevices;
601 uint32_t btScoInDevice = inputDevice & AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET;
602 uint32_t micInDevice = inputDevice ^ btScoInDevice;
603 int sndOutDevice = -1;
604 int sndInDevice = -1;
605 bool btScoOn = btScoOutDevices||btScoInDevice;
606
607 ALOGV("%s: inputDevice %x, outputDevices %x", __FUNCTION__,
608 inputDevice, outputDevices);
609
610 switch (inputDevice) {
611 case AudioSystem::DEVICE_IN_DEFAULT:
612 case AudioSystem::DEVICE_IN_BUILTIN_MIC:
613 sndInDevice = CPCAP_AUDIO_IN_MIC1;
614 break;
615 case AudioSystem::DEVICE_IN_WIRED_HEADSET:
616 sndInDevice = CPCAP_AUDIO_IN_MIC2;
617 break;
618 default:
619 break;
620 }
621
622 switch (speakerOutDevices) {
623 case AudioSystem::DEVICE_OUT_EARPIECE:
624 case AudioSystem::DEVICE_OUT_DEFAULT:
625 case AudioSystem::DEVICE_OUT_SPEAKER:
626 sndOutDevice = CPCAP_AUDIO_OUT_SPEAKER;
627 break;
628 case AudioSystem::DEVICE_OUT_WIRED_HEADSET:
629 case AudioSystem::DEVICE_OUT_WIRED_HEADPHONE:
630 sndOutDevice = CPCAP_AUDIO_OUT_HEADSET;
631 break;
632 case AudioSystem::DEVICE_OUT_SPEAKER | AudioSystem::DEVICE_OUT_WIRED_HEADSET:
633 case AudioSystem::DEVICE_OUT_SPEAKER | AudioSystem::DEVICE_OUT_WIRED_HEADPHONE:
634 sndOutDevice = CPCAP_AUDIO_OUT_HEADSET_AND_SPEAKER;
635 break;
636 case AudioSystem::DEVICE_OUT_ANLG_DOCK_HEADSET:
637 sndOutDevice = CPCAP_AUDIO_OUT_ANLG_DOCK_HEADSET;
638 break;
639 case AudioSystem::DEVICE_OUT_DGTL_DOCK_HEADSET:
640 // To be implemented
641 break;
642 default:
643 break;
644 }
645
646 if (sndInDevice != (int)mCurInDevice.id) {
647 if (sndInDevice == -1) {
648 ALOGV("input device set %x not supported, defaulting to on-board mic",
649 inputDevice);
650 mCurInDevice.id = CPCAP_AUDIO_IN_MIC1;
651 }
652 else
653 mCurInDevice.id = sndInDevice;
654
655 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_IN_SET_INPUT,
656 &mCurInDevice) < 0)
657 ALOGE("could not set input (%d, on %d): %s",
658 mCurInDevice.id, mCurInDevice.on, strerror(errno));
659
660 ALOGV("current input %d, %s",
661 mCurInDevice.id,
662 mCurInDevice.on ? "on" : "off");
663 }
664
665 if (sndOutDevice != (int)mCurOutDevice.id) {
666 if (sndOutDevice == -1) {
667 ALOGW("output device set %x not supported, defaulting to speaker",
668 outputDevices);
669 mCurOutDevice.id = CPCAP_AUDIO_OUT_SPEAKER;
670 }
671 else
672 mCurOutDevice.id = sndOutDevice;
673
674 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_OUT_SET_OUTPUT,
675 &mCurOutDevice) < 0)
676 ALOGE("could not set output (%d, on %d): %s",
677 mCurOutDevice.id, mCurOutDevice.on,
678 strerror(errno));
679
680 ALOGV("current output %d, %s",
681 mCurOutDevice.id,
682 mCurOutDevice.on ? "on" : "off");
683 }
684
685 // enable EC if:
686 // - mEcnsRequested AND
687 // - the output stream is active
688 mEcnsEnabled = mEcnsRequested;
689 if (mOutput->getStandby()) {
690 mEcnsEnabled &= ~PREPROC_AEC;
691 }
692
693 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
694 int ecnsRate = (btScoOn || (getActiveInputRate() < 16000)) ? 8000 : 16000;
695 // Check input/output rates for HW.
696 if (mEcnsEnabled) {
697 mHwInRate = ecnsRate;
698 // rx path is altered only if AEC is enabled
699 if (mEcnsEnabled & PREPROC_AEC) {
700 mHwOutRate = mHwInRate;
701 } else {
702 mHwOutRate = AUDIO_HW_OUT_SAMPLERATE;
703 }
704 ALOGD("EC/NS active, requests rate as %d for in/out", mHwInRate);
705 }
706 else
707 #endif
708 {
709 if (input) {
710 mHwInRate = getActiveInputRate();
711 }
712 mHwOutRate = AUDIO_HW_OUT_SAMPLERATE;
713 ALOGV("No EC/NS, set input rate %d, output %d.", mHwInRate, mHwOutRate);
714 }
715 if (btScoOn) {
716 mHwOutRate = 8000;
717 mHwInRate = 8000;
718 ALOGD("Bluetooth SCO active, rate forced to 8K");
719 }
720
721 if (input) {
722 // acquire mutex if not already locked by read()
723 if (!input->isLocked()) {
724 input->lock();
725 }
726 }
727 // acquire mutex if not already locked by write()
728 if (!mOutput->isLocked()) {
729 mOutput->lock();
730 }
731 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
732 mAudioPP.setAudioDev(&mCurOutDevice, &mCurInDevice,
733 btScoOn, mBluetoothNrec,
734 spdifOutDevices?true:false);
735 mAudioPP.enableEcns(mEcnsEnabled);
736 #endif
737
738 mOutput->setDriver_l(speakerOutDevices?true:false,
739 btScoOn,
740 spdifOutDevices?true:false, mHwOutRate);
741
742 if (input) {
743 input->setDriver_l(micInDevice?true:false,
744 btScoOn, mHwInRate);
745 }
746
747 // Changing I2S to port connection when bluetooth starts or stopS must be done simultaneously
748 // for input and output while both DMAs are stopped
749 if (btScoOn != mBtScoOn) {
750 if (input) {
751 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
752 if (mEcnsEnabled) {
753 mAudioPP.enableEcns(0);
754 mAudioPP.enableEcns(mEcnsEnabled);
755 }
756 #endif
757 input->lockFd();
758 input->stop_l();
759 }
760 mOutput->lockFd();
761 mOutput->flush_l();
762
763 int bit_format = TEGRA_AUDIO_BIT_FORMAT_DEFAULT;
764 bool is_bt_bypass = false;
765 if (btScoOn) {
766 bit_format = TEGRA_AUDIO_BIT_FORMAT_DSP;
767 is_bt_bypass = true;
768 }
769 ALOGV("%s: bluetooth state changed. is_bt_bypass %d bit_format %d",
770 __FUNCTION__, is_bt_bypass, bit_format);
771 // Setup the I2S2-> DAP2/4 capture/playback path.
772 if (::ioctl(mOutput->mBtFdIoCtl, TEGRA_AUDIO_SET_BIT_FORMAT, &bit_format) < 0) {
773 ALOGE("could not set bit format %s", strerror(errno));
774 }
775 if (::ioctl(mCpcapCtlFd, CPCAP_AUDIO_SET_BLUETOOTH_BYPASS, is_bt_bypass) < 0) {
776 ALOGE("could not set bluetooth bypass %s", strerror(errno));
777 }
778
779 mBtScoOn = btScoOn;
780 mOutput->unlockFd();
781 if (input) {
782 input->unlockFd();
783 }
784 }
785
786 if (!mOutput->isLocked()) {
787 mOutput->unlock();
788 }
789 if (input && !input->isLocked()) {
790 input->unlock();
791 }
792
793 // Since HW path may have changed, set the hardware gains.
794 int useCase = AUDIO_HW_GAIN_USECASE_MM;
795 if (mEcnsEnabled) {
796 useCase = AUDIO_HW_GAIN_USECASE_VOICE;
797 } else if (input && input->source() == AUDIO_SOURCE_VOICE_RECOGNITION) {
798 useCase = AUDIO_HW_GAIN_USECASE_VOICE_REC;
799 }
800 setVolume_l(mMasterVol, useCase);
801
802 return NO_ERROR;
803 }
804
dumpInternals(int fd,const Vector<String16> & args)805 status_t AudioHardware::dumpInternals(int fd, const Vector<String16>& args)
806 {
807 const size_t SIZE = 256;
808 char buffer[SIZE];
809 String8 result;
810 result.append("AudioHardware::dumpInternals\n");
811 snprintf(buffer, SIZE, "\tmInit: %s\n", mInit? "true": "false");
812 result.append(buffer);
813 snprintf(buffer, SIZE, "\tmMicMute: %s\n", mMicMute? "true": "false");
814 result.append(buffer);
815 snprintf(buffer, SIZE, "\tmBluetoothNrec: %s\n", mBluetoothNrec? "true": "false");
816 result.append(buffer);
817 snprintf(buffer, SIZE, "\tmBluetoothId: %d\n", mBluetoothId);
818 result.append(buffer);
819 ::write(fd, result.string(), result.size());
820 return NO_ERROR;
821 }
822
dump(int fd,const Vector<String16> & args)823 status_t AudioHardware::dump(int fd, const Vector<String16>& args)
824 {
825 dumpInternals(fd, args);
826 for (size_t index = 0; index < mInputs.size(); index++) {
827 mInputs[index]->dump(fd, args);
828 }
829
830 if (mOutput) {
831 mOutput->dump(fd, args);
832 }
833 return NO_ERROR;
834 }
835
getInputSampleRate(uint32_t sampleRate)836 uint32_t AudioHardware::getInputSampleRate(uint32_t sampleRate)
837 {
838 uint32_t i;
839 uint32_t prevDelta;
840 uint32_t delta;
841
842 for (i = 0, prevDelta = 0xFFFFFFFF; i < sizeof(inputSamplingRates)/sizeof(uint32_t); i++, prevDelta = delta) {
843 delta = abs(sampleRate - inputSamplingRates[i]);
844 if (delta > prevDelta) break;
845 }
846 // i is always > 0 here
847 return inputSamplingRates[i-1];
848 }
849
850 // getActiveInput_l() must be called with mLock held
getActiveInput_l()851 AudioHardware::AudioStreamInTegra *AudioHardware::getActiveInput_l()
852 {
853 for (size_t i = 0; i < mInputs.size(); i++) {
854 // return first input found not being in standby mode
855 // as only one input can be in this state
856 if (!mInputs[i]->getStandby()) {
857 return mInputs[i];
858 }
859 }
860
861 return NULL;
862 }
863
setEcnsRequested_l(int ecns,bool enabled)864 void AudioHardware::setEcnsRequested_l(int ecns, bool enabled)
865 {
866 if (enabled) {
867 mEcnsRequested |= ecns;
868 } else {
869 mEcnsRequested &= ~ecns;
870 }
871 }
872
873 // ----------------------------------------------------------------------------
874 // Sample Rate Converter wrapper
875 //
876 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
AudioStreamSrc()877 AudioHardware::AudioStreamSrc::AudioStreamSrc() :
878 mSrcBuffer(NULL), mSrcInitted(false)
879 {
880 }
~AudioStreamSrc()881 AudioHardware::AudioStreamSrc::~AudioStreamSrc()
882 {
883 if (mSrcBuffer != NULL) {
884 delete[] mSrcBuffer;
885 }
886 }
887
init(int inRate,int outRate)888 void AudioHardware::AudioStreamSrc::init(int inRate, int outRate)
889 {
890 if (mSrcBuffer == NULL) {
891 mSrcBuffer = new char[src_memory_required_stereo(MAX_FRAME_LEN, MAX_CONVERT_RATIO)];
892 }
893 if (mSrcBuffer == NULL) {
894 ALOGE("Failed to allocate memory for sample rate converter.");
895 return;
896 }
897 mSrcInit.memory = (SRC16*)(mSrcBuffer);
898 mSrcInit.input_rate = inRate;
899 mSrcInit.output_rate = outRate;
900 mSrcInit.frame_length = MAX_FRAME_LEN;
901 mSrcInit.stereo_flag = SRC_OFF;
902 mSrcInit.input_interleaved = SRC_OFF;
903 mSrcInit.output_interleaved = SRC_OFF;
904 rate_convert_init(&mSrcInit, &mSrcObj);
905
906 mSrcInitted = true;
907 mSrcInRate = inRate;
908 mSrcOutRate = outRate;
909 }
910 #endif
911
912 // ----------------------------------------------------------------------------
913
914 // always succeeds, must call init() immediately after
AudioStreamOutTegra()915 AudioHardware::AudioStreamOutTegra::AudioStreamOutTegra() :
916 mBtFdIoCtl(-1), mHardware(0), mFd(-1), mFdCtl(-1),
917 mBtFd(-1), mBtFdCtl(-1),
918 mSpdifFd(-1), mSpdifFdCtl(-1),
919 mStartCount(0), mRetryCount(0), mDevices(0),
920 mIsSpkrEnabled(false), mIsBtEnabled(false), mIsSpdifEnabled(false),
921 mIsSpkrEnabledReq(false), mIsBtEnabledReq(false), mIsSpdifEnabledReq(false),
922 mSpareSample(0), mHaveSpareSample(false),
923 mState(AUDIO_STREAM_IDLE), /*mSrc*/ mLocked(false), mDriverRate(AUDIO_HW_OUT_SAMPLERATE),
924 mInit(false)
925 {
926 ALOGV("AudioStreamOutTegra constructor");
927 }
928
929 // designed to be called multiple times for retries
init()930 status_t AudioHardware::AudioStreamOutTegra::init()
931 {
932 if (mInit) {
933 return NO_ERROR;
934 }
935
936 #define OPEN_FD(fd, dev) fd = ::open(dev, O_RDWR); \
937 if (fd < 0) { \
938 ALOGE("open " dev " failed: %s", strerror(errno)); \
939 goto error; \
940 }
941 OPEN_FD(mFd, "/dev/audio0_out")
942 OPEN_FD(mFdCtl, "/dev/audio0_out_ctl")
943 OPEN_FD(mBtFd, "/dev/audio1_out")
944 OPEN_FD(mBtFdCtl, "/dev/audio1_out_ctl")
945 OPEN_FD(mBtFdIoCtl, "/dev/audio1_ctl")
946 // may need to be changed to warnings
947 OPEN_FD(mSpdifFd, "/dev/spdif_out")
948 OPEN_FD(mSpdifFdCtl, "/dev/spdif_out_ctl")
949 #undef OPEN_FD
950
951 setNumBufs(AUDIO_HW_NUM_OUT_BUF_LONG);
952
953 mInit = true;
954 return NO_ERROR;
955
956 error:
957 #define CLOSE_FD(fd) if (fd >= 0) { \
958 (void) ::close(fd); \
959 fd = -1; \
960 }
961 CLOSE_FD(mFd)
962 CLOSE_FD(mFdCtl)
963 CLOSE_FD(mBtFd)
964 CLOSE_FD(mBtFdCtl)
965 CLOSE_FD(mBtFdIoCtl)
966 CLOSE_FD(mSpdifFd)
967 CLOSE_FD(mSpdifFdCtl)
968 #undef CLOSE_FD
969 return NO_INIT;
970 }
971
initCheck()972 status_t AudioHardware::AudioStreamOutTegra::initCheck()
973 {
974 return mInit ? NO_ERROR : NO_INIT;
975 }
976
977 // Called with mHardware->mLock and mLock held.
setDriver_l(bool speaker,bool bluetooth,bool spdif,int sampleRate)978 void AudioHardware::AudioStreamOutTegra::setDriver_l(
979 bool speaker, bool bluetooth, bool spdif, int sampleRate)
980 {
981 ALOGV("Out setDriver_l() Analog speaker? %s. Bluetooth? %s. S/PDIF? %s. sampleRate %d",
982 speaker?"yes":"no", bluetooth?"yes":"no", spdif?"yes":"no", sampleRate);
983
984 // force some reconfiguration at next write()
985 if (mState == AUDIO_STREAM_CONFIGURED) {
986 if (mIsSpkrEnabled != speaker || mIsBtEnabled != bluetooth || mIsSpdifEnabled != spdif) {
987 mState = AUDIO_STREAM_CONFIG_REQ;
988 } else if (sampleRate != mDriverRate) {
989 mState = AUDIO_STREAM_NEW_RATE_REQ;
990 }
991 }
992
993 mIsSpkrEnabledReq = speaker;
994 mIsBtEnabledReq = bluetooth;
995 mIsSpdifEnabledReq = spdif;
996
997 }
998
set(AudioHardware * hw,uint32_t devices,int * pFormat,uint32_t * pChannels,uint32_t * pRate)999 status_t AudioHardware::AudioStreamOutTegra::set(
1000 AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate)
1001 {
1002 int lFormat = pFormat ? *pFormat : 0;
1003 uint32_t lChannels = pChannels ? *pChannels : 0;
1004 uint32_t lRate = pRate ? *pRate : 0;
1005
1006 mHardware = hw;
1007
1008 // fix up defaults
1009 if (lFormat == 0) lFormat = format();
1010 if (lChannels == 0) lChannels = channels();
1011 if (lRate == 0) lRate = sampleRate();
1012
1013 // check values
1014 if ((lFormat != format()) ||
1015 (lChannels != channels()) ||
1016 (lRate != sampleRate())) {
1017 if (pFormat) *pFormat = format();
1018 if (pChannels) *pChannels = channels();
1019 if (pRate) *pRate = sampleRate();
1020 return BAD_VALUE;
1021 }
1022
1023 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
1024 mHardware->mAudioPP.setPlayAudioRate(lRate);
1025 #endif
1026
1027 if (pFormat) *pFormat = lFormat;
1028 if (pChannels) *pChannels = lChannels;
1029 if (pRate) *pRate = lRate;
1030
1031 mDevices = devices;
1032 if (mFd >= 0 && mFdCtl >= 0 &&
1033 mBtFd >= 0 &&
1034 mBtFdCtl >= 0 &&
1035 mBtFdIoCtl >= 0) {
1036 if (mSpdifFd < 0 || mSpdifFdCtl < 0)
1037 ALOGW("s/pdif driver not present");
1038 return NO_ERROR;
1039 } else {
1040 ALOGE("Problem opening device files - Is your kernel compatible?");
1041 return NO_INIT;
1042 }
1043 }
1044
~AudioStreamOutTegra()1045 AudioHardware::AudioStreamOutTegra::~AudioStreamOutTegra()
1046 {
1047 standby();
1048 // Prevent someone from flushing the fd during a close.
1049 Mutex::Autolock lock(mFdLock);
1050 if (mFd >= 0) { ::close(mFd); mFd = -1; }
1051 if (mFdCtl >= 0) { ::close(mFdCtl); mFdCtl = -1; }
1052 if (mBtFd >= 0) { ::close(mBtFd); mBtFd = -1; }
1053 if (mBtFdCtl >= 0) { ::close(mBtFdCtl); mBtFdCtl = -1; }
1054 if (mBtFdIoCtl >= 0) { ::close(mBtFdIoCtl); mBtFdIoCtl = -1; }
1055 if (mSpdifFd >= 0) { ::close(mSpdifFd); mSpdifFd = -1; }
1056 if (mSpdifFdCtl >= 0) { ::close(mSpdifFdCtl); mSpdifFdCtl = -1; }
1057 }
1058
write(const void * buffer,size_t bytes)1059 ssize_t AudioHardware::AudioStreamOutTegra::write(const void* buffer, size_t bytes)
1060 {
1061 status_t status;
1062 if (!mHardware) {
1063 ALOGE("%s: mHardware is null", __FUNCTION__);
1064 return NO_INIT;
1065 }
1066 // ALOGD("AudioStreamOutTegra::write(%p, %u) TID %d", buffer, bytes, gettid());
1067 // Protect output state during the write process.
1068
1069 if (mSleepReq) {
1070 // sleep a few milliseconds so that the processor can be given to the thread attempting to
1071 // lock mLock before we sleep with mLock held while writing below
1072 usleep(FORCED_SLEEP_TIME_US);
1073 }
1074
1075 bool needsOnline = false;
1076 if (mState < AUDIO_STREAM_CONFIGURED) {
1077 mHardware->mLock.lock();
1078 if (mState < AUDIO_STREAM_CONFIGURED) {
1079 needsOnline = true;
1080 } else {
1081 mHardware->mLock.unlock();
1082 }
1083 }
1084
1085 { // scope for the lock
1086 Mutex::Autolock lock(mLock);
1087
1088 ssize_t written = 0;
1089 const uint8_t* p = static_cast<const uint8_t*>(buffer);
1090 size_t outsize = bytes;
1091 int outFd = mFd;
1092 bool stereo;
1093 ssize_t writtenToSpdif = 0;
1094
1095 if (needsOnline) {
1096 status = online_l();
1097 mHardware->mLock.unlock();
1098 if (status < 0) {
1099 goto error;
1100 }
1101 }
1102 stereo = mIsBtEnabled ? false : (channels() == AudioSystem::CHANNEL_OUT_STEREO);
1103
1104 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
1105 // Do Multimedia processing if appropriate for device and usecase.
1106 mHardware->mAudioPP.doMmProcessing((void *)buffer, bytes / frameSize());
1107 #endif
1108
1109 if (mIsSpkrEnabled && mIsBtEnabled) {
1110 // When dual routing to CPCAP and Bluetooth, piggyback CPCAP audio now,
1111 // and then down convert for the BT.
1112 // CPCAP is always 44.1 in this case.
1113 // This also works in the three-way routing case.
1114 Mutex::Autolock lock2(mFdLock);
1115 ::write(outFd, buffer, outsize);
1116 }
1117 if (mIsSpdifEnabled) {
1118 // When dual routing to Speaker and HDMI, piggyback HDMI now, since it
1119 // has no mic we'll leave the rest of the acoustic processing for the
1120 // CPCAP hardware path.
1121 // This also works in the three-way routing case, except the acoustic
1122 // tuning will be done on Bluetooth, since it has the exclusive mic amd
1123 // it also needs the sample rate conversion
1124 Mutex::Autolock lock2(mFdLock);
1125 if (mSpdifFd >= 0) {
1126 writtenToSpdif = ::write(mSpdifFd, buffer, outsize);
1127 ALOGV("%s: written %d bytes to SPDIF", __FUNCTION__, (int)writtenToSpdif);
1128 } else {
1129 ALOGW("s/pdif enabled but unavailable");
1130 }
1131 }
1132 if (mIsBtEnabled) {
1133 outFd = mBtFd;
1134 } else if (mIsSpdifEnabled && !mIsSpkrEnabled) {
1135 outFd = -1;
1136 }
1137
1138 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
1139 // Check if sample rate conversion or ECNS are required.
1140 // Caution: Upconversion (from 44.1 to 48) would require a new output buffer larger than the
1141 // original one.
1142 if (mDriverRate != (int)sampleRate()) {
1143 if (!mSrc.initted() ||
1144 mSrc.inRate() != (int)sampleRate() ||
1145 mSrc.outRate() != mDriverRate) {
1146 ALOGD("%s: downconvert started from %d to %d",__FUNCTION__,
1147 sampleRate(), mDriverRate);
1148 mSrc.init(sampleRate(), mDriverRate);
1149 if (!mSrc.initted()) {
1150 status = -1;
1151 goto error;
1152 }
1153 // Workaround to give multiple of 4 bytes to driver: Keep one sample
1154 // buffered in case SRC returns an odd number of samples.
1155 mHaveSpareSample = false;
1156 }
1157 } else {
1158 mSrc.deinit();
1159 }
1160
1161 if (mHardware->mAudioPP.isEcEnabled() || mSrc.initted())
1162 {
1163 // cut audio down to Mono for SRC or ECNS
1164 if (channels() == AudioSystem::CHANNEL_OUT_STEREO)
1165 {
1166 // Do stereo-to-mono downmix before SRC, in-place
1167 int16_t *destBuf = (int16_t *) buffer;
1168 for (int i = 0; i < (int)bytes/2; i++) {
1169 destBuf[i] = (destBuf[i*2]>>1) + (destBuf[i*2+1]>>1);
1170 }
1171 outsize >>= 1;
1172 }
1173 }
1174
1175 if (mSrc.initted()) {
1176 // Apply the sample rate conversion.
1177 mSrc.mIoData.in_buf_ch1 = (SRC16 *) (buffer);
1178 mSrc.mIoData.in_buf_ch2 = 0;
1179 mSrc.mIoData.input_count = outsize / sizeof(SRC16);
1180 mSrc.mIoData.out_buf_ch1 = (SRC16 *) (buffer);
1181 mSrc.mIoData.out_buf_ch2 = 0;
1182 mSrc.mIoData.output_count = outsize / sizeof(SRC16);
1183 if (mHaveSpareSample) {
1184 // Leave room for placing the spare.
1185 mSrc.mIoData.out_buf_ch1++;
1186 mSrc.mIoData.output_count--;
1187 }
1188 mSrc.srcConvert();
1189 ALOGV("Converted %d bytes at %d to %d bytes at %d",
1190 outsize, sampleRate(), mSrc.mIoData.output_count*2, mDriverRate);
1191 if (mHaveSpareSample) {
1192 int16_t *bufp = (int16_t*)buffer;
1193 bufp[0]=mSpareSample;
1194 mSrc.mIoData.output_count++;
1195 mHaveSpareSample = false;
1196 }
1197 outsize = mSrc.mIoData.output_count*2;
1198 ALOGV("Outsize is now %d", outsize);
1199 }
1200 if (mHardware->mAudioPP.isEcEnabled()) {
1201 // EC/NS is a blocking interface, to synchronise with read.
1202 // It also consumes data when EC/NS is running.
1203 // It expects MONO data.
1204 // If EC/NS is not running, it will return 0, and we need to write this data to the
1205 // driver ourselves.
1206
1207 // Indicate that it is safe to call setDriver_l() without locking mLock: if the input
1208 // stream is started, doRouting_l() will not block when setDriver_l() is called.
1209 mLocked = true;
1210 ALOGV("writeDownlinkEcns size %d", outsize);
1211 written = mHardware->mAudioPP.writeDownlinkEcns(outFd,(void *)buffer,
1212 stereo, outsize, &mFdLock);
1213 mLocked = false;
1214 }
1215 if (mHardware->mAudioPP.isEcEnabled() || mSrc.initted()) {
1216 // Move audio back up to Stereo, if the EC/NS wasn't in fact running and we're
1217 // writing to a stereo device.
1218 if (stereo &&
1219 written != (ssize_t)outsize) {
1220 // Back up to stereo, in place.
1221 int16_t *destBuf = (int16_t *) buffer;
1222 for (int i = outsize/2-1; i >= 0; i--) {
1223 destBuf[i*2] = destBuf[i];
1224 destBuf[i*2+1] = destBuf[i];
1225 }
1226 outsize <<= 1;
1227 }
1228 }
1229 #endif
1230
1231 if (written != (ssize_t)outsize) {
1232 // The sample rate conversion modifies the output size.
1233 if (outsize&0x3) {
1234 int16_t* bufp = (int16_t *)buffer;
1235 // ALOGV("Keep the spare sample away from the driver.");
1236 mHaveSpareSample = true;
1237 mSpareSample = bufp[outsize/2 - 1];
1238 }
1239
1240 if (outFd >= 0) {
1241 Mutex::Autolock lock2(mFdLock);
1242 written = ::write(outFd, buffer, outsize&(~0x3));
1243 if (written != ((ssize_t)outsize&(~0x3))) {
1244 status = written;
1245 goto error;
1246 }
1247 } else {
1248 written = writtenToSpdif;
1249 }
1250 }
1251 if (written < 0) {
1252 ALOGE("Error writing %d bytes to output: %s", outsize, strerror(errno));
1253 status = written;
1254 goto error;
1255 }
1256
1257 // Sample rate converter may be stashing a couple of bytes here or there,
1258 // so just report that all bytes were consumed. (it would be a bug not to.)
1259 ALOGV("write() written %d", bytes);
1260 return bytes;
1261
1262 }
1263 error:
1264 ALOGE("write(): error, return %d", status);
1265 standby();
1266 usleep(bytes * 1000 / frameSize() / sampleRate() * 1000);
1267
1268 return status;
1269 }
1270
flush()1271 void AudioHardware::AudioStreamOutTegra::flush()
1272 {
1273 // Prevent someone from writing the fd while we flush
1274 Mutex::Autolock lock(mFdLock);
1275 flush_l();
1276 }
1277
flush_l()1278 void AudioHardware::AudioStreamOutTegra::flush_l()
1279 {
1280 ALOGV("AudioStreamOutTegra::flush()");
1281 if (::ioctl(mFdCtl, TEGRA_AUDIO_OUT_FLUSH) < 0)
1282 ALOGE("could not flush playback: %s", strerror(errno));
1283 if (::ioctl(mBtFdCtl, TEGRA_AUDIO_OUT_FLUSH) < 0)
1284 ALOGE("could not flush bluetooth: %s", strerror(errno));
1285 if (mSpdifFdCtl >= 0 && ::ioctl(mSpdifFdCtl, TEGRA_AUDIO_OUT_FLUSH) < 0)
1286 ALOGE("could not flush spdif: %s", strerror(errno));
1287 ALOGV("AudioStreamOutTegra::flush() returns");
1288 }
1289
1290 // FIXME: this is a workaround for issue 3387419 with impact on latency
1291 // to be removed when root cause is fixed
setNumBufs(int numBufs)1292 void AudioHardware::AudioStreamOutTegra::setNumBufs(int numBufs)
1293 {
1294 Mutex::Autolock lock(mFdLock);
1295 ALOGV("AudioStreamOutTegra::setNumBufs(%d)", numBufs);
1296 if (::ioctl(mFdCtl, TEGRA_AUDIO_OUT_SET_NUM_BUFS, &numBufs) < 0)
1297 ALOGE("could not set number of output buffers: %s", strerror(errno));
1298 }
1299
1300 // Called with mLock and mHardware->mLock held
online_l()1301 status_t AudioHardware::AudioStreamOutTegra::online_l()
1302 {
1303 status_t status = NO_ERROR;
1304
1305 if (mState < AUDIO_STREAM_NEW_RATE_REQ) {
1306 if (mState == AUDIO_STREAM_IDLE) {
1307 ALOGV("output %p going online", this);
1308 mState = AUDIO_STREAM_CONFIG_REQ;
1309 // update EC state if necessary
1310 if (mHardware->getActiveInput_l() && mHardware->isEcRequested()) {
1311 // doRouting_l() will not try to lock mLock when calling setDriver_l()
1312 mLocked = true;
1313 mHardware->doRouting_l();
1314 mLocked = false;
1315 }
1316 }
1317
1318 // If there's no hardware speaker, leave the HW alone. (i.e. SCO/SPDIF is on)
1319 if (mIsSpkrEnabledReq) {
1320 status = mHardware->doStandby(mFdCtl, true, false); // output, online
1321 } else {
1322 status = mHardware->doStandby(mFdCtl, true, true); // output, standby
1323 }
1324 mIsSpkrEnabled = mIsSpkrEnabledReq;
1325
1326 mIsBtEnabled = mIsBtEnabledReq;
1327 mIsSpdifEnabled = mIsSpdifEnabledReq;
1328
1329 }
1330
1331 // Flush old data (wrong rate) from I2S driver before changing rate.
1332 flush();
1333 if (mHardware->mEcnsEnabled) {
1334 setNumBufs(AUDIO_HW_NUM_OUT_BUF);
1335 } else {
1336 setNumBufs(AUDIO_HW_NUM_OUT_BUF_LONG);
1337 }
1338 int speaker_rate = mHardware->mHwOutRate;
1339 if (mIsBtEnabled) {
1340 speaker_rate = AUDIO_HW_OUT_SAMPLERATE;
1341 }
1342 // Now the DMA is empty, change the rate.
1343 if (::ioctl(mHardware->mCpcapCtlFd, CPCAP_AUDIO_OUT_SET_RATE,
1344 speaker_rate) < 0)
1345 ALOGE("could not set output rate(%d): %s",
1346 speaker_rate, strerror(errno));
1347
1348 mDriverRate = mHardware->mHwOutRate;
1349
1350 // If EC is on, pre load one DMA buffer with 20ms of silence to limit underruns
1351 if (mHardware->mEcnsEnabled) {
1352 int fd = -1;
1353 if (mIsBtEnabled) {
1354 fd = mBtFd;
1355 } else if (mIsSpkrEnabled) {
1356 fd = mFd;
1357 }
1358 if (fd >= 0) {
1359 size_t bufSize = (mDriverRate * 2 /* stereo */ * sizeof(int16_t))/ 50;
1360 char buf[bufSize];
1361 memset(buf, 0, bufSize);
1362 Mutex::Autolock lock2(mFdLock);
1363 ::write(fd, buf, bufSize);
1364 }
1365 }
1366
1367 mState = AUDIO_STREAM_CONFIGURED;
1368
1369 return status;
1370 }
1371
standby()1372 status_t AudioHardware::AudioStreamOutTegra::standby()
1373 {
1374 if (!mHardware) {
1375 return NO_INIT;
1376 }
1377
1378 status_t status = NO_ERROR;
1379 Mutex::Autolock lock(mHardware->mLock);
1380 Mutex::Autolock lock2(mLock);
1381
1382 if (mState != AUDIO_STREAM_IDLE) {
1383 ALOGV("output %p going into standby", this);
1384 mState = AUDIO_STREAM_IDLE;
1385
1386 // update EC state if necessary
1387 if (mHardware->getActiveInput_l() && mHardware->isEcRequested()) {
1388 // doRouting_l will not try to lock mLock when calling setDriver_l()
1389 mLocked = true;
1390 mHardware->doRouting_l();
1391 mLocked = false;
1392 }
1393
1394 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
1395 // Prevent EC/NS from writing to the file anymore.
1396 mHardware->mAudioPP.writeDownlinkEcns(-1,0,false,0,&mFdLock);
1397 #endif
1398 if (mIsSpkrEnabled) {
1399 // doStandby() calls flush() which also handles the case where multiple devices
1400 // including bluetooth or SPDIF are selected
1401 status = mHardware->doStandby(mFdCtl, true, true); // output, standby
1402 } else if (mIsBtEnabled || mIsSpdifEnabled) {
1403 flush();
1404 }
1405 }
1406
1407 return status;
1408 }
1409
dump(int fd,const Vector<String16> & args)1410 status_t AudioHardware::AudioStreamOutTegra::dump(int fd, const Vector<String16>& args)
1411 {
1412 const size_t SIZE = 256;
1413 char buffer[SIZE];
1414 String8 result;
1415 result.append("AudioStreamOutTegra::dump\n");
1416 snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
1417 result.append(buffer);
1418 snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
1419 result.append(buffer);
1420 snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
1421 result.append(buffer);
1422 snprintf(buffer, SIZE, "\tformat: %d\n", format());
1423 result.append(buffer);
1424 snprintf(buffer, SIZE, "\tmHardware: %p\n", mHardware);
1425 result.append(buffer);
1426 snprintf(buffer, SIZE, "\tmFd: %d\n", mFd);
1427 result.append(buffer);
1428 snprintf(buffer, SIZE, "\tmStartCount: %d\n", mStartCount);
1429 result.append(buffer);
1430 snprintf(buffer, SIZE, "\tmRetryCount: %d\n", mRetryCount);
1431 result.append(buffer);
1432 if (mHardware)
1433 snprintf(buffer, SIZE, "\tmStandby: %s\n",
1434 mHardware->mCurOutDevice.on ? "false": "true");
1435 else
1436 snprintf(buffer, SIZE, "\tmStandby: unknown\n");
1437
1438 result.append(buffer);
1439 ::write(fd, result.string(), result.size());
1440 return NO_ERROR;
1441 }
1442
getStandby()1443 bool AudioHardware::AudioStreamOutTegra::getStandby()
1444 {
1445 return mState == AUDIO_STREAM_IDLE;;
1446 }
1447
setParameters(const String8 & keyValuePairs)1448 status_t AudioHardware::AudioStreamOutTegra::setParameters(const String8& keyValuePairs)
1449 {
1450 AudioParameter param = AudioParameter(keyValuePairs);
1451 String8 key = String8(AudioParameter::keyRouting);
1452 status_t status = NO_ERROR;
1453 int device;
1454 ALOGV("AudioStreamOutTegra::setParameters() %s", keyValuePairs.string());
1455
1456 if (param.getInt(key, device) == NO_ERROR) {
1457 if (device != 0) {
1458 mDevices = device;
1459 ALOGV("set output routing %x", mDevices);
1460 status = mHardware->doRouting();
1461 }
1462 param.remove(key);
1463 }
1464
1465 if (param.size()) {
1466 status = BAD_VALUE;
1467 }
1468 return status;
1469 }
1470
getParameters(const String8 & keys)1471 String8 AudioHardware::AudioStreamOutTegra::getParameters(const String8& keys)
1472 {
1473 AudioParameter param = AudioParameter(keys);
1474 String8 value;
1475 String8 key = String8(AudioParameter::keyRouting);
1476
1477 if (param.get(key, value) == NO_ERROR) {
1478 ALOGV("get routing %x", mDevices);
1479 param.addInt(key, (int)mDevices);
1480 }
1481
1482 ALOGV("AudioStreamOutTegra::getParameters() %s", param.toString().string());
1483 return param.toString();
1484 }
1485
getRenderPosition(uint32_t * dspFrames)1486 status_t AudioHardware::AudioStreamOutTegra::getRenderPosition(uint32_t *dspFrames)
1487 {
1488 //TODO: enable when supported by driver
1489 return INVALID_OPERATION;
1490 }
1491
1492 // ----------------------------------------------------------------------------
1493
1494 // always succeeds, must call set() immediately after
AudioStreamInTegra()1495 AudioHardware::AudioStreamInTegra::AudioStreamInTegra() :
1496 mHardware(0), mFd(-1), mFdCtl(-1), mState(AUDIO_STREAM_IDLE), mRetryCount(0),
1497 mFormat(AUDIO_HW_IN_FORMAT), mChannels(AUDIO_HW_IN_CHANNELS),
1498 mSampleRate(AUDIO_HW_IN_SAMPLERATE), mBufferSize(AUDIO_HW_IN_BUFFERSIZE),
1499 mAcoustics((AudioSystem::audio_in_acoustics)0), mDevices(0),
1500 mIsMicEnabled(0), mIsBtEnabled(0),
1501 mSource(AUDIO_SOURCE_DEFAULT), mLocked(false), mTotalBuffersRead(0),
1502 mDriverRate(AUDIO_HW_IN_SAMPLERATE), mEcnsRequested(0)
1503 {
1504 ALOGV("AudioStreamInTegra constructor");
1505 }
1506
1507 // serves a similar purpose as init()
set(AudioHardware * hw,uint32_t devices,int * pFormat,uint32_t * pChannels,uint32_t * pRate,AudioSystem::audio_in_acoustics acoustic_flags)1508 status_t AudioHardware::AudioStreamInTegra::set(
1509 AudioHardware* hw, uint32_t devices, int *pFormat, uint32_t *pChannels, uint32_t *pRate,
1510 AudioSystem::audio_in_acoustics acoustic_flags)
1511 {
1512 Mutex::Autolock lock(mLock);
1513 status_t status = BAD_VALUE;
1514 mHardware = hw;
1515 if (pFormat == 0)
1516 return status;
1517 if (*pFormat != AUDIO_HW_IN_FORMAT) {
1518 ALOGE("wrong in format %d, expecting %lld", *pFormat, AUDIO_HW_IN_FORMAT);
1519 *pFormat = AUDIO_HW_IN_FORMAT;
1520 return status;
1521 }
1522
1523 if (pRate == 0)
1524 return status;
1525
1526 uint32_t rate = hw->getInputSampleRate(*pRate);
1527 if (rate != *pRate) {
1528 ALOGE("wrong sample rate %d, expecting %d", *pRate, rate);
1529 *pRate = rate;
1530 return status;
1531 }
1532
1533 if (pChannels == 0)
1534 return status;
1535
1536 if (*pChannels != AudioSystem::CHANNEL_IN_MONO &&
1537 *pChannels != AudioSystem::CHANNEL_IN_STEREO) {
1538 ALOGE("wrong number of channels %d", *pChannels);
1539 *pChannels = AUDIO_HW_IN_CHANNELS;
1540 return status;
1541 }
1542
1543 ALOGV("AudioStreamInTegra::set(%d, %d, %u)", *pFormat, *pChannels, *pRate);
1544
1545 mDevices = devices;
1546 mFormat = AUDIO_HW_IN_FORMAT;
1547 mChannels = *pChannels;
1548 mSampleRate = *pRate;
1549 mBufferSize = mHardware->getInputBufferSize(mSampleRate, AudioSystem::PCM_16_BIT,
1550 AudioSystem::popCount(mChannels));
1551 return NO_ERROR;
1552 }
1553
~AudioStreamInTegra()1554 AudioHardware::AudioStreamInTegra::~AudioStreamInTegra()
1555 {
1556 ALOGV("AudioStreamInTegra destructor");
1557
1558 standby();
1559
1560 }
1561
1562 // Called with mHardware->mLock and mLock held.
setDriver_l(bool mic,bool bluetooth,int sampleRate)1563 void AudioHardware::AudioStreamInTegra::setDriver_l(bool mic, bool bluetooth, int sampleRate)
1564 {
1565 ALOGV("In setDriver_l() Analog mic? %s. Bluetooth? %s.", mic?"yes":"no", bluetooth?"yes":"no");
1566
1567 // force some reconfiguration at next read()
1568 // Note: mState always == AUDIO_STREAM_CONFIGURED when setDriver_l() is called on an input
1569 if (mic != mIsMicEnabled || bluetooth != mIsBtEnabled) {
1570 mState = AUDIO_STREAM_CONFIG_REQ;
1571 } else if (sampleRate != mDriverRate) {
1572 mState = AUDIO_STREAM_NEW_RATE_REQ;
1573 }
1574
1575 mIsMicEnabled = mic;
1576 mIsBtEnabled = bluetooth;
1577
1578 }
1579
read(void * buffer,ssize_t bytes)1580 ssize_t AudioHardware::AudioStreamInTegra::read(void* buffer, ssize_t bytes)
1581 {
1582 status_t status;
1583 if (!mHardware) {
1584 ALOGE("%s: mHardware is null", __FUNCTION__);
1585 return NO_INIT;
1586 }
1587 //
1588 ALOGV("AudioStreamInTegra::read(%p, %ld) TID %d", buffer, bytes, gettid());
1589
1590 if (mSleepReq) {
1591 // sleep a few milliseconds so that the processor can be given to the thread attempting to
1592 // lock mLock before we sleep with mLock held while reading below
1593 usleep(FORCED_SLEEP_TIME_US);
1594 }
1595
1596 bool needsOnline = false;
1597 if (mState < AUDIO_STREAM_CONFIGURED) {
1598 mHardware->mLock.lock();
1599 if (mState < AUDIO_STREAM_CONFIGURED) {
1600 needsOnline = true;
1601 } else {
1602 mHardware->mLock.unlock();
1603 }
1604 }
1605
1606 { // scope for mLock
1607 Mutex::Autolock lock(mLock);
1608
1609 ssize_t ret;
1610 bool srcReqd;
1611 int hwReadBytes;
1612 int16_t * inbuf;
1613
1614 if (needsOnline) {
1615 status = online_l();
1616 mHardware->mLock.unlock();
1617 if (status != NO_ERROR) {
1618 ALOGE("%s: Problem switching to online.",__FUNCTION__);
1619 goto error;
1620 }
1621 }
1622
1623 srcReqd = (mDriverRate != (int)mSampleRate);
1624
1625 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
1626 if (srcReqd) {
1627 hwReadBytes = ( bytes*mDriverRate/mSampleRate ) & (~0x7);
1628 ALOGV("Running capture SRC. HW=%d bytes at %d, Flinger=%d bytes at %d",
1629 hwReadBytes, mDriverRate, (int)bytes, mSampleRate);
1630 inbuf = mInScratch;
1631 if ((size_t)bytes > sizeof(mInScratch)) {
1632 ALOGE("read: buf size problem. %d>%d",(int)bytes,sizeof(mInScratch));
1633 status = BAD_VALUE;
1634 goto error;
1635 }
1636 // Check if we need to init the rate converter
1637 if (!mSrc.initted() ||
1638 mSrc.inRate() != mDriverRate ||
1639 mSrc.outRate() != (int)mSampleRate) {
1640 ALOGD ("%s: Upconvert started from %d to %d", __FUNCTION__,
1641 mDriverRate, mSampleRate);
1642 mSrc.init(mDriverRate, mSampleRate);
1643 if (!mSrc.initted()) {
1644 status = NO_INIT;
1645 goto error;
1646 }
1647 }
1648 } else {
1649 hwReadBytes = bytes;
1650 inbuf = (int16_t *)buffer;
1651 mSrc.deinit();
1652 }
1653 // Read from driver, or ECNS thread, as appropriate.
1654 {
1655 Mutex::Autolock dfl(mFdLock);
1656 ret = mHardware->mAudioPP.read(mFd, inbuf, hwReadBytes, mDriverRate);
1657 }
1658 if (ret>0 && srcReqd) {
1659 mSrc.mIoData.in_buf_ch1 = (SRC16 *) (inbuf);
1660 mSrc.mIoData.in_buf_ch2 = 0;
1661 mSrc.mIoData.input_count = hwReadBytes / sizeof(SRC16);
1662 mSrc.mIoData.out_buf_ch1 = (SRC16 *) (buffer);
1663 mSrc.mIoData.out_buf_ch2 = 0;
1664 mSrc.mIoData.output_count = bytes/sizeof(SRC16);
1665 mSrc.srcConvert();
1666 ret = mSrc.mIoData.output_count*sizeof(SRC16);
1667 if (ret > bytes) {
1668 ALOGE("read: buffer overrun");
1669 }
1670 }
1671 #else
1672 if (srcReqd) {
1673 ALOGE("%s: sample rate mismatch HAL %d, driver %d",
1674 __FUNCTION__, mSampleRate, mDriverRate);
1675 status = INVALID_OPERATION;
1676 goto error;
1677 }
1678 {
1679 Mutex::Autolock dfl(mFdLock);
1680 ret = ::read(mFd, buffer, bytes);
1681 }
1682 #endif
1683
1684 // It is not optimal to mute after all the above processing but it is necessary to
1685 // keep the clock sync from input device. It also avoids glitches on output streams due
1686 // to EC being turned on and off
1687 bool muted;
1688 mHardware->getMicMute(&muted);
1689 if (muted) {
1690 ALOGV("%s muted",__FUNCTION__);
1691 memset(buffer, 0, bytes);
1692 }
1693
1694 ALOGV("%s returns %d.",__FUNCTION__, (int)ret);
1695 if (ret < 0) {
1696 status = ret;
1697 goto error;
1698 }
1699
1700 {
1701 Mutex::Autolock _fl(mFramesLock);
1702 mTotalBuffersRead++;
1703 }
1704 return ret;
1705 }
1706
1707 error:
1708 ALOGE("read(): error, return %d", status);
1709 standby();
1710 usleep(bytes * 1000 / frameSize() / sampleRate() * 1000);
1711 return status;
1712 }
1713
getStandby() const1714 bool AudioHardware::AudioStreamInTegra::getStandby() const
1715 {
1716 return mState == AUDIO_STREAM_IDLE;
1717 }
1718
standby()1719 status_t AudioHardware::AudioStreamInTegra::standby()
1720 {
1721 if (!mHardware) {
1722 return NO_INIT;
1723 }
1724
1725 Mutex::Autolock lock(mHardware->mLock);
1726 Mutex::Autolock lock2(mLock);
1727 status_t status = NO_ERROR;
1728 if (mState != AUDIO_STREAM_IDLE) {
1729 ALOGV("input %p going into standby", this);
1730 mState = AUDIO_STREAM_IDLE;
1731 // stopping capture now so that the input stream state (AUDIO_STREAM_IDLE)
1732 // is consistent with the driver state when doRouting_l() is executed.
1733 // Not doing so makes that I2S reconfiguration fails when switching from
1734 // BT SCO to built-in mic.
1735 stop_l();
1736 // reset global pre processing state before disabling the input
1737 mHardware->setEcnsRequested_l(PREPROC_AEC|PREPROC_NS, false);
1738 // setDriver_l() will not try to lock mLock when called by doRouting_l()
1739 mLocked = true;
1740 mHardware->doRouting_l();
1741 mLocked = false;
1742 status = mHardware->doStandby(mFdCtl, false, true); // input, standby
1743 if (mFd >= 0) {
1744 ::close(mFd);
1745 mFd = -1;
1746 }
1747 if (mFdCtl >= 0) {
1748 ::close(mFdCtl);
1749 mFdCtl = -1;
1750 }
1751 }
1752
1753 return status;
1754 }
1755
1756 // Called with mLock and mHardware->mLock held
online_l()1757 status_t AudioHardware::AudioStreamInTegra::online_l()
1758 {
1759 status_t status = NO_ERROR;
1760
1761 reopenReconfigDriver();
1762
1763 if (mState < AUDIO_STREAM_NEW_RATE_REQ) {
1764
1765 // Use standby to flush the driver. mHardware->mLock should already be held
1766
1767 mHardware->doStandby(mFdCtl, false, true);
1768 if (mDevices & ~AudioSystem::DEVICE_IN_BLUETOOTH_SCO_HEADSET) {
1769 status = mHardware->doStandby(mFdCtl, false, false);
1770 }
1771
1772 if (mState == AUDIO_STREAM_IDLE) {
1773 mState = AUDIO_STREAM_CONFIG_REQ;
1774 ALOGV("input %p going online", this);
1775 // apply pre processing requested for this input
1776 mHardware->setEcnsRequested_l(mEcnsRequested, true);
1777 // setDriver_l() will not try to lock mLock when called by doRouting_l()
1778 mLocked = true;
1779 mHardware->doRouting_l();
1780 mLocked = false;
1781 {
1782 Mutex::Autolock _fl(mFramesLock);
1783 mTotalBuffersRead = 0;
1784 mStartTimeNs = systemTime();
1785 }
1786 }
1787
1788 // configuration
1789 struct tegra_audio_in_config config;
1790 status = ::ioctl(mFdCtl, TEGRA_AUDIO_IN_GET_CONFIG, &config);
1791 if (status < 0) {
1792 ALOGE("cannot read input config: %s", strerror(errno));
1793 return status;
1794 }
1795 config.stereo = AudioSystem::popCount(mChannels) == 2;
1796 config.rate = mHardware->mHwInRate;
1797 status = ::ioctl(mFdCtl, TEGRA_AUDIO_IN_SET_CONFIG, &config);
1798
1799 if (status < 0) {
1800 ALOGE("cannot set input config: %s", strerror(errno));
1801 if (::ioctl(mFdCtl, TEGRA_AUDIO_IN_GET_CONFIG, &config) == 0) {
1802 if (config.stereo) {
1803 mChannels = AudioSystem::CHANNEL_IN_STEREO;
1804 } else {
1805 mChannels = AudioSystem::CHANNEL_IN_MONO;
1806 }
1807 }
1808 }
1809
1810
1811 }
1812
1813 mDriverRate = mHardware->mHwInRate;
1814
1815 if (::ioctl(mHardware->mCpcapCtlFd, CPCAP_AUDIO_IN_SET_RATE,
1816 mDriverRate) < 0)
1817 ALOGE("could not set input rate(%d): %s", mDriverRate, strerror(errno));
1818
1819 mState = AUDIO_STREAM_CONFIGURED;
1820
1821 return status;
1822 }
1823
1824 // serves a similar purpose as the init() method of other classes
reopenReconfigDriver()1825 void AudioHardware::AudioStreamInTegra::reopenReconfigDriver()
1826 {
1827 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
1828 if (mHardware->mEcnsEnabled) {
1829 mHardware->mAudioPP.enableEcns(0);
1830 mHardware->mAudioPP.enableEcns(mHardware->mEcnsEnabled);
1831 }
1832 #endif
1833 // Need to "restart" the driver when changing the buffer configuration.
1834 if (mFdCtl >= 0 && ::ioctl(mFdCtl, TEGRA_AUDIO_IN_STOP) < 0) {
1835 ALOGE("%s: could not stop recording: %s", __FUNCTION__, strerror(errno));
1836 }
1837 if (mFd >= 0) {
1838 ::close(mFd);
1839 mFd = -1;
1840 }
1841 if (mFdCtl >= 0) {
1842 ::close(mFdCtl);
1843 mFdCtl = -1;
1844 }
1845
1846 // This does not have a retry loop to avoid blocking if another record session already in progress
1847 mFd = ::open("/dev/audio1_in", O_RDWR);
1848 if (mFd < 0) {
1849 ALOGE("open /dev/audio1_in failed: %s", strerror(errno));
1850 }
1851 mFdCtl = ::open("/dev/audio1_in_ctl", O_RDWR);
1852 if (mFdCtl < 0) {
1853 ALOGE("open /dev/audio1_in_ctl failed: %s", strerror(errno));
1854 if (mFd >= 0) {
1855 ::close(mFd);
1856 mFd = -1;
1857 }
1858 } else {
1859 // here we would set mInit = true;
1860 }
1861 }
1862
1863
dump(int fd,const Vector<String16> & args)1864 status_t AudioHardware::AudioStreamInTegra::dump(int fd, const Vector<String16>& args)
1865 {
1866 const size_t SIZE = 256;
1867 char buffer[SIZE];
1868 String8 result;
1869 result.append("AudioStreamInTegra::dump\n");
1870 snprintf(buffer, SIZE, "\tsample rate: %d\n", sampleRate());
1871 result.append(buffer);
1872 snprintf(buffer, SIZE, "\tbuffer size: %d\n", bufferSize());
1873 result.append(buffer);
1874 snprintf(buffer, SIZE, "\tchannels: %d\n", channels());
1875 result.append(buffer);
1876 snprintf(buffer, SIZE, "\tformat: %d\n", format());
1877 result.append(buffer);
1878 snprintf(buffer, SIZE, "\tmHardware: %p\n", mHardware);
1879 result.append(buffer);
1880 snprintf(buffer, SIZE, "\tmFd count: %d\n", mFd);
1881 result.append(buffer);
1882 snprintf(buffer, SIZE, "\tmState: %d\n", mState);
1883 result.append(buffer);
1884 snprintf(buffer, SIZE, "\tmRetryCount: %d\n", mRetryCount);
1885 result.append(buffer);
1886 ::write(fd, result.string(), result.size());
1887 return NO_ERROR;
1888 }
1889
setParameters(const String8 & keyValuePairs)1890 status_t AudioHardware::AudioStreamInTegra::setParameters(const String8& keyValuePairs)
1891 {
1892 AudioParameter param = AudioParameter(keyValuePairs);
1893 String8 key = String8(AudioParameter::keyRouting);
1894 status_t status = NO_ERROR;
1895 int device;
1896 int source;
1897 ALOGV("AudioStreamInTegra::setParameters() %s", keyValuePairs.string());
1898
1899 // read source before device so that it is upto date when doRouting() is called
1900 if (param.getInt(String8(AudioParameter::keyInputSource), source) == NO_ERROR) {
1901 mSource = source;
1902 param.remove(String8(AudioParameter::keyInputSource));
1903 }
1904
1905 if (param.getInt(key, device) == NO_ERROR) {
1906 ALOGV("set input routing %x", device);
1907 if (device & (device - 1)) {
1908 status = BAD_VALUE;
1909 } else {
1910 mDevices = device;
1911 if (!getStandby() && device != 0) {
1912 status = mHardware->doRouting();
1913 }
1914 }
1915 param.remove(key);
1916 }
1917
1918 if (param.size()) {
1919 status = BAD_VALUE;
1920 }
1921 return status;
1922 }
1923
getParameters(const String8 & keys)1924 String8 AudioHardware::AudioStreamInTegra::getParameters(const String8& keys)
1925 {
1926 AudioParameter param = AudioParameter(keys);
1927 String8 value;
1928 String8 key = String8(AudioParameter::keyRouting);
1929
1930 if (param.get(key, value) == NO_ERROR) {
1931 ALOGV("get routing %x", mDevices);
1932 param.addInt(key, (int)mDevices);
1933 }
1934
1935 ALOGV("AudioStreamInTegra::getParameters() %s", param.toString().string());
1936 return param.toString();
1937 }
1938
getInputFramesLost() const1939 unsigned int AudioHardware::AudioStreamInTegra::getInputFramesLost() const
1940 {
1941 Mutex::Autolock _l(mFramesLock);
1942 unsigned int lostFrames = 0;
1943 if (!getStandby()) {
1944 unsigned int framesPerBuffer = bufferSize() / frameSize();
1945 uint64_t expectedFrames = ((systemTime() - mStartTimeNs) * mSampleRate) / 1000000000;
1946 expectedFrames = (expectedFrames / framesPerBuffer) * framesPerBuffer;
1947 uint64_t actualFrames = (uint64_t)mTotalBuffersRead * framesPerBuffer;
1948 if (expectedFrames > actualFrames) {
1949 lostFrames = (unsigned int)(expectedFrames - actualFrames);
1950 ALOGW("getInputFramesLost() expected %d actual %d lost %d",
1951 (unsigned int)expectedFrames, (unsigned int)actualFrames, lostFrames);
1952 }
1953 }
1954
1955 mTotalBuffersRead = 0;
1956 mStartTimeNs = systemTime();
1957
1958 return lostFrames;
1959 }
1960
1961 // must be called with mLock and mFdLock held
stop_l()1962 void AudioHardware::AudioStreamInTegra::stop_l()
1963 {
1964 ALOGV("AudioStreamInTegra::stop_l() starts");
1965 if (::ioctl(mFdCtl, TEGRA_AUDIO_IN_STOP) < 0) {
1966 ALOGE("could not stop recording: %d %s", errno, strerror(errno));
1967 }
1968 ALOGV("AudioStreamInTegra::stop_l() returns");
1969 }
1970
updateEcnsRequested(effect_handle_t effect,bool enabled)1971 void AudioHardware::AudioStreamInTegra::updateEcnsRequested(effect_handle_t effect, bool enabled)
1972 {
1973 #ifdef USE_PROPRIETARY_AUDIO_EXTENSIONS
1974 effect_descriptor_t desc;
1975 status_t status = (*effect)->get_descriptor(effect, &desc);
1976 if (status == 0) {
1977 int ecns = 0;
1978 if (memcmp(&desc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) {
1979 ecns = PREPROC_AEC;
1980 } else if (memcmp(&desc.type, FX_IID_NS, sizeof(effect_uuid_t)) == 0) {
1981 ecns = PREPROC_NS;
1982 }
1983 ALOGV("AudioStreamInTegra::updateEcnsRequested() %s effect %s",
1984 enabled ? "enabling" : "disabling", desc.name);
1985 if (enabled) {
1986 mEcnsRequested |= ecns;
1987 } else {
1988 mEcnsRequested &= ~ecns;
1989 }
1990 standby();
1991 }
1992 #endif
1993 }
1994
addAudioEffect(effect_handle_t effect)1995 status_t AudioHardware::AudioStreamInTegra::addAudioEffect(effect_handle_t effect)
1996 {
1997 updateEcnsRequested(effect, true);
1998 return NO_ERROR;
1999 }
2000
removeAudioEffect(effect_handle_t effect)2001 status_t AudioHardware::AudioStreamInTegra::removeAudioEffect(effect_handle_t effect)
2002 {
2003 updateEcnsRequested(effect, false);
2004 return NO_ERROR;
2005 }
2006
2007 // ----------------------------------------------------------------------------
2008
createAudioHardware(void)2009 extern "C" AudioHardwareInterface* createAudioHardware(void) {
2010 AudioHardware *hw = new AudioHardware();
2011 for (unsigned tries = 0; tries < MAX_INIT_TRIES; ++tries) {
2012 if (NO_ERROR == hw->init())
2013 break;
2014 ALOGW("AudioHardware::init failed soft, retrying");
2015 sleep(1);
2016 }
2017 if (NO_ERROR != hw->initCheck()) {
2018 ALOGE("AudioHardware::init failed hard");
2019 delete hw;
2020 hw = NULL;
2021 }
2022 return hw;
2023 }
2024
2025 }; // namespace android
2026