Gitiles
Code Review Sign In
review.blissroms.org / platform_frameworks_native / edbf3b6af777b721cd2a1ef461947e51e88241e1 / . / libs / audioflinger / AudioFlinger.cpp
blob: 92c40e90dcd50b8ada5db7dcc1cd8abdd13ade95 [file] [log] [blame]
The Android Open Source Projectedbf3b62009-03-03 19:31:44 -0800[diff] [blame^]1/* //device/include/server/AudioFlinger/AudioFlinger.cpp
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
21
22#include <math.h>
23#include <signal.h>
24#include <sys/time.h>
25#include <sys/resource.h>
26
27#include <utils/IServiceManager.h>
28#include <utils/Log.h>
29#include <utils/Parcel.h>
30#include <utils/IPCThreadState.h>
31#include <utils/String16.h>
32#include <utils/threads.h>
33
34#include <cutils/properties.h>
35
36#include <media/AudioTrack.h>
37#include <media/AudioRecord.h>
38
39#include <private/media/AudioTrackShared.h>
40
41#include <hardware_legacy/AudioHardwareInterface.h>
42
43#include "AudioMixer.h"
44#include "AudioFlinger.h"
45
46#ifdef WITH_A2DP
47#include "A2dpAudioInterface.h"
48#endif
49
50// ----------------------------------------------------------------------------
51// the sim build doesn't have gettid
52
53#ifndef HAVE_GETTID
54# define gettid getpid
55#endif
56
57// ----------------------------------------------------------------------------
58
59namespace android {
60
61//static const nsecs_t kStandbyTimeInNsecs = seconds(3);
62static const unsigned long kBufferRecoveryInUsecs = 2000;
63static const unsigned long kMaxBufferRecoveryInUsecs = 20000;
64static const float MAX_GAIN = 4096.0f;
65
66// retry counts for buffer fill timeout
67// 50 * ~20msecs = 1 second
68static const int8_t kMaxTrackRetries = 50;
69static const int8_t kMaxTrackStartupRetries = 50;
70
71static const int kStartSleepTime = 30000;
72static const int kStopSleepTime = 30000;
73
74// Maximum number of pending buffers allocated by OutputTrack::write()
75static const uint8_t kMaxOutputTrackBuffers = 5;
76
77
78#define AUDIOFLINGER_SECURITY_ENABLED 1
79
80// ----------------------------------------------------------------------------
81
82static bool recordingAllowed() {
83#ifndef HAVE_ANDROID_OS
84 return true;
85#endif
86#if AUDIOFLINGER_SECURITY_ENABLED
87 if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
88 bool ok = checkCallingPermission(String16("android.permission.RECORD_AUDIO"));
89 if (!ok) LOGE("Request requires android.permission.RECORD_AUDIO");
90 return ok;
91#else
92 if (!checkCallingPermission(String16("android.permission.RECORD_AUDIO")))
93 LOGW("WARNING: Need to add android.permission.RECORD_AUDIO to manifest");
94 return true;
95#endif
96}
97
98static bool settingsAllowed() {
99#ifndef HAVE_ANDROID_OS
100 return true;
101#endif
102#if AUDIOFLINGER_SECURITY_ENABLED
103 if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
104 bool ok = checkCallingPermission(String16("android.permission.MODIFY_AUDIO_SETTINGS"));
105 if (!ok) LOGE("Request requires android.permission.MODIFY_AUDIO_SETTINGS");
106 return ok;
107#else
108 if (!checkCallingPermission(String16("android.permission.MODIFY_AUDIO_SETTINGS")))
109 LOGW("WARNING: Need to add android.permission.MODIFY_AUDIO_SETTINGS to manifest");
110 return true;
111#endif
112}
113
114// ----------------------------------------------------------------------------
115
116AudioFlinger::AudioFlinger()
117 : BnAudioFlinger(),
118 mAudioHardware(0), mA2dpAudioInterface(0),
119 mA2dpEnabled(false), mA2dpEnabledReq(false),
120 mForcedSpeakerCount(0), mForcedRoute(0), mRouteRestoreTime(0), mMusicMuteSaved(false)
121{
122 mHardwareStatus = AUDIO_HW_IDLE;
123 mAudioHardware = AudioHardwareInterface::create();
124 mHardwareStatus = AUDIO_HW_INIT;
125 if (mAudioHardware->initCheck() == NO_ERROR) {
126 // open 16-bit output stream for s/w mixer
127 mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
128 status_t status;
129 AudioStreamOut *hwOutput = mAudioHardware->openOutputStream(AudioSystem::PCM_16_BIT, 0, 0, &status);
130 mHardwareStatus = AUDIO_HW_IDLE;
131 if (hwOutput) {
132 mHardwareMixerThread = new MixerThread(this, hwOutput, AudioSystem::AUDIO_OUTPUT_HARDWARE);
133 } else {
134 LOGE("Failed to initialize hardware output stream, status: %d", status);
135 }
136
137#ifdef WITH_A2DP
138 // Create A2DP interface
139 mA2dpAudioInterface = new A2dpAudioInterface();
140 AudioStreamOut *a2dpOutput = mA2dpAudioInterface->openOutputStream(AudioSystem::PCM_16_BIT, 0, 0, &status);
141 if (a2dpOutput) {
142 mA2dpMixerThread = new MixerThread(this, a2dpOutput, AudioSystem::AUDIO_OUTPUT_A2DP);
143 if (hwOutput) {
144 uint32_t frameCount = ((a2dpOutput->bufferSize()/a2dpOutput->frameSize()) * hwOutput->sampleRate()) / a2dpOutput->sampleRate();
145 MixerThread::OutputTrack *a2dpOutTrack = new MixerThread::OutputTrack(mA2dpMixerThread,
146 hwOutput->sampleRate(),
147 AudioSystem::PCM_16_BIT,
148 hwOutput->channelCount(),
149 frameCount);
150 mHardwareMixerThread->setOuputTrack(a2dpOutTrack);
151 }
152 } else {
153 LOGE("Failed to initialize A2DP output stream, status: %d", status);
154 }
155#endif
156
157 // FIXME - this should come from settings
158 setRouting(AudioSystem::MODE_NORMAL, AudioSystem::ROUTE_SPEAKER, AudioSystem::ROUTE_ALL);
159 setRouting(AudioSystem::MODE_RINGTONE, AudioSystem::ROUTE_SPEAKER, AudioSystem::ROUTE_ALL);
160 setRouting(AudioSystem::MODE_IN_CALL, AudioSystem::ROUTE_EARPIECE, AudioSystem::ROUTE_ALL);
161 setMode(AudioSystem::MODE_NORMAL);
162
163 setMasterVolume(1.0f);
164 setMasterMute(false);
165
166 // Start record thread
167 mAudioRecordThread = new AudioRecordThread(mAudioHardware);
168 if (mAudioRecordThread != 0) {
169 mAudioRecordThread->run("AudioRecordThread", PRIORITY_URGENT_AUDIO);
170 }
171 } else {
172 LOGE("Couldn't even initialize the stubbed audio hardware!");
173 }
174}
175
176AudioFlinger::~AudioFlinger()
177{
178 if (mAudioRecordThread != 0) {
179 mAudioRecordThread->exit();
180 mAudioRecordThread.clear();
181 }
182 mHardwareMixerThread.clear();
183 delete mAudioHardware;
184 // deleting mA2dpAudioInterface also deletes mA2dpOutput;
185#ifdef WITH_A2DP
186 mA2dpMixerThread.clear();
187 delete mA2dpAudioInterface;
188#endif
189}
190
191
192#ifdef WITH_A2DP
193void AudioFlinger::setA2dpEnabled(bool enable)
194{
195 LOGV_IF(enable, "set output to A2DP\n");
196 LOGV_IF(!enable, "set output to hardware audio\n");
197
198 mA2dpEnabledReq = enable;
199 mA2dpMixerThread->wakeUp();
200}
201#endif // WITH_A2DP
202
203bool AudioFlinger::streamForcedToSpeaker(int streamType)
204{
205 // NOTE that streams listed here must not be routed to A2DP by default:
206 // AudioSystem::routedToA2dpOutput(streamType) == false
207 return (streamType == AudioSystem::RING ||
208 streamType == AudioSystem::ALARM ||
209 streamType == AudioSystem::NOTIFICATION);
210}
211
212status_t AudioFlinger::dumpClients(int fd, const Vector<String16>& args)
213{
214 const size_t SIZE = 256;
215 char buffer[SIZE];
216 String8 result;
217
218 result.append("Clients:\n");
219 for (size_t i = 0; i < mClients.size(); ++i) {
220 wp<Client> wClient = mClients.valueAt(i);
221 if (wClient != 0) {
222 sp<Client> client = wClient.promote();
223 if (client != 0) {
224 snprintf(buffer, SIZE, " pid: %d\n", client->pid());
225 result.append(buffer);
226 }
227 }
228 }
229 write(fd, result.string(), result.size());
230 return NO_ERROR;
231}
232
233
234status_t AudioFlinger::dumpInternals(int fd, const Vector<String16>& args)
235{
236 const size_t SIZE = 256;
237 char buffer[SIZE];
238 String8 result;
239
240 snprintf(buffer, SIZE, "Hardware status: %d\n", mHardwareStatus);
241 result.append(buffer);
242 write(fd, result.string(), result.size());
243 return NO_ERROR;
244}
245
246status_t AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args)
247{
248 const size_t SIZE = 256;
249 char buffer[SIZE];
250 String8 result;
251 snprintf(buffer, SIZE, "Permission Denial: "
252 "can't dump AudioFlinger from pid=%d, uid=%d\n",
253 IPCThreadState::self()->getCallingPid(),
254 IPCThreadState::self()->getCallingUid());
255 result.append(buffer);
256 write(fd, result.string(), result.size());
257 return NO_ERROR;
258}
259
260status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
261{
262 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
263 dumpPermissionDenial(fd, args);
264 } else {
265 AutoMutex lock(&mLock);
266
267 dumpClients(fd, args);
268 dumpInternals(fd, args);
269 mHardwareMixerThread->dump(fd, args);
270#ifdef WITH_A2DP
271 mA2dpMixerThread->dump(fd, args);
272#endif
273
274 // dump record client
275 if (mAudioRecordThread != 0) mAudioRecordThread->dump(fd, args);
276
277 if (mAudioHardware) {
278 mAudioHardware->dumpState(fd, args);
279 }
280 }
281 return NO_ERROR;
282}
283
284// IAudioFlinger interface
285
286
287sp<IAudioTrack> AudioFlinger::createTrack(
288 pid_t pid,
289 int streamType,
290 uint32_t sampleRate,
291 int format,
292 int channelCount,
293 int frameCount,
294 uint32_t flags,
295 const sp<IMemory>& sharedBuffer,
296 status_t *status)
297{
298 sp<MixerThread::Track> track;
299 sp<TrackHandle> trackHandle;
300 sp<Client> client;
301 wp<Client> wclient;
302 status_t lStatus;
303
304 if (streamType >= AudioSystem::NUM_STREAM_TYPES) {
305 LOGE("invalid stream type");
306 lStatus = BAD_VALUE;
307 goto Exit;
308 }
309
310 {
311 Mutex::Autolock _l(mLock);
312
313 wclient = mClients.valueFor(pid);
314
315 if (wclient != NULL) {
316 client = wclient.promote();
317 } else {
318 client = new Client(this, pid);
319 mClients.add(pid, client);
320 }
321#ifdef WITH_A2DP
322 if (isA2dpEnabled() && AudioSystem::routedToA2dpOutput(streamType)) {
323 track = mA2dpMixerThread->createTrack(client, streamType, sampleRate, format,
324 channelCount, frameCount, sharedBuffer, &lStatus);
325 } else
326#endif
327 {
328 track = mHardwareMixerThread->createTrack(client, streamType, sampleRate, format,
329 channelCount, frameCount, sharedBuffer, &lStatus);
330 }
331 if (track != NULL) {
332 trackHandle = new TrackHandle(track);
333 lStatus = NO_ERROR;
334 }
335 }
336
337Exit:
338 if(status) {
339 *status = lStatus;
340 }
341 return trackHandle;
342}
343
344uint32_t AudioFlinger::sampleRate(int output) const
345{
346#ifdef WITH_A2DP
347 if (output == AudioSystem::AUDIO_OUTPUT_A2DP) {
348 return mA2dpMixerThread->sampleRate();
349 }
350#endif
351 return mHardwareMixerThread->sampleRate();
352}
353
354int AudioFlinger::channelCount(int output) const
355{
356#ifdef WITH_A2DP
357 if (output == AudioSystem::AUDIO_OUTPUT_A2DP) {
358 return mA2dpMixerThread->channelCount();
359 }
360#endif
361 return mHardwareMixerThread->channelCount();
362}
363
364int AudioFlinger::format(int output) const
365{
366#ifdef WITH_A2DP
367 if (output == AudioSystem::AUDIO_OUTPUT_A2DP) {
368 return mA2dpMixerThread->format();
369 }
370#endif
371 return mHardwareMixerThread->format();
372}
373
374size_t AudioFlinger::frameCount(int output) const
375{
376#ifdef WITH_A2DP
377 if (output == AudioSystem::AUDIO_OUTPUT_A2DP) {
378 return mA2dpMixerThread->frameCount();
379 }
380#endif
381 return mHardwareMixerThread->frameCount();
382}
383
384uint32_t AudioFlinger::latency(int output) const
385{
386#ifdef WITH_A2DP
387 if (output == AudioSystem::AUDIO_OUTPUT_A2DP) {
388 return mA2dpMixerThread->latency();
389 }
390#endif
391 return mHardwareMixerThread->latency();
392}
393
394status_t AudioFlinger::setMasterVolume(float value)
395{
396 // check calling permissions
397 if (!settingsAllowed()) {
398 return PERMISSION_DENIED;
399 }
400
401 // when hw supports master volume, don't scale in sw mixer
402 AutoMutex lock(mHardwareLock);
403 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
404 if (mAudioHardware->setMasterVolume(value) == NO_ERROR) {
405 value = 1.0f;
406 }
407 mHardwareStatus = AUDIO_HW_IDLE;
408 mHardwareMixerThread->setMasterVolume(value);
409#ifdef WITH_A2DP
410 mA2dpMixerThread->setMasterVolume(value);
411#endif
412
413 return NO_ERROR;
414}
415
416status_t AudioFlinger::setRouting(int mode, uint32_t routes, uint32_t mask)
417{
418 status_t err = NO_ERROR;
419
420 // check calling permissions
421 if (!settingsAllowed()) {
422 return PERMISSION_DENIED;
423 }
424 if ((mode < AudioSystem::MODE_CURRENT) || (mode >= AudioSystem::NUM_MODES)) {
425 LOGW("Illegal value: setRouting(%d, %u, %u)", mode, routes, mask);
426 return BAD_VALUE;
427 }
428
429#ifdef WITH_A2DP
430 LOGD("setRouting %d %d %d, tid %d, calling tid %d\n", mode, routes, mask, gettid(), IPCThreadState::self()->getCallingPid());
431 if (mode == AudioSystem::MODE_NORMAL &&
432 (mask & AudioSystem::ROUTE_BLUETOOTH_A2DP)) {
433 AutoMutex lock(&mLock);
434
435 bool enableA2dp = false;
436 if (routes & AudioSystem::ROUTE_BLUETOOTH_A2DP) {
437 enableA2dp = true;
438 }
439 setA2dpEnabled(enableA2dp);
440 LOGV("setOutput done\n");
441 }
442#endif
443
444 // do nothing if only A2DP routing is affected
445 mask &= ~AudioSystem::ROUTE_BLUETOOTH_A2DP;
446 if (mask) {
447 AutoMutex lock(mHardwareLock);
448 mHardwareStatus = AUDIO_HW_GET_ROUTING;
449 uint32_t r;
450 err = mAudioHardware->getRouting(mode, &r);
451 if (err == NO_ERROR) {
452 r = (r & ~mask) | (routes & mask);
453 if (mode == AudioSystem::MODE_NORMAL ||
454 (mode == AudioSystem::MODE_CURRENT && getMode() == AudioSystem::MODE_NORMAL)) {
455 mSavedRoute = r;
456 r |= mForcedRoute;
457 LOGV("setRouting mSavedRoute %08x mForcedRoute %08x\n", mSavedRoute, mForcedRoute);
458 }
459 mHardwareStatus = AUDIO_HW_SET_ROUTING;
460 err = mAudioHardware->setRouting(mode, r);
461 }
462 mHardwareStatus = AUDIO_HW_IDLE;
463 }
464 return err;
465}
466
467uint32_t AudioFlinger::getRouting(int mode) const
468{
469 uint32_t routes = 0;
470 if ((mode >= AudioSystem::MODE_CURRENT) && (mode < AudioSystem::NUM_MODES)) {
471 if (mode == AudioSystem::MODE_NORMAL ||
472 (mode == AudioSystem::MODE_CURRENT && getMode() == AudioSystem::MODE_NORMAL)) {
473 routes = mSavedRoute;
474 } else {
475 mHardwareStatus = AUDIO_HW_GET_ROUTING;
476 mAudioHardware->getRouting(mode, &routes);
477 mHardwareStatus = AUDIO_HW_IDLE;
478 }
479 } else {
480 LOGW("Illegal value: getRouting(%d)", mode);
481 }
482 return routes;
483}
484
485status_t AudioFlinger::setMode(int mode)
486{
487 // check calling permissions
488 if (!settingsAllowed()) {
489 return PERMISSION_DENIED;
490 }
491 if ((mode < 0) || (mode >= AudioSystem::NUM_MODES)) {
492 LOGW("Illegal value: setMode(%d)", mode);
493 return BAD_VALUE;
494 }
495
496 AutoMutex lock(mHardwareLock);
497 mHardwareStatus = AUDIO_HW_SET_MODE;
498 status_t ret = mAudioHardware->setMode(mode);
499 mHardwareStatus = AUDIO_HW_IDLE;
500 return ret;
501}
502
503int AudioFlinger::getMode() const
504{
505 int mode = AudioSystem::MODE_INVALID;
506 mHardwareStatus = AUDIO_HW_SET_MODE;
507 mAudioHardware->getMode(&mode);
508 mHardwareStatus = AUDIO_HW_IDLE;
509 return mode;
510}
511
512status_t AudioFlinger::setMicMute(bool state)
513{
514 // check calling permissions
515 if (!settingsAllowed()) {
516 return PERMISSION_DENIED;
517 }
518
519 AutoMutex lock(mHardwareLock);
520 mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
521 status_t ret = mAudioHardware->setMicMute(state);
522 mHardwareStatus = AUDIO_HW_IDLE;
523 return ret;
524}
525
526bool AudioFlinger::getMicMute() const
527{
528 bool state = AudioSystem::MODE_INVALID;
529 mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
530 mAudioHardware->getMicMute(&state);
531 mHardwareStatus = AUDIO_HW_IDLE;
532 return state;
533}
534
535status_t AudioFlinger::setMasterMute(bool muted)
536{
537 // check calling permissions
538 if (!settingsAllowed()) {
539 return PERMISSION_DENIED;
540 }
541 mHardwareMixerThread->setMasterMute(muted);
542#ifdef WITH_A2DP
543 mA2dpMixerThread->setMasterMute(muted);
544#endif
545 return NO_ERROR;
546}
547
548float AudioFlinger::masterVolume() const
549{
550 return mHardwareMixerThread->masterVolume();
551}
552
553bool AudioFlinger::masterMute() const
554{
555 return mHardwareMixerThread->masterMute();
556}
557
558status_t AudioFlinger::setStreamVolume(int stream, float value)
559{
560 // check calling permissions
561 if (!settingsAllowed()) {
562 return PERMISSION_DENIED;
563 }
564
565 if (uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) {
566 return BAD_VALUE;
567 }
568
569 mHardwareMixerThread->setStreamVolume(stream, value);
570#ifdef WITH_A2DP
571 mA2dpMixerThread->setStreamVolume(stream, value);
572#endif
573
574 status_t ret = NO_ERROR;
575 if (stream == AudioSystem::VOICE_CALL ||
576 stream == AudioSystem::BLUETOOTH_SCO) {
577
578 if (stream == AudioSystem::VOICE_CALL) {
579 value = (float)AudioSystem::logToLinear(value)/100.0f;
580 } else { // (type == AudioSystem::BLUETOOTH_SCO)
581 value = 1.0f;
582 }
583
584 AutoMutex lock(mHardwareLock);
585 mHardwareStatus = AUDIO_SET_VOICE_VOLUME;
586 ret = mAudioHardware->setVoiceVolume(value);
587 mHardwareStatus = AUDIO_HW_IDLE;
588 }
589
590 return ret;
591}
592
593status_t AudioFlinger::setStreamMute(int stream, bool muted)
594{
595 // check calling permissions
596 if (!settingsAllowed()) {
597 return PERMISSION_DENIED;
598 }
599
600 if (uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) {
601 return BAD_VALUE;
602 }
603
604#ifdef WITH_A2DP
605 mA2dpMixerThread->setStreamMute(stream, muted);
606#endif
607 if (stream == AudioSystem::MUSIC)
608 {
609 AutoMutex lock(&mHardwareLock);
610 if (mForcedRoute != 0)
611 mMusicMuteSaved = muted;
612 else
613 mHardwareMixerThread->setStreamMute(stream, muted);
614 } else {
615 mHardwareMixerThread->setStreamMute(stream, muted);
616 }
617
618
619
620 return NO_ERROR;
621}
622
623float AudioFlinger::streamVolume(int stream) const
624{
625 if (uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) {
626 return 0.0f;
627 }
628 return mHardwareMixerThread->streamVolume(stream);
629}
630
631bool AudioFlinger::streamMute(int stream) const
632{
633 if (uint32_t(stream) >= AudioSystem::NUM_STREAM_TYPES) {
634 return true;
635 }
636
637 if (stream == AudioSystem::MUSIC && mForcedRoute != 0)
638 {
639 return mMusicMuteSaved;
640 }
641 return mHardwareMixerThread->streamMute(stream);
642}
643
644bool AudioFlinger::isMusicActive() const
645{
646 #ifdef WITH_A2DP
647 if (isA2dpEnabled()) {
648 return mA2dpMixerThread->isMusicActive();
649 }
650 #endif
651 return mHardwareMixerThread->isMusicActive();
652}
653
654status_t AudioFlinger::setParameter(const char* key, const char* value)
655{
656 status_t result, result2;
657 AutoMutex lock(mHardwareLock);
658 mHardwareStatus = AUDIO_SET_PARAMETER;
659
660 LOGV("setParameter() key %s, value %s, tid %d, calling tid %d", key, value, gettid(), IPCThreadState::self()->getCallingPid());
661 result = mAudioHardware->setParameter(key, value);
662 if (mA2dpAudioInterface) {
663 result2 = mA2dpAudioInterface->setParameter(key, value);
664 if (result2)
665 result = result2;
666 }
667 mHardwareStatus = AUDIO_HW_IDLE;
668 return result;
669}
670
671size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
672{
673 return mAudioHardware->getInputBufferSize(sampleRate, format, channelCount);
674}
675
676void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client)
677{
678
679 LOGV("registerClient() %p, tid %d, calling tid %d", client.get(), gettid(), IPCThreadState::self()->getCallingPid());
680 Mutex::Autolock _l(mLock);
681
682 sp<IBinder> binder = client->asBinder();
683 if (mNotificationClients.indexOf(binder) < 0) {
684 LOGV("Adding notification client %p", binder.get());
685 binder->linkToDeath(this);
686 mNotificationClients.add(binder);
687 client->a2dpEnabledChanged(isA2dpEnabled());
688 }
689}
690
691void AudioFlinger::binderDied(const wp<IBinder>& who) {
692
693 LOGV("binderDied() %p, tid %d, calling tid %d", who.unsafe_get(), gettid(), IPCThreadState::self()->getCallingPid());
694 Mutex::Autolock _l(mLock);
695
696 IBinder *binder = who.unsafe_get();
697
698 if (binder != NULL) {
699 int index = mNotificationClients.indexOf(binder);
700 if (index >= 0) {
701 LOGV("Removing notification client %p", binder);
702 mNotificationClients.removeAt(index);
703 }
704 }
705}
706
707void AudioFlinger::handleOutputSwitch()
708{
709 if (mA2dpEnabled != mA2dpEnabledReq)
710 {
711 Mutex::Autolock _l(mLock);
712
713 if (mA2dpEnabled != mA2dpEnabledReq)
714 {
715 mA2dpEnabled = mA2dpEnabledReq;
716 SortedVector < sp<MixerThread::Track> > tracks;
717 SortedVector < wp<MixerThread::Track> > activeTracks;
718
719 // We hold mA2dpMixerThread mLock already
720 Mutex::Autolock _l(mHardwareMixerThread->mLock);
721
722 // Transfer tracks playing on MUSIC stream from one mixer to the other
723 if (mA2dpEnabled) {
724 mHardwareMixerThread->getTracks(tracks, activeTracks);
725 mA2dpMixerThread->putTracks(tracks, activeTracks);
726 } else {
727 mA2dpMixerThread->getTracks(tracks, activeTracks);
728 mHardwareMixerThread->putTracks(tracks, activeTracks);
729 }
730
731 // Notify AudioSystem of the A2DP activation/deactivation
732 size_t size = mNotificationClients.size();
733 for (size_t i = 0; i < size; i++) {
734 sp<IBinder> binder = mNotificationClients.itemAt(i).promote();
735 if (binder != NULL) {
736 LOGV("Notifying output change to client %p", binder.get());
737 sp<IAudioFlingerClient> client = interface_cast<IAudioFlingerClient> (binder);
738 client->a2dpEnabledChanged(mA2dpEnabled);
739 }
740 }
741
742 mHardwareMixerThread->wakeUp();
743 }
744 }
745}
746
747void AudioFlinger::removeClient(pid_t pid)
748{
749 LOGV("removeClient() pid %d, tid %d, calling tid %d", pid, gettid(), IPCThreadState::self()->getCallingPid());
750 Mutex::Autolock _l(mLock);
751 mClients.removeItem(pid);
752}
753
754void AudioFlinger::wakeUp()
755{
756 mHardwareMixerThread->wakeUp();
757#ifdef WITH_A2DP
758 mA2dpMixerThread->wakeUp();
759#endif // WITH_A2DP
760}
761
762bool AudioFlinger::isA2dpEnabled() const
763{
764 return mA2dpEnabledReq;
765}
766
767void AudioFlinger::handleForcedSpeakerRoute(int command)
768{
769 switch(command) {
770 case ACTIVE_TRACK_ADDED:
771 {
772 AutoMutex lock(mHardwareLock);
773 if (mForcedSpeakerCount++ == 0) {
774 mRouteRestoreTime = 0;
775 mMusicMuteSaved = mHardwareMixerThread->streamMute(AudioSystem::MUSIC);
776 if (mForcedRoute == 0 && !(mSavedRoute & AudioSystem::ROUTE_SPEAKER)) {
777 LOGV("Route forced to Speaker ON %08x", mSavedRoute | AudioSystem::ROUTE_SPEAKER);
778 mHardwareMixerThread->setStreamMute(AudioSystem::MUSIC, true);
779 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
780 mAudioHardware->setMasterVolume(0);
781 usleep(mHardwareMixerThread->latency()*1000);
782 mHardwareStatus = AUDIO_HW_SET_ROUTING;
783 mAudioHardware->setRouting(AudioSystem::MODE_NORMAL, mSavedRoute | AudioSystem::ROUTE_SPEAKER);
784 mHardwareStatus = AUDIO_HW_IDLE;
785 // delay track start so that audio hardware has time to siwtch routes
786 usleep(kStartSleepTime);
787 mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
788 mAudioHardware->setMasterVolume(mHardwareMixerThread->masterVolume());
789 mHardwareStatus = AUDIO_HW_IDLE;
790 }
791 mForcedRoute = AudioSystem::ROUTE_SPEAKER;
792 }
793 LOGV("mForcedSpeakerCount incremented to %d", mForcedSpeakerCount);
794 }
795 break;
796 case ACTIVE_TRACK_REMOVED:
797 {
798 AutoMutex lock(mHardwareLock);
799 if (mForcedSpeakerCount > 0){
800 if (--mForcedSpeakerCount == 0) {
801 mRouteRestoreTime = systemTime() + milliseconds(kStopSleepTime/1000);
802 }
803 LOGV("mForcedSpeakerCount decremented to %d", mForcedSpeakerCount);
804 } else {
805 LOGE("mForcedSpeakerCount is already zero");
806 }
807 }
808 break;
809 case CHECK_ROUTE_RESTORE_TIME:
810 case FORCE_ROUTE_RESTORE:
811 if (mRouteRestoreTime) {
812 AutoMutex lock(mHardwareLock);
813 if (mRouteRestoreTime &&
814 (systemTime() > mRouteRestoreTime || command == FORCE_ROUTE_RESTORE)) {
815 mHardwareMixerThread->setStreamMute(AudioSystem::MUSIC, mMusicMuteSaved);
816 mForcedRoute = 0;
817 if (!(mSavedRoute & AudioSystem::ROUTE_SPEAKER)) {
818 mHardwareStatus = AUDIO_HW_SET_ROUTING;
819 mAudioHardware->setRouting(AudioSystem::MODE_NORMAL, mSavedRoute);
820 mHardwareStatus = AUDIO_HW_IDLE;
821 LOGV("Route forced to Speaker OFF %08x", mSavedRoute);
822 }
823 mRouteRestoreTime = 0;
824 }
825 }
826 break;
827 }
828}
829
830
831// ----------------------------------------------------------------------------
832
833AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int outputType)
834 : Thread(false),
835 mAudioFlinger(audioFlinger), mAudioMixer(0), mOutput(output), mOutputType(outputType),
836 mSampleRate(0), mFrameCount(0), mChannelCount(0), mFormat(0), mMixBuffer(0),
837 mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mStandby(false),
838 mInWrite(false)
839{
840 mSampleRate = output->sampleRate();
841 mChannelCount = output->channelCount();
842
843 // FIXME - Current mixer implementation only supports stereo output
844 if (mChannelCount == 1) {
845 LOGE("Invalid audio hardware channel count");
846 }
847
848 mFormat = output->format();
849 mFrameCount = output->bufferSize() / output->channelCount() / sizeof(int16_t);
850 mAudioMixer = new AudioMixer(mFrameCount, output->sampleRate());
851
852 // FIXME - Current mixer implementation only supports stereo output: Always
853 // Allocate a stereo buffer even if HW output is mono.
854 mMixBuffer = new int16_t[mFrameCount * 2];
855 memset(mMixBuffer, 0, mFrameCount * 2 * sizeof(int16_t));
856}
857
858AudioFlinger::MixerThread::~MixerThread()
859{
860 delete [] mMixBuffer;
861 delete mAudioMixer;
862}
863
864status_t AudioFlinger::MixerThread::dump(int fd, const Vector<String16>& args)
865{
866 dumpInternals(fd, args);
867 dumpTracks(fd, args);
868 return NO_ERROR;
869}
870
871status_t AudioFlinger::MixerThread::dumpTracks(int fd, const Vector<String16>& args)
872{
873 const size_t SIZE = 256;
874 char buffer[SIZE];
875 String8 result;
876
877 snprintf(buffer, SIZE, "Output %d mixer thread tracks\n", mOutputType);
878 result.append(buffer);
879 result.append(" Name Clien Typ Fmt Chn Buf S M F SRate LeftV RighV Serv User\n");
880 for (size_t i = 0; i < mTracks.size(); ++i) {
881 wp<Track> wTrack = mTracks[i];
882 if (wTrack != 0) {
883 sp<Track> track = wTrack.promote();
884 if (track != 0) {
885 track->dump(buffer, SIZE);
886 result.append(buffer);
887 }
888 }
889 }
890
891 snprintf(buffer, SIZE, "Output %d mixer thread active tracks\n", mOutputType);
892 result.append(buffer);
893 result.append(" Name Clien Typ Fmt Chn Buf S M F SRate LeftV RighV Serv User\n");
894 for (size_t i = 0; i < mActiveTracks.size(); ++i) {
895 wp<Track> wTrack = mTracks[i];
896 if (wTrack != 0) {
897 sp<Track> track = wTrack.promote();
898 if (track != 0) {
899 track->dump(buffer, SIZE);
900 result.append(buffer);
901 }
902 }
903 }
904 write(fd, result.string(), result.size());
905 return NO_ERROR;
906}
907
908status_t AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16>& args)
909{
910 const size_t SIZE = 256;
911 char buffer[SIZE];
912 String8 result;
913
914 snprintf(buffer, SIZE, "Output %d mixer thread internals\n", mOutputType);
915 result.append(buffer);
916 snprintf(buffer, SIZE, "AudioMixer tracks: %08x\n", mAudioMixer->trackNames());
917 result.append(buffer);
918 snprintf(buffer, SIZE, "last write occurred (msecs): %llu\n", ns2ms(systemTime() - mLastWriteTime));
919 result.append(buffer);
920 snprintf(buffer, SIZE, "total writes: %d\n", mNumWrites);
921 result.append(buffer);
922 snprintf(buffer, SIZE, "delayed writes: %d\n", mNumDelayedWrites);
923 result.append(buffer);
924 snprintf(buffer, SIZE, "blocked in write: %d\n", mInWrite);
925 result.append(buffer);
926 snprintf(buffer, SIZE, "standby: %d\n", mStandby);
927 result.append(buffer);
928 write(fd, result.string(), result.size());
929 return NO_ERROR;
930}
931
932// Thread virtuals
933bool AudioFlinger::MixerThread::threadLoop()
934{
935 unsigned long sleepTime = kBufferRecoveryInUsecs;
936 int16_t* curBuf = mMixBuffer;
937 Vector< sp<Track> > tracksToRemove;
938 size_t enabledTracks = 0;
939 nsecs_t standbyTime = systemTime();
940 size_t mixBufferSize = mFrameCount*mChannelCount*sizeof(int16_t);
941 nsecs_t maxPeriod = seconds(mFrameCount) / mSampleRate * 2;
942
943#ifdef WITH_A2DP
944 bool outputTrackActive = false;
945#endif
946
947 do {
948 enabledTracks = 0;
949 { // scope for the mLock
950
951 Mutex::Autolock _l(mLock);
952
953#ifdef WITH_A2DP
954 if (mOutputType == AudioSystem::AUDIO_OUTPUT_A2DP) {
955 mAudioFlinger->handleOutputSwitch();
956 }
957 if (mOutputTrack != NULL && !mAudioFlinger->isA2dpEnabled()) {
958 if (outputTrackActive) {
959 mOutputTrack->stop();
960 outputTrackActive = false;
961 }
962 }
963#endif
964
965 const SortedVector< wp<Track> >& activeTracks = mActiveTracks;
966
967 // put audio hardware into standby after short delay
968 if UNLIKELY(!activeTracks.size() && systemTime() > standbyTime) {
969 // wait until we have something to do...
970 LOGV("Audio hardware entering standby, output %d\n", mOutputType);
971// mAudioFlinger->mHardwareStatus = AUDIO_HW_STANDBY;
972 if (!mStandby) {
973 mOutput->standby();
974 mStandby = true;
975 }
976
977#ifdef WITH_A2DP
978 if (outputTrackActive) {
979 mOutputTrack->stop();
980 outputTrackActive = false;
981 }
982#endif
983 if (mOutputType == AudioSystem::AUDIO_OUTPUT_HARDWARE) {
984 mAudioFlinger->handleForcedSpeakerRoute(FORCE_ROUTE_RESTORE);
985 }
986// mHardwareStatus = AUDIO_HW_IDLE;
987 // we're about to wait, flush the binder command buffer
988 IPCThreadState::self()->flushCommands();
989 mWaitWorkCV.wait(mLock);
990 LOGV("Audio hardware exiting standby, output %d\n", mOutputType);
991
992 if (mMasterMute == false) {
993 char value[PROPERTY_VALUE_MAX];
994 property_get("ro.audio.silent", value, "0");
995 if (atoi(value)) {
996 LOGD("Silence is golden");
997 setMasterMute(true);
998 }
999 }
1000
1001 standbyTime = systemTime() + kStandbyTimeInNsecs;
1002 continue;
1003 }
1004
1005 // Forced route to speaker is handled by hardware mixer thread
1006 if (mOutputType == AudioSystem::AUDIO_OUTPUT_HARDWARE) {
1007 mAudioFlinger->handleForcedSpeakerRoute(CHECK_ROUTE_RESTORE_TIME);
1008 }
1009
1010 // find out which tracks need to be processed
1011 size_t count = activeTracks.size();
1012 for (size_t i=0 ; i<count ; i++) {
1013 sp<Track> t = activeTracks[i].promote();
1014 if (t == 0) continue;
1015
1016 Track* const track = t.get();
1017 audio_track_cblk_t* cblk = track->cblk();
1018
1019 // The first time a track is added we wait
1020 // for all its buffers to be filled before processing it
1021 mAudioMixer->setActiveTrack(track->name());
1022 if (cblk->framesReady() && (track->isReady() || track->isStopped()) &&
1023 !track->isPaused())
1024 {
1025 //LOGV("track %d u=%08x, s=%08x [OK]", track->name(), cblk->user, cblk->server);
1026
1027 // compute volume for this track
1028 int16_t left, right;
1029 if (track->isMuted() || mMasterMute || track->isPausing()) {
1030 left = right = 0;
1031 if (track->isPausing()) {
1032 LOGV("paused(%d)", track->name());
1033 track->setPaused();
1034 }
1035 } else {
1036 float typeVolume = mStreamTypes[track->type()].volume;
1037 float v = mMasterVolume * typeVolume;
1038 float v_clamped = v * cblk->volume[0];
1039 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
1040 left = int16_t(v_clamped);
1041 v_clamped = v * cblk->volume[1];
1042 if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
1043 right = int16_t(v_clamped);
1044 }
1045
1046 // XXX: these things DON'T need to be done each time
1047 mAudioMixer->setBufferProvider(track);
1048 mAudioMixer->enable(AudioMixer::MIXING);
1049
1050 int param;
1051 if ( track->mFillingUpStatus == Track::FS_FILLED) {
1052 // no ramp for the first volume setting
1053 track->mFillingUpStatus = Track::FS_ACTIVE;
1054 if (track->mState == TrackBase::RESUMING) {
1055 track->mState = TrackBase::ACTIVE;
1056 param = AudioMixer::RAMP_VOLUME;
1057 } else {
1058 param = AudioMixer::VOLUME;
1059 }
1060 } else {
1061 param = AudioMixer::RAMP_VOLUME;
1062 }
1063 mAudioMixer->setParameter(param, AudioMixer::VOLUME0, left);
1064 mAudioMixer->setParameter(param, AudioMixer::VOLUME1, right);
1065 mAudioMixer->setParameter(
1066 AudioMixer::TRACK,
1067 AudioMixer::FORMAT, track->format());
1068 mAudioMixer->setParameter(
1069 AudioMixer::TRACK,
1070 AudioMixer::CHANNEL_COUNT, track->channelCount());
1071 mAudioMixer->setParameter(
1072 AudioMixer::RESAMPLE,
1073 AudioMixer::SAMPLE_RATE,
1074 int(cblk->sampleRate));
1075
1076 // reset retry count
1077 track->mRetryCount = kMaxTrackRetries;
1078 enabledTracks++;
1079 } else {
1080 //LOGV("track %d u=%08x, s=%08x [NOT READY]", track->name(), cblk->user, cblk->server);
1081 if (track->isStopped()) {
1082 track->reset();
1083 }
1084 if (track->isTerminated() || track->isStopped() || track->isPaused()) {
1085 // We have consumed all the buffers of this track.
1086 // Remove it from the list of active tracks.
1087 LOGV("remove(%d) from active list", track->name());
1088 tracksToRemove.add(track);
1089 } else {
1090 // No buffers for this track. Give it a few chances to
1091 // fill a buffer, then remove it from active list.
1092 if (--(track->mRetryCount) <= 0) {
1093 LOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name());
1094 tracksToRemove.add(track);
1095 }
1096 }
1097 // LOGV("disable(%d)", track->name());
1098 mAudioMixer->disable(AudioMixer::MIXING);
1099 }
1100 }
1101
1102 // remove all the tracks that need to be...
1103 count = tracksToRemove.size();
1104 if (UNLIKELY(count)) {
1105 for (size_t i=0 ; i<count ; i++) {
1106 const sp<Track>& track = tracksToRemove[i];
1107 removeActiveTrack(track);
1108 if (track->isTerminated()) {
1109 mTracks.remove(track);
1110 deleteTrackName(track->mName);
1111 }
1112 }
1113 }
1114 }
1115
1116 if (LIKELY(enabledTracks)) {
1117 // mix buffers...
1118 mAudioMixer->process(curBuf);
1119
1120#ifdef WITH_A2DP
1121 if (mOutputTrack != NULL && mAudioFlinger->isA2dpEnabled()) {
1122 if (!outputTrackActive) {
1123 LOGV("starting output track in mixer for output %d", mOutputType);
1124 mOutputTrack->start();
1125 outputTrackActive = true;
1126 }
1127 mOutputTrack->write(curBuf, mFrameCount);
1128 }
1129#endif
1130
1131 // output audio to hardware
1132 mLastWriteTime = systemTime();
1133 mInWrite = true;
1134 mOutput->write(curBuf, mixBufferSize);
1135 mNumWrites++;
1136 mInWrite = false;
1137 mStandby = false;
1138 nsecs_t temp = systemTime();
1139 standbyTime = temp + kStandbyTimeInNsecs;
1140 nsecs_t delta = temp - mLastWriteTime;
1141 if (delta > maxPeriod) {
1142 LOGW("write blocked for %llu msecs", ns2ms(delta));
1143 mNumDelayedWrites++;
1144 }
1145 sleepTime = kBufferRecoveryInUsecs;
1146 } else {
1147#ifdef WITH_A2DP
1148 if (mOutputTrack != NULL && mAudioFlinger->isA2dpEnabled()) {
1149 if (outputTrackActive) {
1150 mOutputTrack->write(curBuf, 0);
1151 if (mOutputTrack->bufferQueueEmpty()) {
1152 mOutputTrack->stop();
1153 outputTrackActive = false;
1154 } else {
1155 standbyTime = systemTime() + kStandbyTimeInNsecs;
1156 }
1157 }
1158 }
1159#endif
1160 // There was nothing to mix this round, which means all
1161 // active tracks were late. Sleep a little bit to give
1162 // them another chance. If we're too late, the audio
1163 // hardware will zero-fill for us.
1164 //LOGV("no buffers - usleep(%lu)", sleepTime);
1165 usleep(sleepTime);
1166 if (sleepTime < kMaxBufferRecoveryInUsecs) {
1167 sleepTime += kBufferRecoveryInUsecs;
1168 }
1169 }
1170
1171 // finally let go of all our tracks, without the lock held
1172 // since we can't guarantee the destructors won't acquire that
1173 // same lock.
1174 tracksToRemove.clear();
1175 } while (true);
1176
1177 return false;
1178}
1179
1180status_t AudioFlinger::MixerThread::readyToRun()
1181{
1182 if (mSampleRate == 0) {
1183 LOGE("No working audio driver found.");
1184 return NO_INIT;
1185 }
1186 LOGI("AudioFlinger's thread ready to run for output %d", mOutputType);
1187 return NO_ERROR;
1188}
1189
1190void AudioFlinger::MixerThread::onFirstRef()
1191{
1192 const size_t SIZE = 256;
1193 char buffer[SIZE];
1194
1195 snprintf(buffer, SIZE, "Mixer Thread for output %d", mOutputType);
1196
1197 run(buffer, ANDROID_PRIORITY_URGENT_AUDIO);
1198}
1199
1200
1201sp<AudioFlinger::MixerThread::Track> AudioFlinger::MixerThread::createTrack(
1202 const sp<AudioFlinger::Client>& client,
1203 int streamType,
1204 uint32_t sampleRate,
1205 int format,
1206 int channelCount,
1207 int frameCount,
1208 const sp<IMemory>& sharedBuffer,
1209 status_t *status)
1210{
1211 sp<Track> track;
1212 status_t lStatus;
1213
1214 // Resampler implementation limits input sampling rate to 2 x output sampling rate.
1215 if (sampleRate > MAX_SAMPLE_RATE || sampleRate > mSampleRate*2) {
1216 LOGE("Sample rate out of range: %d mSampleRate %d", sampleRate, mSampleRate);
1217 lStatus = BAD_VALUE;
1218 goto Exit;
1219 }
1220
1221 {
1222 Mutex::Autolock _l(mLock);
1223
1224 if (mSampleRate == 0) {
1225 LOGE("Audio driver not initialized.");
1226 lStatus = NO_INIT;
1227 goto Exit;
1228 }
1229
1230 track = new Track(this, client, streamType, sampleRate, format,
1231 channelCount, frameCount, sharedBuffer);
1232 if (track->getCblk() == NULL) {
1233 track.clear();
1234 lStatus = NO_MEMORY;
1235 goto Exit;
1236 }
1237 mTracks.add(track);
1238 lStatus = NO_ERROR;
1239 }
1240
1241Exit:
1242 if(status) {
1243 *status = lStatus;
1244 }
1245 return track;
1246}
1247
1248void AudioFlinger::MixerThread::getTracks(
1249 SortedVector < sp<Track> >& tracks,
1250 SortedVector < wp<Track> >& activeTracks)
1251{
1252 size_t size = mTracks.size();
1253 LOGV ("MixerThread::getTracks() for output %d, mTracks.size %d, mActiveTracks.size %d", mOutputType, mTracks.size(), mActiveTracks.size());
1254 for (size_t i = 0; i < size; i++) {
1255 sp<Track> t = mTracks[i];
1256 if (AudioSystem::routedToA2dpOutput(t->mStreamType)) {
1257 tracks.add(t);
1258 int j = mActiveTracks.indexOf(t);
1259 if (j >= 0) {
1260 t = mActiveTracks[j].promote();
1261 if (t != NULL) {
1262 activeTracks.add(t);
1263 }
1264 }
1265 }
1266 }
1267
1268 size = activeTracks.size();
1269 for (size_t i = 0; i < size; i++) {
1270 removeActiveTrack(activeTracks[i]);
1271 }
1272
1273 size = tracks.size();
1274 for (size_t i = 0; i < size; i++) {
1275 sp<Track> t = tracks[i];
1276 mTracks.remove(t);
1277 deleteTrackName(t->name());
1278 }
1279}
1280
1281void AudioFlinger::MixerThread::putTracks(
1282 SortedVector < sp<Track> >& tracks,
1283 SortedVector < wp<Track> >& activeTracks)
1284{
1285
1286 LOGV ("MixerThread::putTracks() for output %d, tracks.size %d, activeTracks.size %d", mOutputType, tracks.size(), activeTracks.size());
1287
1288 size_t size = tracks.size();
1289 for (size_t i = 0; i < size ; i++) {
1290 sp<Track> t = tracks[i];
1291 int name = getTrackName();
1292
1293 if (name < 0) return;
1294
1295 t->mName = name;
1296 t->mMixerThread = this;
1297 mTracks.add(t);
1298
1299 int j = activeTracks.indexOf(t);
1300 if (j >= 0) {
1301 addActiveTrack(t);
1302 }
1303 }
1304}
1305
1306uint32_t AudioFlinger::MixerThread::sampleRate() const
1307{
1308 return mSampleRate;
1309}
1310
1311int AudioFlinger::MixerThread::channelCount() const
1312{
1313 return mChannelCount;
1314}
1315
1316int AudioFlinger::MixerThread::format() const
1317{
1318 return mFormat;
1319}
1320
1321size_t AudioFlinger::MixerThread::frameCount() const
1322{
1323 return mFrameCount;
1324}
1325
1326uint32_t AudioFlinger::MixerThread::latency() const
1327{
1328 if (mOutput) {
1329 return mOutput->latency();
1330 }
1331 else {
1332 return 0;
1333 }
1334}
1335
1336status_t AudioFlinger::MixerThread::setMasterVolume(float value)
1337{
1338 mMasterVolume = value;
1339 return NO_ERROR;
1340}
1341
1342status_t AudioFlinger::MixerThread::setMasterMute(bool muted)
1343{
1344 mMasterMute = muted;
1345 return NO_ERROR;
1346}
1347
1348float AudioFlinger::MixerThread::masterVolume() const
1349{
1350 return mMasterVolume;
1351}
1352
1353bool AudioFlinger::MixerThread::masterMute() const
1354{
1355 return mMasterMute;
1356}
1357
1358status_t AudioFlinger::MixerThread::setStreamVolume(int stream, float value)
1359{
1360 mStreamTypes[stream].volume = value;
1361 return NO_ERROR;
1362}
1363
1364status_t AudioFlinger::MixerThread::setStreamMute(int stream, bool muted)
1365{
1366 mStreamTypes[stream].mute = muted;
1367 return NO_ERROR;
1368}
1369
1370float AudioFlinger::MixerThread::streamVolume(int stream) const
1371{
1372 return mStreamTypes[stream].volume;
1373}
1374
1375bool AudioFlinger::MixerThread::streamMute(int stream) const
1376{
1377 return mStreamTypes[stream].mute;
1378}
1379
1380bool AudioFlinger::MixerThread::isMusicActive() const
1381{
1382 size_t count = mActiveTracks.size();
1383 for (size_t i = 0 ; i < count ; ++i) {
1384 sp<Track> t = mActiveTracks[i].promote();
1385 if (t == 0) continue;
1386 Track* const track = t.get();
1387 if (t->mStreamType == AudioSystem::MUSIC)
1388 return true;
1389 }
1390 return false;
1391}
1392
1393status_t AudioFlinger::MixerThread::addTrack(const sp<Track>& track)
1394{
1395 status_t status = ALREADY_EXISTS;
1396 Mutex::Autolock _l(mLock);
1397
1398 // here the track could be either new, or restarted
1399 // in both cases "unstop" the track
1400 if (track->isPaused()) {
1401 track->mState = TrackBase::RESUMING;
1402 LOGV("PAUSED => RESUMING (%d)", track->name());
1403 } else {
1404 track->mState = TrackBase::ACTIVE;
1405 LOGV("? => ACTIVE (%d)", track->name());
1406 }
1407 // set retry count for buffer fill
1408 track->mRetryCount = kMaxTrackStartupRetries;
1409 if (mActiveTracks.indexOf(track) < 0) {
1410 // the track is newly added, make sure it fills up all its
1411 // buffers before playing. This is to ensure the client will
1412 // effectively get the latency it requested.
1413 track->mFillingUpStatus = Track::FS_FILLING;
1414 track->mResetDone = false;
1415 addActiveTrack(track);
1416 status = NO_ERROR;
1417 }
1418
1419 LOGV("mWaitWorkCV.broadcast");
1420 mWaitWorkCV.broadcast();
1421
1422 return status;
1423}
1424
1425void AudioFlinger::MixerThread::removeTrack(wp<Track> track, int name)
1426{
1427 Mutex::Autolock _l(mLock);
1428 sp<Track> t = track.promote();
1429 if (t!=NULL && (t->mState <= TrackBase::STOPPED)) {
1430 remove_track_l(track, name);
1431 }
1432}
1433
1434void AudioFlinger::MixerThread::remove_track_l(wp<Track> track, int name)
1435{
1436 sp<Track> t = track.promote();
1437 if (t!=NULL) {
1438 t->reset();
1439 }
1440 deleteTrackName(name);
1441 removeActiveTrack(track);
1442 mWaitWorkCV.broadcast();
1443}
1444
1445void AudioFlinger::MixerThread::destroyTrack(const sp<Track>& track)
1446{
1447 // NOTE: We're acquiring a strong reference on the track before
1448 // acquiring the lock, this is to make sure removing it from
1449 // mTracks won't cause the destructor to be called while the lock is
1450 // held (note that technically, 'track' could be a reference to an item
1451 // in mTracks, which is why we need to do this).
1452 sp<Track> keep(track);
1453 Mutex::Autolock _l(mLock);
1454 track->mState = TrackBase::TERMINATED;
1455 if (mActiveTracks.indexOf(track) < 0) {
1456 LOGV("remove track (%d) and delete from mixer", track->name());
1457 mTracks.remove(track);
1458 deleteTrackName(keep->name());
1459 }
1460}
1461
1462
1463void AudioFlinger::MixerThread::addActiveTrack(const wp<Track>& t)
1464{
1465 mActiveTracks.add(t);
1466
1467 // Force routing to speaker for certain stream types
1468 // The forced routing to speaker is managed by hardware mixer
1469 if (mOutputType == AudioSystem::AUDIO_OUTPUT_HARDWARE) {
1470 sp<Track> track = t.promote();
1471 if (track == NULL) return;
1472
1473 if (streamForcedToSpeaker(track->type())) {
1474 mAudioFlinger->handleForcedSpeakerRoute(ACTIVE_TRACK_ADDED);
1475 }
1476 }
1477}
1478
1479void AudioFlinger::MixerThread::removeActiveTrack(const wp<Track>& t)
1480{
1481 mActiveTracks.remove(t);
1482
1483 // Force routing to speaker for certain stream types
1484 // The forced routing to speaker is managed by hardware mixer
1485 if (mOutputType == AudioSystem::AUDIO_OUTPUT_HARDWARE) {
1486 sp<Track> track = t.promote();
1487 if (track == NULL) return;
1488
1489 if (streamForcedToSpeaker(track->type())) {
1490 mAudioFlinger->handleForcedSpeakerRoute(ACTIVE_TRACK_REMOVED);
1491 }
1492 }
1493}
1494
1495int AudioFlinger::MixerThread::getTrackName()
1496{
1497 return mAudioMixer->getTrackName();
1498}
1499
1500void AudioFlinger::MixerThread::deleteTrackName(int name)
1501{
1502 mAudioMixer->deleteTrackName(name);
1503}
1504
1505size_t AudioFlinger::MixerThread::getOutputFrameCount()
1506{
1507 return mOutput->bufferSize() / mOutput->channelCount() / sizeof(int16_t);
1508}
1509
1510// ----------------------------------------------------------------------------
1511
1512AudioFlinger::MixerThread::TrackBase::TrackBase(
1513 const sp<MixerThread>& mixerThread,
1514 const sp<Client>& client,
1515 int streamType,
1516 uint32_t sampleRate,
1517 int format,
1518 int channelCount,
1519 int frameCount,
1520 uint32_t flags,
1521 const sp<IMemory>& sharedBuffer)
1522 : RefBase(),
1523 mMixerThread(mixerThread),
1524 mClient(client),
1525 mStreamType(streamType),
1526 mFrameCount(0),
1527 mState(IDLE),
1528 mClientTid(-1),
1529 mFormat(format),
1530 mFlags(flags & ~SYSTEM_FLAGS_MASK)
1531{
1532 mName = mixerThread->getTrackName();
1533 LOGV("TrackBase contructor name %d, calling thread %d", mName, IPCThreadState::self()->getCallingPid());
1534 if (mName < 0) {
1535 LOGE("no more track names availlable");
1536 return;
1537 }
1538
1539 LOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), sharedBuffer->size());
1540
1541 // LOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
1542 size_t size = sizeof(audio_track_cblk_t);
1543 size_t bufferSize = frameCount*channelCount*sizeof(int16_t);
1544 if (sharedBuffer == 0) {
1545 size += bufferSize;
1546 }
1547
1548 if (client != NULL) {
1549 mCblkMemory = client->heap()->allocate(size);
1550 if (mCblkMemory != 0) {
1551 mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer());
1552 if (mCblk) { // construct the shared structure in-place.
1553 new(mCblk) audio_track_cblk_t();
1554 // clear all buffers
1555 mCblk->frameCount = frameCount;
1556 mCblk->sampleRate = sampleRate;
1557 mCblk->channels = channelCount;
1558 if (sharedBuffer == 0) {
1559 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
1560 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));
1561 // Force underrun condition to avoid false underrun callback until first data is
1562 // written to buffer
1563 mCblk->flowControlFlag = 1;
1564 } else {
1565 mBuffer = sharedBuffer->pointer();
1566 }
1567 mBufferEnd = (uint8_t *)mBuffer + bufferSize;
1568 }
1569 } else {
1570 LOGE("not enough memory for AudioTrack size=%u", size);
1571 client->heap()->dump("AudioTrack");
1572 return;
1573 }
1574 } else {
1575 mCblk = (audio_track_cblk_t *)(new uint8_t[size]);
1576 if (mCblk) { // construct the shared structure in-place.
1577 new(mCblk) audio_track_cblk_t();
1578 // clear all buffers
1579 mCblk->frameCount = frameCount;
1580 mCblk->sampleRate = sampleRate;
1581 mCblk->channels = channelCount;
1582 mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
1583 memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));
1584 // Force underrun condition to avoid false underrun callback until first data is
1585 // written to buffer
1586 mCblk->flowControlFlag = 1;
1587 mBufferEnd = (uint8_t *)mBuffer + bufferSize;
1588 }
1589 }
1590}
1591
1592AudioFlinger::MixerThread::TrackBase::~TrackBase()
1593{
1594 if (mCblk) {
1595 mCblk->~audio_track_cblk_t(); // destroy our shared-structure.
1596 }
1597 mCblkMemory.clear(); // and free the shared memory
1598 mClient.clear();
1599}
1600
1601void AudioFlinger::MixerThread::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
1602{
1603 buffer->raw = 0;
1604 mFrameCount = buffer->frameCount;
1605 step();
1606 buffer->frameCount = 0;
1607}
1608
1609bool AudioFlinger::MixerThread::TrackBase::step() {
1610 bool result;
1611 audio_track_cblk_t* cblk = this->cblk();
1612
1613 result = cblk->stepServer(mFrameCount);
1614 if (!result) {
1615 LOGV("stepServer failed acquiring cblk mutex");
1616 mFlags |= STEPSERVER_FAILED;
1617 }
1618 return result;
1619}
1620
1621void AudioFlinger::MixerThread::TrackBase::reset() {
1622 audio_track_cblk_t* cblk = this->cblk();
1623
1624 cblk->user = 0;
1625 cblk->server = 0;
1626 cblk->userBase = 0;
1627 cblk->serverBase = 0;
1628 mFlags &= (uint32_t)(~SYSTEM_FLAGS_MASK);
1629 LOGV("TrackBase::reset");
1630}
1631
1632sp<IMemory> AudioFlinger::MixerThread::TrackBase::getCblk() const
1633{
1634 return mCblkMemory;
1635}
1636
1637int AudioFlinger::MixerThread::TrackBase::sampleRate() const {
1638 return mCblk->sampleRate;
1639}
1640
1641int AudioFlinger::MixerThread::TrackBase::channelCount() const {
1642 return mCblk->channels;
1643}
1644
1645void* AudioFlinger::MixerThread::TrackBase::getBuffer(uint32_t offset, uint32_t frames) const {
1646 audio_track_cblk_t* cblk = this->cblk();
1647 int16_t *bufferStart = (int16_t *)mBuffer + (offset-cblk->serverBase)*cblk->channels;
1648 int16_t *bufferEnd = bufferStart + frames * cblk->channels;
1649
1650 // Check validity of returned pointer in case the track control block would have been corrupted.
1651 if (bufferStart < mBuffer || bufferStart > bufferEnd || bufferEnd > mBufferEnd) {
1652 LOGW("TrackBase::getBuffer buffer out of range:\n start: %p, end %p , mBuffer %p mBufferEnd %p\n \
1653 server %d, serverBase %d, user %d, userBase %d",
1654 bufferStart, bufferEnd, mBuffer, mBufferEnd,
1655 cblk->server, cblk->serverBase, cblk->user, cblk->userBase);
1656 return 0;
1657 }
1658
1659 return bufferStart;
1660}
1661
1662// ----------------------------------------------------------------------------
1663
1664AudioFlinger::MixerThread::Track::Track(
1665 const sp<MixerThread>& mixerThread,
1666 const sp<Client>& client,
1667 int streamType,
1668 uint32_t sampleRate,
1669 int format,
1670 int channelCount,
1671 int frameCount,
1672 const sp<IMemory>& sharedBuffer)
1673 : TrackBase(mixerThread, client, streamType, sampleRate, format, channelCount, frameCount, 0, sharedBuffer)
1674{
1675 mVolume[0] = 1.0f;
1676 mVolume[1] = 1.0f;
1677 mMute = false;
1678 mSharedBuffer = sharedBuffer;
1679}
1680
1681AudioFlinger::MixerThread::Track::~Track()
1682{
1683 wp<Track> weak(this); // never create a strong ref from the dtor
1684 mState = TERMINATED;
1685 mMixerThread->removeTrack(weak, mName);
1686}
1687
1688void AudioFlinger::MixerThread::Track::destroy()
1689{
1690 mMixerThread->destroyTrack(this);
1691}
1692
1693void AudioFlinger::MixerThread::Track::dump(char* buffer, size_t size)
1694{
1695 snprintf(buffer, size, " %5d %5d %3u %3u %3u %3u %1d %1d %1d %5u %5u %5u %04x %04x\n",
1696 mName - AudioMixer::TRACK0,
1697 (mClient == NULL) ? getpid() : mClient->pid(),
1698 mStreamType,
1699 mFormat,
1700 mCblk->channels,
1701 mFrameCount,
1702 mState,
1703 mMute,
1704 mFillingUpStatus,
1705 mCblk->sampleRate,
1706 mCblk->volume[0],
1707 mCblk->volume[1],
1708 mCblk->server,
1709 mCblk->user);
1710}
1711
1712status_t AudioFlinger::MixerThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
1713{
1714 audio_track_cblk_t* cblk = this->cblk();
1715 uint32_t framesReady;
1716 uint32_t framesReq = buffer->frameCount;
1717
1718 // Check if last stepServer failed, try to step now
1719 if (mFlags & TrackBase::STEPSERVER_FAILED) {
1720 if (!step()) goto getNextBuffer_exit;
1721 LOGV("stepServer recovered");
1722 mFlags &= ~TrackBase::STEPSERVER_FAILED;
1723 }
1724
1725 framesReady = cblk->framesReady();
1726
1727 if (LIKELY(framesReady)) {
1728 uint32_t s = cblk->server;
1729 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount;
1730
1731 bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd : bufferEnd;
1732 if (framesReq > framesReady) {
1733 framesReq = framesReady;
1734 }
1735 if (s + framesReq > bufferEnd) {
1736 framesReq = bufferEnd - s;
1737 }
1738
1739 buffer->raw = getBuffer(s, framesReq);
1740 if (buffer->raw == 0) goto getNextBuffer_exit;
1741
1742 buffer->frameCount = framesReq;
1743 return NO_ERROR;
1744 }
1745
1746getNextBuffer_exit:
1747 buffer->raw = 0;
1748 buffer->frameCount = 0;
1749 return NOT_ENOUGH_DATA;
1750}
1751
1752bool AudioFlinger::MixerThread::Track::isReady() const {
1753 if (mFillingUpStatus != FS_FILLING) return true;
1754
1755 if (mCblk->framesReady() >= mCblk->frameCount ||
1756 mCblk->forceReady) {
1757 mFillingUpStatus = FS_FILLED;
1758 mCblk->forceReady = 0;
1759 LOGV("Track::isReady() track %d for output %d", mName, mMixerThread->mOutputType);
1760 return true;
1761 }
1762 return false;
1763}
1764
1765status_t AudioFlinger::MixerThread::Track::start()
1766{
1767 LOGV("start(%d), calling thread %d for output %d", mName, IPCThreadState::self()->getCallingPid(), mMixerThread->mOutputType);
1768 mMixerThread->addTrack(this);
1769 return NO_ERROR;
1770}
1771
1772void AudioFlinger::MixerThread::Track::stop()
1773{
1774 LOGV("stop(%d), calling thread %d for output %d", mName, IPCThreadState::self()->getCallingPid(), mMixerThread->mOutputType);
1775 Mutex::Autolock _l(mMixerThread->mLock);
1776 if (mState > STOPPED) {
1777 mState = STOPPED;
1778 // If the track is not active (PAUSED and buffers full), flush buffers
1779 if (mMixerThread->mActiveTracks.indexOf(this) < 0) {
1780 reset();
1781 }
1782 LOGV("(> STOPPED) => STOPPED (%d)", mName);
1783 }
1784}
1785
1786void AudioFlinger::MixerThread::Track::pause()
1787{
1788 LOGV("pause(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid());
1789 Mutex::Autolock _l(mMixerThread->mLock);
1790 if (mState == ACTIVE || mState == RESUMING) {
1791 mState = PAUSING;
1792 LOGV("ACTIVE/RESUMING => PAUSING (%d)", mName);
1793 }
1794}
1795
1796void AudioFlinger::MixerThread::Track::flush()
1797{
1798 LOGV("flush(%d)", mName);
1799 Mutex::Autolock _l(mMixerThread->mLock);
1800 if (mState != STOPPED && mState != PAUSED && mState != PAUSING) {
1801 return;
1802 }
1803 // No point remaining in PAUSED state after a flush => go to
1804 // STOPPED state
1805 mState = STOPPED;
1806
1807 // NOTE: reset() will reset cblk->user and cblk->server with
1808 // the risk that at the same time, the AudioMixer is trying to read
1809 // data. In this case, getNextBuffer() would return a NULL pointer
1810 // as audio buffer => the AudioMixer code MUST always test that pointer
1811 // returned by getNextBuffer() is not NULL!
1812 reset();
1813}
1814
1815void AudioFlinger::MixerThread::Track::reset()
1816{
1817 // Do not reset twice to avoid discarding data written just after a flush and before
1818 // the audioflinger thread detects the track is stopped.
1819 if (!mResetDone) {
1820 TrackBase::reset();
1821 // Force underrun condition to avoid false underrun callback until first data is
1822 // written to buffer
1823 mCblk->flowControlFlag = 1;
1824 mCblk->forceReady = 0;
1825 mFillingUpStatus = FS_FILLING;
1826 mResetDone = true;
1827 }
1828}
1829
1830void AudioFlinger::MixerThread::Track::mute(bool muted)
1831{
1832 mMute = muted;
1833}
1834
1835void AudioFlinger::MixerThread::Track::setVolume(float left, float right)
1836{
1837 mVolume[0] = left;
1838 mVolume[1] = right;
1839}
1840
1841// ----------------------------------------------------------------------------
1842
1843AudioFlinger::MixerThread::RecordTrack::RecordTrack(
1844 const sp<MixerThread>& mixerThread,
1845 const sp<Client>& client,
1846 int streamType,
1847 uint32_t sampleRate,
1848 int format,
1849 int channelCount,
1850 int frameCount,
1851 uint32_t flags)
1852 : TrackBase(mixerThread, client, streamType, sampleRate, format,
1853 channelCount, frameCount, flags, 0),
1854 mOverflow(false)
1855{
1856}
1857
1858AudioFlinger::MixerThread::RecordTrack::~RecordTrack()
1859{
1860 mMixerThread->deleteTrackName(mName);
1861}
1862
1863status_t AudioFlinger::MixerThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
1864{
1865 audio_track_cblk_t* cblk = this->cblk();
1866 uint32_t framesAvail;
1867 uint32_t framesReq = buffer->frameCount;
1868
1869 // Check if last stepServer failed, try to step now
1870 if (mFlags & TrackBase::STEPSERVER_FAILED) {
1871 if (!step()) goto getNextBuffer_exit;
1872 LOGV("stepServer recovered");
1873 mFlags &= ~TrackBase::STEPSERVER_FAILED;
1874 }
1875
1876 framesAvail = cblk->framesAvailable_l();
1877
1878 if (LIKELY(framesAvail)) {
1879 uint32_t s = cblk->server;
1880 uint32_t bufferEnd = cblk->serverBase + cblk->frameCount;
1881
1882 if (framesReq > framesAvail) {
1883 framesReq = framesAvail;
1884 }
1885 if (s + framesReq > bufferEnd) {
1886 framesReq = bufferEnd - s;
1887 }
1888
1889 buffer->raw = getBuffer(s, framesReq);
1890 if (buffer->raw == 0) goto getNextBuffer_exit;
1891
1892 buffer->frameCount = framesReq;
1893 return NO_ERROR;
1894 }
1895
1896getNextBuffer_exit:
1897 buffer->raw = 0;
1898 buffer->frameCount = 0;
1899 return NOT_ENOUGH_DATA;
1900}
1901
1902status_t AudioFlinger::MixerThread::RecordTrack::start()
1903{
1904 return mMixerThread->mAudioFlinger->startRecord(this);
1905}
1906
1907void AudioFlinger::MixerThread::RecordTrack::stop()
1908{
1909 mMixerThread->mAudioFlinger->stopRecord(this);
1910 TrackBase::reset();
1911 // Force overerrun condition to avoid false overrun callback until first data is
1912 // read from buffer
1913 mCblk->flowControlFlag = 1;
1914}
1915
1916
1917// ----------------------------------------------------------------------------
1918
1919AudioFlinger::MixerThread::OutputTrack::OutputTrack(
1920 const sp<MixerThread>& mixerThread,
1921 uint32_t sampleRate,
1922 int format,
1923 int channelCount,
1924 int frameCount)
1925 : Track(mixerThread, NULL, AudioSystem::SYSTEM, sampleRate, format, channelCount, frameCount, NULL),
1926 mOutputMixerThread(mixerThread)
1927{
1928
1929 mCblk->out = 1;
1930 mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);
1931 mCblk->volume[0] = mCblk->volume[1] = 0x1000;
1932 mOutBuffer.frameCount = 0;
1933 mCblk->bufferTimeoutMs = 10;
1934
1935 LOGV("OutputTrack constructor mCblk %p, mBuffer %p, mCblk->buffers %p, mCblk->frameCount %d, mCblk->sampleRate %d, mCblk->channels %d mBufferEnd %p",
1936 mCblk, mBuffer, mCblk->buffers, mCblk->frameCount, mCblk->sampleRate, mCblk->channels, mBufferEnd);
1937
1938}
1939
1940AudioFlinger::MixerThread::OutputTrack::~OutputTrack()
1941{
1942 stop();
1943}
1944
1945status_t AudioFlinger::MixerThread::OutputTrack::start()
1946{
1947 status_t status = Track::start();
1948
1949 mRetryCount = 127;
1950 return status;
1951}
1952
1953void AudioFlinger::MixerThread::OutputTrack::stop()
1954{
1955 Track::stop();
1956 clearBufferQueue();
1957 mOutBuffer.frameCount = 0;
1958}
1959
1960void AudioFlinger::MixerThread::OutputTrack::write(int16_t* data, uint32_t frames)
1961{
1962 Buffer *pInBuffer;
1963 Buffer inBuffer;
1964 uint32_t channels = mCblk->channels;
1965
1966 inBuffer.frameCount = frames;
1967 inBuffer.i16 = data;
1968
1969 if (mCblk->user == 0) {
1970 if (mOutputMixerThread->isMusicActive()) {
1971 mCblk->forceReady = 1;
1972 LOGV("OutputTrack::start() force ready");
1973 } else if (mCblk->frameCount > frames){
1974 if (mBufferQueue.size() < kMaxOutputTrackBuffers) {
1975 uint32_t startFrames = (mCblk->frameCount - frames);
1976 LOGV("OutputTrack::start() write %d frames", startFrames);
1977 pInBuffer = new Buffer;
1978 pInBuffer->mBuffer = new int16_t[startFrames * channels];
1979 pInBuffer->frameCount = startFrames;
1980 pInBuffer->i16 = pInBuffer->mBuffer;
1981 memset(pInBuffer->raw, 0, startFrames * channels * sizeof(int16_t));
1982 mBufferQueue.add(pInBuffer);
1983 } else {
1984 LOGW ("OutputTrack::write() no more buffers");
1985 }
1986 }
1987 }
1988
1989 while (1) {
1990 // First write pending buffers, then new data
1991 if (mBufferQueue.size()) {
1992 pInBuffer = mBufferQueue.itemAt(0);
1993 } else {
1994 pInBuffer = &inBuffer;
1995 }
1996
1997 if (pInBuffer->frameCount == 0) {
1998 break;
1999 }
2000
2001 if (mOutBuffer.frameCount == 0) {
2002 mOutBuffer.frameCount = pInBuffer->frameCount;
2003 if (obtainBuffer(&mOutBuffer) == (status_t)AudioTrack::NO_MORE_BUFFERS) {
2004 break;
2005 }
2006 }
2007
2008 uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : pInBuffer->frameCount;
2009 memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channels * sizeof(int16_t));
2010 mCblk->stepUser(outFrames);
2011 pInBuffer->frameCount -= outFrames;
2012 pInBuffer->i16 += outFrames * channels;
2013 mOutBuffer.frameCount -= outFrames;
2014 mOutBuffer.i16 += outFrames * channels;
2015
2016 if (pInBuffer->frameCount == 0) {
2017 if (mBufferQueue.size()) {
2018 mBufferQueue.removeAt(0);
2019 delete [] pInBuffer->mBuffer;
2020 delete pInBuffer;
2021 } else {
2022 break;
2023 }
2024 }
2025 }
2026
2027 // If we could not write all frames, allocate a buffer and queue it for next time.
2028 if (inBuffer.frameCount) {
2029 if (mBufferQueue.size() < kMaxOutputTrackBuffers) {
2030 pInBuffer = new Buffer;
2031 pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channels];
2032 pInBuffer->frameCount = inBuffer.frameCount;
2033 pInBuffer->i16 = pInBuffer->mBuffer;
2034 memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channels * sizeof(int16_t));
2035 mBufferQueue.add(pInBuffer);
2036 } else {
2037 LOGW("OutputTrack::write() no more buffers");
2038 }
2039 }
2040
2041 // Calling write() with a 0 length buffer, means that no more data will be written:
2042 // If no more buffers are pending, fill output track buffer to make sure it is started
2043 // by output mixer.
2044 if (frames == 0 && mBufferQueue.size() == 0 && mCblk->user < mCblk->frameCount) {
2045 frames = mCblk->frameCount - mCblk->user;
2046 pInBuffer = new Buffer;
2047 pInBuffer->mBuffer = new int16_t[frames * channels];
2048 pInBuffer->frameCount = frames;
2049 pInBuffer->i16 = pInBuffer->mBuffer;
2050 memset(pInBuffer->raw, 0, frames * channels * sizeof(int16_t));
2051 mBufferQueue.add(pInBuffer);
2052 }
2053
2054}
2055
2056status_t AudioFlinger::MixerThread::OutputTrack::obtainBuffer(AudioBufferProvider::Buffer* buffer)
2057{
2058 int active;
2059 int timeout = 0;
2060 status_t result;
2061 audio_track_cblk_t* cblk = mCblk;
2062 uint32_t framesReq = buffer->frameCount;
2063
2064 LOGV("OutputTrack::obtainBuffer user %d, server %d", cblk->user, cblk->server);
2065 buffer->frameCount = 0;
2066
2067 uint32_t framesAvail = cblk->framesAvailable();
2068
2069 if (framesAvail == 0) {
2070 return AudioTrack::NO_MORE_BUFFERS;
2071 }
2072
2073 if (framesReq > framesAvail) {
2074 framesReq = framesAvail;
2075 }
2076
2077 uint32_t u = cblk->user;
2078 uint32_t bufferEnd = cblk->userBase + cblk->frameCount;
2079
2080 if (u + framesReq > bufferEnd) {
2081 framesReq = bufferEnd - u;
2082 }
2083
2084 buffer->frameCount = framesReq;
2085 buffer->raw = (void *)cblk->buffer(u);
2086 return NO_ERROR;
2087}
2088
2089
2090void AudioFlinger::MixerThread::OutputTrack::clearBufferQueue()
2091{
2092 size_t size = mBufferQueue.size();
2093 Buffer *pBuffer;
2094
2095 for (size_t i = 0; i < size; i++) {
2096 pBuffer = mBufferQueue.itemAt(i);
2097 delete [] pBuffer->mBuffer;
2098 delete pBuffer;
2099 }
2100 mBufferQueue.clear();
2101}
2102
2103// ----------------------------------------------------------------------------
2104
2105AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
2106 : RefBase(),
2107 mAudioFlinger(audioFlinger),
2108 mMemoryDealer(new MemoryDealer(1024*1024)),
2109 mPid(pid)
2110{
2111 // 1 MB of address space is good for 32 tracks, 8 buffers each, 4 KB/buffer
2112}
2113
2114AudioFlinger::Client::~Client()
2115{
2116 mAudioFlinger->removeClient(mPid);
2117}
2118
2119const sp<MemoryDealer>& AudioFlinger::Client::heap() const
2120{
2121 return mMemoryDealer;
2122}
2123
2124// ----------------------------------------------------------------------------
2125
2126AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::MixerThread::Track>& track)
2127 : BnAudioTrack(),
2128 mTrack(track)
2129{
2130}
2131
2132AudioFlinger::TrackHandle::~TrackHandle() {
2133 // just stop the track on deletion, associated resources
2134 // will be freed from the main thread once all pending buffers have
2135 // been played. Unless it's not in the active track list, in which
2136 // case we free everything now...
2137 mTrack->destroy();
2138}
2139
2140status_t AudioFlinger::TrackHandle::start() {
2141 return mTrack->start();
2142}
2143
2144void AudioFlinger::TrackHandle::stop() {
2145 mTrack->stop();
2146}
2147
2148void AudioFlinger::TrackHandle::flush() {
2149 mTrack->flush();
2150}
2151
2152void AudioFlinger::TrackHandle::mute(bool e) {
2153 mTrack->mute(e);
2154}
2155
2156void AudioFlinger::TrackHandle::pause() {
2157 mTrack->pause();
2158}
2159
2160void AudioFlinger::TrackHandle::setVolume(float left, float right) {
2161 mTrack->setVolume(left, right);
2162}
2163
2164sp<IMemory> AudioFlinger::TrackHandle::getCblk() const {
2165 return mTrack->getCblk();
2166}
2167
2168status_t AudioFlinger::TrackHandle::onTransact(
2169 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
2170{
2171 return BnAudioTrack::onTransact(code, data, reply, flags);
2172}
2173
2174// ----------------------------------------------------------------------------
2175
2176sp<IAudioRecord> AudioFlinger::openRecord(
2177 pid_t pid,
2178 int streamType,
2179 uint32_t sampleRate,
2180 int format,
2181 int channelCount,
2182 int frameCount,
2183 uint32_t flags,
2184 status_t *status)
2185{
2186 sp<AudioRecordThread> thread;
2187 sp<MixerThread::RecordTrack> recordTrack;
2188 sp<RecordHandle> recordHandle;
2189 sp<Client> client;
2190 wp<Client> wclient;
2191 AudioStreamIn* input = 0;
2192 int inFrameCount;
2193 size_t inputBufferSize;
2194 status_t lStatus;
2195
2196 // check calling permissions
2197 if (!recordingAllowed()) {
2198 lStatus = PERMISSION_DENIED;
2199 goto Exit;
2200 }
2201
2202 if (uint32_t(streamType) >= AudioRecord::NUM_STREAM_TYPES) {
2203 LOGE("invalid stream type");
2204 lStatus = BAD_VALUE;
2205 goto Exit;
2206 }
2207
2208 if (sampleRate > MAX_SAMPLE_RATE) {
2209 LOGE("Sample rate out of range");
2210 lStatus = BAD_VALUE;
2211 goto Exit;
2212 }
2213
2214 if (mAudioRecordThread == 0) {
2215 LOGE("Audio record thread not started");
2216 lStatus = NO_INIT;
2217 goto Exit;
2218 }
2219
2220
2221 // Check that audio input stream accepts requested audio parameters
2222 inputBufferSize = mAudioHardware->getInputBufferSize(sampleRate, format, channelCount);
2223 if (inputBufferSize == 0) {
2224 lStatus = BAD_VALUE;
2225 LOGE("Bad audio input parameters: sampling rate %u, format %d, channels %d", sampleRate, format, channelCount);
2226 goto Exit;
2227 }
2228
2229 // add client to list
2230 {
2231 Mutex::Autolock _l(mLock);
2232 wclient = mClients.valueFor(pid);
2233 if (wclient != NULL) {
2234 client = wclient.promote();
2235 } else {
2236 client = new Client(this, pid);
2237 mClients.add(pid, client);
2238 }
2239 }
2240
2241 // frameCount must be a multiple of input buffer size
2242 inFrameCount = inputBufferSize/channelCount/sizeof(short);
2243 frameCount = ((frameCount - 1)/inFrameCount + 1) * inFrameCount;
2244
2245 // create new record track and pass to record thread
2246 recordTrack = new MixerThread::RecordTrack(mHardwareMixerThread, client, streamType, sampleRate,
2247 format, channelCount, frameCount, flags);
2248 if (recordTrack->getCblk() == NULL) {
2249 recordTrack.clear();
2250 lStatus = NO_MEMORY;
2251 goto Exit;
2252 }
2253
2254 // return to handle to client
2255 recordHandle = new RecordHandle(recordTrack);
2256 lStatus = NO_ERROR;
2257
2258Exit:
2259 if (status) {
2260 *status = lStatus;
2261 }
2262 return recordHandle;
2263}
2264
2265status_t AudioFlinger::startRecord(MixerThread::RecordTrack* recordTrack) {
2266 if (mAudioRecordThread != 0) {
2267 return mAudioRecordThread->start(recordTrack);
2268 }
2269 return NO_INIT;
2270}
2271
2272void AudioFlinger::stopRecord(MixerThread::RecordTrack* recordTrack) {
2273 if (mAudioRecordThread != 0) {
2274 mAudioRecordThread->stop(recordTrack);
2275 }
2276}
2277
2278// ----------------------------------------------------------------------------
2279
2280AudioFlinger::RecordHandle::RecordHandle(const sp<AudioFlinger::MixerThread::RecordTrack>& recordTrack)
2281 : BnAudioRecord(),
2282 mRecordTrack(recordTrack)
2283{
2284}
2285
2286AudioFlinger::RecordHandle::~RecordHandle() {
2287 stop();
2288}
2289
2290status_t AudioFlinger::RecordHandle::start() {
2291 LOGV("RecordHandle::start()");
2292 return mRecordTrack->start();
2293}
2294
2295void AudioFlinger::RecordHandle::stop() {
2296 LOGV("RecordHandle::stop()");
2297 mRecordTrack->stop();
2298}
2299
2300sp<IMemory> AudioFlinger::RecordHandle::getCblk() const {
2301 return mRecordTrack->getCblk();
2302}
2303
2304status_t AudioFlinger::RecordHandle::onTransact(
2305 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
2306{
2307 return BnAudioRecord::onTransact(code, data, reply, flags);
2308}
2309
2310// ----------------------------------------------------------------------------
2311
2312AudioFlinger::AudioRecordThread::AudioRecordThread(AudioHardwareInterface* audioHardware) :
2313 mAudioHardware(audioHardware),
2314 mActive(false)
2315{
2316}
2317
2318AudioFlinger::AudioRecordThread::~AudioRecordThread()
2319{
2320}
2321
2322bool AudioFlinger::AudioRecordThread::threadLoop()
2323{
2324 LOGV("AudioRecordThread: start record loop");
2325 AudioBufferProvider::Buffer buffer;
2326 int inBufferSize = 0;
2327 int inFrameCount = 0;
2328 AudioStreamIn* input = 0;
2329
2330 mActive = 0;
2331
2332 // start recording
2333 while (!exitPending()) {
2334 if (!mActive) {
2335 mLock.lock();
2336 if (!mActive && !exitPending()) {
2337 LOGV("AudioRecordThread: loop stopping");
2338 if (input) {
2339 delete input;
2340 input = 0;
2341 }
2342 mRecordTrack.clear();
2343 mStopped.signal();
2344
2345 mWaitWorkCV.wait(mLock);
2346
2347 LOGV("AudioRecordThread: loop starting");
2348 if (mRecordTrack != 0) {
2349 input = mAudioHardware->openInputStream(mRecordTrack->format(),
2350 mRecordTrack->channelCount(),
2351 mRecordTrack->sampleRate(),
2352 &mStartStatus,
2353 (AudioSystem::audio_in_acoustics)(mRecordTrack->mFlags >> 16));
2354 if (input != 0) {
2355 inBufferSize = input->bufferSize();
2356 inFrameCount = inBufferSize/input->frameSize();
2357 }
2358 } else {
2359 mStartStatus = NO_INIT;
2360 }
2361 if (mStartStatus !=NO_ERROR) {
2362 LOGW("record start failed, status %d", mStartStatus);
2363 mActive = false;
2364 mRecordTrack.clear();
2365 }
2366 mWaitWorkCV.signal();
2367 }
2368 mLock.unlock();
2369 } else if (mRecordTrack != 0) {
2370
2371 buffer.frameCount = inFrameCount;
2372 if (LIKELY(mRecordTrack->getNextBuffer(&buffer) == NO_ERROR)) {
2373 LOGV("AudioRecordThread read: %d frames", buffer.frameCount);
2374 ssize_t bytesRead = input->read(buffer.raw, inBufferSize);
2375 if (bytesRead < 0) {
2376 LOGE("Error reading audio input");
2377 sleep(1);
2378 }
2379 mRecordTrack->releaseBuffer(&buffer);
2380 mRecordTrack->overflow();
2381 }
2382
2383 // client isn't retrieving buffers fast enough
2384 else {
2385 if (!mRecordTrack->setOverflow())
2386 LOGW("AudioRecordThread: buffer overflow");
2387 // Release the processor for a while before asking for a new buffer.
2388 // This will give the application more chance to read from the buffer and
2389 // clear the overflow.
2390 usleep(5000);
2391 }
2392 }
2393 }
2394
2395
2396 if (input) {
2397 delete input;
2398 }
2399 mRecordTrack.clear();
2400
2401 return false;
2402}
2403
2404status_t AudioFlinger::AudioRecordThread::start(MixerThread::RecordTrack* recordTrack)
2405{
2406 LOGV("AudioRecordThread::start");
2407 AutoMutex lock(&mLock);
2408 mActive = true;
2409 // If starting the active track, just reset mActive in case a stop
2410 // was pending and exit
2411 if (recordTrack == mRecordTrack.get()) return NO_ERROR;
2412
2413 if (mRecordTrack != 0) return -EBUSY;
2414
2415 mRecordTrack = recordTrack;
2416
2417 // signal thread to start
2418 LOGV("Signal record thread");
2419 mWaitWorkCV.signal();
2420 mWaitWorkCV.wait(mLock);
2421 LOGV("Record started, status %d", mStartStatus);
2422 return mStartStatus;
2423}
2424
2425void AudioFlinger::AudioRecordThread::stop(MixerThread::RecordTrack* recordTrack) {
2426 LOGV("AudioRecordThread::stop");
2427 AutoMutex lock(&mLock);
2428 if (mActive && (recordTrack == mRecordTrack.get())) {
2429 mActive = false;
2430 mStopped.wait(mLock);
2431 }
2432}
2433
2434void AudioFlinger::AudioRecordThread::exit()
2435{
2436 LOGV("AudioRecordThread::exit");
2437 {
2438 AutoMutex lock(&mLock);
2439 requestExit();
2440 mWaitWorkCV.signal();
2441 }
2442 requestExitAndWait();
2443}
2444
2445status_t AudioFlinger::AudioRecordThread::dump(int fd, const Vector<String16>& args)
2446{
2447 const size_t SIZE = 256;
2448 char buffer[SIZE];
2449 String8 result;
2450 pid_t pid = 0;
2451
2452 if (mRecordTrack != 0 && mRecordTrack->mClient != 0) {
2453 snprintf(buffer, SIZE, "Record client pid: %d\n", mRecordTrack->mClient->pid());
2454 result.append(buffer);
2455 } else {
2456 result.append("No record client\n");
2457 }
2458 write(fd, result.string(), result.size());
2459 return NO_ERROR;
2460}
2461
2462status_t AudioFlinger::onTransact(
2463 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
2464{
2465 return BnAudioFlinger::onTransact(code, data, reply, flags);
2466}
2467
2468// ----------------------------------------------------------------------------
2469void AudioFlinger::instantiate() {
2470 defaultServiceManager()->addService(
2471 String16("media.audio_flinger"), new AudioFlinger());
2472}
2473
2474}; // namespace android