blob: ef109af041d19f77b08d0b85d880f306054bb519 [file] [log] [blame]
Eric Laurent81784c32012-11-19 14:55:58 -08001/*
2**
3** Copyright 2012, 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
Alex Ray371eb972012-11-30 11:11:54 -080021#define ATRACE_TAG ATRACE_TAG_AUDIO
Eric Laurent81784c32012-11-19 14:55:58 -080022
23#include <math.h>
24#include <fcntl.h>
25#include <sys/stat.h>
26#include <cutils/properties.h>
27#include <cutils/compiler.h>
Glenn Kasten1ab85ec2013-05-31 09:18:43 -070028#include <media/AudioParameter.h>
Eric Laurent81784c32012-11-19 14:55:58 -080029#include <utils/Log.h>
Alex Ray371eb972012-11-30 11:11:54 -080030#include <utils/Trace.h>
Eric Laurent81784c32012-11-19 14:55:58 -080031
32#include <private/media/AudioTrackShared.h>
33#include <hardware/audio.h>
34#include <audio_effects/effect_ns.h>
35#include <audio_effects/effect_aec.h>
36#include <audio_utils/primitives.h>
37
38// NBAIO implementations
39#include <media/nbaio/AudioStreamOutSink.h>
40#include <media/nbaio/MonoPipe.h>
41#include <media/nbaio/MonoPipeReader.h>
42#include <media/nbaio/Pipe.h>
43#include <media/nbaio/PipeReader.h>
44#include <media/nbaio/SourceAudioBufferProvider.h>
45
46#include <powermanager/PowerManager.h>
47
48#include <common_time/cc_helper.h>
49#include <common_time/local_clock.h>
50
51#include "AudioFlinger.h"
52#include "AudioMixer.h"
53#include "FastMixer.h"
54#include "ServiceUtilities.h"
55#include "SchedulingPolicyService.h"
56
57#undef ADD_BATTERY_DATA
58
59#ifdef ADD_BATTERY_DATA
60#include <media/IMediaPlayerService.h>
61#include <media/IMediaDeathNotifier.h>
62#endif
63
64// #define DEBUG_CPU_USAGE 10 // log statistics every n wall clock seconds
65#ifdef DEBUG_CPU_USAGE
66#include <cpustats/CentralTendencyStatistics.h>
67#include <cpustats/ThreadCpuUsage.h>
68#endif
69
70// ----------------------------------------------------------------------------
71
72// Note: the following macro is used for extremely verbose logging message. In
73// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
74// 0; but one side effect of this is to turn all LOGV's as well. Some messages
75// are so verbose that we want to suppress them even when we have ALOG_ASSERT
76// turned on. Do not uncomment the #def below unless you really know what you
77// are doing and want to see all of the extremely verbose messages.
78//#define VERY_VERY_VERBOSE_LOGGING
79#ifdef VERY_VERY_VERBOSE_LOGGING
80#define ALOGVV ALOGV
81#else
82#define ALOGVV(a...) do { } while(0)
83#endif
84
85namespace android {
86
87// retry counts for buffer fill timeout
88// 50 * ~20msecs = 1 second
89static const int8_t kMaxTrackRetries = 50;
90static const int8_t kMaxTrackStartupRetries = 50;
91// allow less retry attempts on direct output thread.
92// direct outputs can be a scarce resource in audio hardware and should
93// be released as quickly as possible.
94static const int8_t kMaxTrackRetriesDirect = 2;
95
96// don't warn about blocked writes or record buffer overflows more often than this
97static const nsecs_t kWarningThrottleNs = seconds(5);
98
99// RecordThread loop sleep time upon application overrun or audio HAL read error
100static const int kRecordThreadSleepUs = 5000;
101
102// maximum time to wait for setParameters to complete
103static const nsecs_t kSetParametersTimeoutNs = seconds(2);
104
105// minimum sleep time for the mixer thread loop when tracks are active but in underrun
106static const uint32_t kMinThreadSleepTimeUs = 5000;
107// maximum divider applied to the active sleep time in the mixer thread loop
108static const uint32_t kMaxThreadSleepTimeShift = 2;
109
110// minimum normal mix buffer size, expressed in milliseconds rather than frames
111static const uint32_t kMinNormalMixBufferSizeMs = 20;
112// maximum normal mix buffer size
113static const uint32_t kMaxNormalMixBufferSizeMs = 24;
114
115// Whether to use fast mixer
116static const enum {
117 FastMixer_Never, // never initialize or use: for debugging only
118 FastMixer_Always, // always initialize and use, even if not needed: for debugging only
119 // normal mixer multiplier is 1
120 FastMixer_Static, // initialize if needed, then use all the time if initialized,
121 // multiplier is calculated based on min & max normal mixer buffer size
122 FastMixer_Dynamic, // initialize if needed, then use dynamically depending on track load,
123 // multiplier is calculated based on min & max normal mixer buffer size
124 // FIXME for FastMixer_Dynamic:
125 // Supporting this option will require fixing HALs that can't handle large writes.
126 // For example, one HAL implementation returns an error from a large write,
127 // and another HAL implementation corrupts memory, possibly in the sample rate converter.
128 // We could either fix the HAL implementations, or provide a wrapper that breaks
129 // up large writes into smaller ones, and the wrapper would need to deal with scheduler.
130} kUseFastMixer = FastMixer_Static;
131
132// Priorities for requestPriority
133static const int kPriorityAudioApp = 2;
134static const int kPriorityFastMixer = 3;
135
136// IAudioFlinger::createTrack() reports back to client the total size of shared memory area
137// for the track. The client then sub-divides this into smaller buffers for its use.
138// Currently the client uses double-buffering by default, but doesn't tell us about that.
139// So for now we just assume that client is double-buffered.
140// FIXME It would be better for client to tell AudioFlinger whether it wants double-buffering or
141// N-buffering, so AudioFlinger could allocate the right amount of memory.
142// See the client's minBufCount and mNotificationFramesAct calculations for details.
Glenn Kasten9f80dd22012-12-18 15:57:32 -0800143static const int kFastTrackMultiplier = 1;
Eric Laurent81784c32012-11-19 14:55:58 -0800144
145// ----------------------------------------------------------------------------
146
147#ifdef ADD_BATTERY_DATA
148// To collect the amplifier usage
149static void addBatteryData(uint32_t params) {
150 sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
151 if (service == NULL) {
152 // it already logged
153 return;
154 }
155
156 service->addBatteryData(params);
157}
158#endif
159
160
161// ----------------------------------------------------------------------------
162// CPU Stats
163// ----------------------------------------------------------------------------
164
165class CpuStats {
166public:
167 CpuStats();
168 void sample(const String8 &title);
169#ifdef DEBUG_CPU_USAGE
170private:
171 ThreadCpuUsage mCpuUsage; // instantaneous thread CPU usage in wall clock ns
172 CentralTendencyStatistics mWcStats; // statistics on thread CPU usage in wall clock ns
173
174 CentralTendencyStatistics mHzStats; // statistics on thread CPU usage in cycles
175
176 int mCpuNum; // thread's current CPU number
177 int mCpukHz; // frequency of thread's current CPU in kHz
178#endif
179};
180
181CpuStats::CpuStats()
182#ifdef DEBUG_CPU_USAGE
183 : mCpuNum(-1), mCpukHz(-1)
184#endif
185{
186}
187
188void CpuStats::sample(const String8 &title) {
189#ifdef DEBUG_CPU_USAGE
190 // get current thread's delta CPU time in wall clock ns
191 double wcNs;
192 bool valid = mCpuUsage.sampleAndEnable(wcNs);
193
194 // record sample for wall clock statistics
195 if (valid) {
196 mWcStats.sample(wcNs);
197 }
198
199 // get the current CPU number
200 int cpuNum = sched_getcpu();
201
202 // get the current CPU frequency in kHz
203 int cpukHz = mCpuUsage.getCpukHz(cpuNum);
204
205 // check if either CPU number or frequency changed
206 if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
207 mCpuNum = cpuNum;
208 mCpukHz = cpukHz;
209 // ignore sample for purposes of cycles
210 valid = false;
211 }
212
213 // if no change in CPU number or frequency, then record sample for cycle statistics
214 if (valid && mCpukHz > 0) {
215 double cycles = wcNs * cpukHz * 0.000001;
216 mHzStats.sample(cycles);
217 }
218
219 unsigned n = mWcStats.n();
220 // mCpuUsage.elapsed() is expensive, so don't call it every loop
221 if ((n & 127) == 1) {
222 long long elapsed = mCpuUsage.elapsed();
223 if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
224 double perLoop = elapsed / (double) n;
225 double perLoop100 = perLoop * 0.01;
226 double perLoop1k = perLoop * 0.001;
227 double mean = mWcStats.mean();
228 double stddev = mWcStats.stddev();
229 double minimum = mWcStats.minimum();
230 double maximum = mWcStats.maximum();
231 double meanCycles = mHzStats.mean();
232 double stddevCycles = mHzStats.stddev();
233 double minCycles = mHzStats.minimum();
234 double maxCycles = mHzStats.maximum();
235 mCpuUsage.resetElapsed();
236 mWcStats.reset();
237 mHzStats.reset();
238 ALOGD("CPU usage for %s over past %.1f secs\n"
239 " (%u mixer loops at %.1f mean ms per loop):\n"
240 " us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
241 " %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
242 " MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
243 title.string(),
244 elapsed * .000000001, n, perLoop * .000001,
245 mean * .001,
246 stddev * .001,
247 minimum * .001,
248 maximum * .001,
249 mean / perLoop100,
250 stddev / perLoop100,
251 minimum / perLoop100,
252 maximum / perLoop100,
253 meanCycles / perLoop1k,
254 stddevCycles / perLoop1k,
255 minCycles / perLoop1k,
256 maxCycles / perLoop1k);
257
258 }
259 }
260#endif
261};
262
263// ----------------------------------------------------------------------------
264// ThreadBase
265// ----------------------------------------------------------------------------
266
267AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
268 audio_devices_t outDevice, audio_devices_t inDevice, type_t type)
269 : Thread(false /*canCallJava*/),
270 mType(type),
271 mAudioFlinger(audioFlinger), mSampleRate(0), mFrameCount(0), mNormalFrameCount(0),
272 // mChannelMask
273 mChannelCount(0),
274 mFrameSize(1), mFormat(AUDIO_FORMAT_INVALID),
275 mParamStatus(NO_ERROR),
276 mStandby(false), mOutDevice(outDevice), mInDevice(inDevice),
277 mAudioSource(AUDIO_SOURCE_DEFAULT), mId(id),
278 // mName will be set by concrete (non-virtual) subclass
279 mDeathRecipient(new PMDeathRecipient(this))
280{
281}
282
283AudioFlinger::ThreadBase::~ThreadBase()
284{
285 mParamCond.broadcast();
286 // do not lock the mutex in destructor
287 releaseWakeLock_l();
288 if (mPowerManager != 0) {
289 sp<IBinder> binder = mPowerManager->asBinder();
290 binder->unlinkToDeath(mDeathRecipient);
291 }
292}
293
294void AudioFlinger::ThreadBase::exit()
295{
296 ALOGV("ThreadBase::exit");
297 // do any cleanup required for exit to succeed
298 preExit();
299 {
300 // This lock prevents the following race in thread (uniprocessor for illustration):
301 // if (!exitPending()) {
302 // // context switch from here to exit()
303 // // exit() calls requestExit(), what exitPending() observes
304 // // exit() calls signal(), which is dropped since no waiters
305 // // context switch back from exit() to here
306 // mWaitWorkCV.wait(...);
307 // // now thread is hung
308 // }
309 AutoMutex lock(mLock);
310 requestExit();
311 mWaitWorkCV.broadcast();
312 }
313 // When Thread::requestExitAndWait is made virtual and this method is renamed to
314 // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
315 requestExitAndWait();
316}
317
318status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
319{
320 status_t status;
321
322 ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
323 Mutex::Autolock _l(mLock);
324
325 mNewParameters.add(keyValuePairs);
326 mWaitWorkCV.signal();
327 // wait condition with timeout in case the thread loop has exited
328 // before the request could be processed
329 if (mParamCond.waitRelative(mLock, kSetParametersTimeoutNs) == NO_ERROR) {
330 status = mParamStatus;
331 mWaitWorkCV.signal();
332 } else {
333 status = TIMED_OUT;
334 }
335 return status;
336}
337
338void AudioFlinger::ThreadBase::sendIoConfigEvent(int event, int param)
339{
340 Mutex::Autolock _l(mLock);
341 sendIoConfigEvent_l(event, param);
342}
343
344// sendIoConfigEvent_l() must be called with ThreadBase::mLock held
345void AudioFlinger::ThreadBase::sendIoConfigEvent_l(int event, int param)
346{
347 IoConfigEvent *ioEvent = new IoConfigEvent(event, param);
348 mConfigEvents.add(static_cast<ConfigEvent *>(ioEvent));
349 ALOGV("sendIoConfigEvent() num events %d event %d, param %d", mConfigEvents.size(), event,
350 param);
351 mWaitWorkCV.signal();
352}
353
354// sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
355void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio)
356{
357 PrioConfigEvent *prioEvent = new PrioConfigEvent(pid, tid, prio);
358 mConfigEvents.add(static_cast<ConfigEvent *>(prioEvent));
359 ALOGV("sendPrioConfigEvent_l() num events %d pid %d, tid %d prio %d",
360 mConfigEvents.size(), pid, tid, prio);
361 mWaitWorkCV.signal();
362}
363
364void AudioFlinger::ThreadBase::processConfigEvents()
365{
366 mLock.lock();
367 while (!mConfigEvents.isEmpty()) {
368 ALOGV("processConfigEvents() remaining events %d", mConfigEvents.size());
369 ConfigEvent *event = mConfigEvents[0];
370 mConfigEvents.removeAt(0);
371 // release mLock before locking AudioFlinger mLock: lock order is always
372 // AudioFlinger then ThreadBase to avoid cross deadlock
373 mLock.unlock();
374 switch(event->type()) {
375 case CFG_EVENT_PRIO: {
376 PrioConfigEvent *prioEvent = static_cast<PrioConfigEvent *>(event);
Glenn Kastena07f17c2013-04-23 12:39:37 -0700377 // FIXME Need to understand why this has be done asynchronously
378 int err = requestPriority(prioEvent->pid(), prioEvent->tid(), prioEvent->prio(),
379 true /*asynchronous*/);
Eric Laurent81784c32012-11-19 14:55:58 -0800380 if (err != 0) {
381 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; "
382 "error %d",
383 prioEvent->prio(), prioEvent->pid(), prioEvent->tid(), err);
384 }
385 } break;
386 case CFG_EVENT_IO: {
387 IoConfigEvent *ioEvent = static_cast<IoConfigEvent *>(event);
388 mAudioFlinger->mLock.lock();
389 audioConfigChanged_l(ioEvent->event(), ioEvent->param());
390 mAudioFlinger->mLock.unlock();
391 } break;
392 default:
393 ALOGE("processConfigEvents() unknown event type %d", event->type());
394 break;
395 }
396 delete event;
397 mLock.lock();
398 }
399 mLock.unlock();
400}
401
402void AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args)
403{
404 const size_t SIZE = 256;
405 char buffer[SIZE];
406 String8 result;
407
408 bool locked = AudioFlinger::dumpTryLock(mLock);
409 if (!locked) {
410 snprintf(buffer, SIZE, "thread %p maybe dead locked\n", this);
411 write(fd, buffer, strlen(buffer));
412 }
413
414 snprintf(buffer, SIZE, "io handle: %d\n", mId);
415 result.append(buffer);
416 snprintf(buffer, SIZE, "TID: %d\n", getTid());
417 result.append(buffer);
418 snprintf(buffer, SIZE, "standby: %d\n", mStandby);
419 result.append(buffer);
420 snprintf(buffer, SIZE, "Sample rate: %u\n", mSampleRate);
421 result.append(buffer);
422 snprintf(buffer, SIZE, "HAL frame count: %d\n", mFrameCount);
423 result.append(buffer);
424 snprintf(buffer, SIZE, "Normal frame count: %d\n", mNormalFrameCount);
425 result.append(buffer);
426 snprintf(buffer, SIZE, "Channel Count: %d\n", mChannelCount);
427 result.append(buffer);
428 snprintf(buffer, SIZE, "Channel Mask: 0x%08x\n", mChannelMask);
429 result.append(buffer);
430 snprintf(buffer, SIZE, "Format: %d\n", mFormat);
431 result.append(buffer);
432 snprintf(buffer, SIZE, "Frame size: %u\n", mFrameSize);
433 result.append(buffer);
434
435 snprintf(buffer, SIZE, "\nPending setParameters commands: \n");
436 result.append(buffer);
437 result.append(" Index Command");
438 for (size_t i = 0; i < mNewParameters.size(); ++i) {
439 snprintf(buffer, SIZE, "\n %02d ", i);
440 result.append(buffer);
441 result.append(mNewParameters[i]);
442 }
443
444 snprintf(buffer, SIZE, "\n\nPending config events: \n");
445 result.append(buffer);
446 for (size_t i = 0; i < mConfigEvents.size(); i++) {
447 mConfigEvents[i]->dump(buffer, SIZE);
448 result.append(buffer);
449 }
450 result.append("\n");
451
452 write(fd, result.string(), result.size());
453
454 if (locked) {
455 mLock.unlock();
456 }
457}
458
459void AudioFlinger::ThreadBase::dumpEffectChains(int fd, const Vector<String16>& args)
460{
461 const size_t SIZE = 256;
462 char buffer[SIZE];
463 String8 result;
464
465 snprintf(buffer, SIZE, "\n- %d Effect Chains:\n", mEffectChains.size());
466 write(fd, buffer, strlen(buffer));
467
468 for (size_t i = 0; i < mEffectChains.size(); ++i) {
469 sp<EffectChain> chain = mEffectChains[i];
470 if (chain != 0) {
471 chain->dump(fd, args);
472 }
473 }
474}
475
476void AudioFlinger::ThreadBase::acquireWakeLock()
477{
478 Mutex::Autolock _l(mLock);
479 acquireWakeLock_l();
480}
481
482void AudioFlinger::ThreadBase::acquireWakeLock_l()
483{
484 if (mPowerManager == 0) {
485 // use checkService() to avoid blocking if power service is not up yet
486 sp<IBinder> binder =
487 defaultServiceManager()->checkService(String16("power"));
488 if (binder == 0) {
489 ALOGW("Thread %s cannot connect to the power manager service", mName);
490 } else {
491 mPowerManager = interface_cast<IPowerManager>(binder);
492 binder->linkToDeath(mDeathRecipient);
493 }
494 }
495 if (mPowerManager != 0) {
496 sp<IBinder> binder = new BBinder();
497 status_t status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK,
498 binder,
Dianne Hackborn61d404e2013-05-20 11:22:20 -0700499 String16(mName),
500 String16("media"));
Eric Laurent81784c32012-11-19 14:55:58 -0800501 if (status == NO_ERROR) {
502 mWakeLockToken = binder;
503 }
504 ALOGV("acquireWakeLock_l() %s status %d", mName, status);
505 }
506}
507
508void AudioFlinger::ThreadBase::releaseWakeLock()
509{
510 Mutex::Autolock _l(mLock);
511 releaseWakeLock_l();
512}
513
514void AudioFlinger::ThreadBase::releaseWakeLock_l()
515{
516 if (mWakeLockToken != 0) {
517 ALOGV("releaseWakeLock_l() %s", mName);
518 if (mPowerManager != 0) {
519 mPowerManager->releaseWakeLock(mWakeLockToken, 0);
520 }
521 mWakeLockToken.clear();
522 }
523}
524
525void AudioFlinger::ThreadBase::clearPowerManager()
526{
527 Mutex::Autolock _l(mLock);
528 releaseWakeLock_l();
529 mPowerManager.clear();
530}
531
532void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who)
533{
534 sp<ThreadBase> thread = mThread.promote();
535 if (thread != 0) {
536 thread->clearPowerManager();
537 }
538 ALOGW("power manager service died !!!");
539}
540
541void AudioFlinger::ThreadBase::setEffectSuspended(
542 const effect_uuid_t *type, bool suspend, int sessionId)
543{
544 Mutex::Autolock _l(mLock);
545 setEffectSuspended_l(type, suspend, sessionId);
546}
547
548void AudioFlinger::ThreadBase::setEffectSuspended_l(
549 const effect_uuid_t *type, bool suspend, int sessionId)
550{
551 sp<EffectChain> chain = getEffectChain_l(sessionId);
552 if (chain != 0) {
553 if (type != NULL) {
554 chain->setEffectSuspended_l(type, suspend);
555 } else {
556 chain->setEffectSuspendedAll_l(suspend);
557 }
558 }
559
560 updateSuspendedSessions_l(type, suspend, sessionId);
561}
562
563void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
564{
565 ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
566 if (index < 0) {
567 return;
568 }
569
570 const KeyedVector <int, sp<SuspendedSessionDesc> >& sessionEffects =
571 mSuspendedSessions.valueAt(index);
572
573 for (size_t i = 0; i < sessionEffects.size(); i++) {
574 sp<SuspendedSessionDesc> desc = sessionEffects.valueAt(i);
575 for (int j = 0; j < desc->mRefCount; j++) {
576 if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
577 chain->setEffectSuspendedAll_l(true);
578 } else {
579 ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
580 desc->mType.timeLow);
581 chain->setEffectSuspended_l(&desc->mType, true);
582 }
583 }
584 }
585}
586
587void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
588 bool suspend,
589 int sessionId)
590{
591 ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
592
593 KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
594
595 if (suspend) {
596 if (index >= 0) {
597 sessionEffects = mSuspendedSessions.valueAt(index);
598 } else {
599 mSuspendedSessions.add(sessionId, sessionEffects);
600 }
601 } else {
602 if (index < 0) {
603 return;
604 }
605 sessionEffects = mSuspendedSessions.valueAt(index);
606 }
607
608
609 int key = EffectChain::kKeyForSuspendAll;
610 if (type != NULL) {
611 key = type->timeLow;
612 }
613 index = sessionEffects.indexOfKey(key);
614
615 sp<SuspendedSessionDesc> desc;
616 if (suspend) {
617 if (index >= 0) {
618 desc = sessionEffects.valueAt(index);
619 } else {
620 desc = new SuspendedSessionDesc();
621 if (type != NULL) {
622 desc->mType = *type;
623 }
624 sessionEffects.add(key, desc);
625 ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
626 }
627 desc->mRefCount++;
628 } else {
629 if (index < 0) {
630 return;
631 }
632 desc = sessionEffects.valueAt(index);
633 if (--desc->mRefCount == 0) {
634 ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
635 sessionEffects.removeItemsAt(index);
636 if (sessionEffects.isEmpty()) {
637 ALOGV("updateSuspendedSessions_l() restore removing session %d",
638 sessionId);
639 mSuspendedSessions.removeItem(sessionId);
640 }
641 }
642 }
643 if (!sessionEffects.isEmpty()) {
644 mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
645 }
646}
647
648void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
649 bool enabled,
650 int sessionId)
651{
652 Mutex::Autolock _l(mLock);
653 checkSuspendOnEffectEnabled_l(effect, enabled, sessionId);
654}
655
656void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
657 bool enabled,
658 int sessionId)
659{
660 if (mType != RECORD) {
661 // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
662 // another session. This gives the priority to well behaved effect control panels
663 // and applications not using global effects.
664 // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
665 // global effects
666 if ((sessionId != AUDIO_SESSION_OUTPUT_MIX) && (sessionId != AUDIO_SESSION_OUTPUT_STAGE)) {
667 setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
668 }
669 }
670
671 sp<EffectChain> chain = getEffectChain_l(sessionId);
672 if (chain != 0) {
673 chain->checkSuspendOnEffectEnabled(effect, enabled);
674 }
675}
676
677// ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
678sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
679 const sp<AudioFlinger::Client>& client,
680 const sp<IEffectClient>& effectClient,
681 int32_t priority,
682 int sessionId,
683 effect_descriptor_t *desc,
684 int *enabled,
685 status_t *status
686 )
687{
688 sp<EffectModule> effect;
689 sp<EffectHandle> handle;
690 status_t lStatus;
691 sp<EffectChain> chain;
692 bool chainCreated = false;
693 bool effectCreated = false;
694 bool effectRegistered = false;
695
696 lStatus = initCheck();
697 if (lStatus != NO_ERROR) {
698 ALOGW("createEffect_l() Audio driver not initialized.");
699 goto Exit;
700 }
701
702 // Do not allow effects with session ID 0 on direct output or duplicating threads
703 // TODO: add rule for hw accelerated effects on direct outputs with non PCM format
704 if (sessionId == AUDIO_SESSION_OUTPUT_MIX && mType != MIXER) {
705 ALOGW("createEffect_l() Cannot add auxiliary effect %s to session %d",
706 desc->name, sessionId);
707 lStatus = BAD_VALUE;
708 goto Exit;
709 }
710 // Only Pre processor effects are allowed on input threads and only on input threads
711 if ((mType == RECORD) != ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
712 ALOGW("createEffect_l() effect %s (flags %08x) created on wrong thread type %d",
713 desc->name, desc->flags, mType);
714 lStatus = BAD_VALUE;
715 goto Exit;
716 }
717
718 ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
719
720 { // scope for mLock
721 Mutex::Autolock _l(mLock);
722
723 // check for existing effect chain with the requested audio session
724 chain = getEffectChain_l(sessionId);
725 if (chain == 0) {
726 // create a new chain for this session
727 ALOGV("createEffect_l() new effect chain for session %d", sessionId);
728 chain = new EffectChain(this, sessionId);
729 addEffectChain_l(chain);
730 chain->setStrategy(getStrategyForSession_l(sessionId));
731 chainCreated = true;
732 } else {
733 effect = chain->getEffectFromDesc_l(desc);
734 }
735
736 ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
737
738 if (effect == 0) {
739 int id = mAudioFlinger->nextUniqueId();
740 // Check CPU and memory usage
741 lStatus = AudioSystem::registerEffect(desc, mId, chain->strategy(), sessionId, id);
742 if (lStatus != NO_ERROR) {
743 goto Exit;
744 }
745 effectRegistered = true;
746 // create a new effect module if none present in the chain
747 effect = new EffectModule(this, chain, desc, id, sessionId);
748 lStatus = effect->status();
749 if (lStatus != NO_ERROR) {
750 goto Exit;
751 }
752 lStatus = chain->addEffect_l(effect);
753 if (lStatus != NO_ERROR) {
754 goto Exit;
755 }
756 effectCreated = true;
757
758 effect->setDevice(mOutDevice);
759 effect->setDevice(mInDevice);
760 effect->setMode(mAudioFlinger->getMode());
761 effect->setAudioSource(mAudioSource);
762 }
763 // create effect handle and connect it to effect module
764 handle = new EffectHandle(effect, client, effectClient, priority);
765 lStatus = effect->addHandle(handle.get());
766 if (enabled != NULL) {
767 *enabled = (int)effect->isEnabled();
768 }
769 }
770
771Exit:
772 if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
773 Mutex::Autolock _l(mLock);
774 if (effectCreated) {
775 chain->removeEffect_l(effect);
776 }
777 if (effectRegistered) {
778 AudioSystem::unregisterEffect(effect->id());
779 }
780 if (chainCreated) {
781 removeEffectChain_l(chain);
782 }
783 handle.clear();
784 }
785
786 if (status != NULL) {
787 *status = lStatus;
788 }
789 return handle;
790}
791
792sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(int sessionId, int effectId)
793{
794 Mutex::Autolock _l(mLock);
795 return getEffect_l(sessionId, effectId);
796}
797
798sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(int sessionId, int effectId)
799{
800 sp<EffectChain> chain = getEffectChain_l(sessionId);
801 return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
802}
803
804// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
805// PlaybackThread::mLock held
806status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
807{
808 // check for existing effect chain with the requested audio session
809 int sessionId = effect->sessionId();
810 sp<EffectChain> chain = getEffectChain_l(sessionId);
811 bool chainCreated = false;
812
813 if (chain == 0) {
814 // create a new chain for this session
815 ALOGV("addEffect_l() new effect chain for session %d", sessionId);
816 chain = new EffectChain(this, sessionId);
817 addEffectChain_l(chain);
818 chain->setStrategy(getStrategyForSession_l(sessionId));
819 chainCreated = true;
820 }
821 ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
822
823 if (chain->getEffectFromId_l(effect->id()) != 0) {
824 ALOGW("addEffect_l() %p effect %s already present in chain %p",
825 this, effect->desc().name, chain.get());
826 return BAD_VALUE;
827 }
828
829 status_t status = chain->addEffect_l(effect);
830 if (status != NO_ERROR) {
831 if (chainCreated) {
832 removeEffectChain_l(chain);
833 }
834 return status;
835 }
836
837 effect->setDevice(mOutDevice);
838 effect->setDevice(mInDevice);
839 effect->setMode(mAudioFlinger->getMode());
840 effect->setAudioSource(mAudioSource);
841 return NO_ERROR;
842}
843
844void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect) {
845
846 ALOGV("removeEffect_l() %p effect %p", this, effect.get());
847 effect_descriptor_t desc = effect->desc();
848 if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
849 detachAuxEffect_l(effect->id());
850 }
851
852 sp<EffectChain> chain = effect->chain().promote();
853 if (chain != 0) {
854 // remove effect chain if removing last effect
855 if (chain->removeEffect_l(effect) == 0) {
856 removeEffectChain_l(chain);
857 }
858 } else {
859 ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
860 }
861}
862
863void AudioFlinger::ThreadBase::lockEffectChains_l(
864 Vector< sp<AudioFlinger::EffectChain> >& effectChains)
865{
866 effectChains = mEffectChains;
867 for (size_t i = 0; i < mEffectChains.size(); i++) {
868 mEffectChains[i]->lock();
869 }
870}
871
872void AudioFlinger::ThreadBase::unlockEffectChains(
873 const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
874{
875 for (size_t i = 0; i < effectChains.size(); i++) {
876 effectChains[i]->unlock();
877 }
878}
879
880sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(int sessionId)
881{
882 Mutex::Autolock _l(mLock);
883 return getEffectChain_l(sessionId);
884}
885
886sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(int sessionId) const
887{
888 size_t size = mEffectChains.size();
889 for (size_t i = 0; i < size; i++) {
890 if (mEffectChains[i]->sessionId() == sessionId) {
891 return mEffectChains[i];
892 }
893 }
894 return 0;
895}
896
897void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
898{
899 Mutex::Autolock _l(mLock);
900 size_t size = mEffectChains.size();
901 for (size_t i = 0; i < size; i++) {
902 mEffectChains[i]->setMode_l(mode);
903 }
904}
905
906void AudioFlinger::ThreadBase::disconnectEffect(const sp<EffectModule>& effect,
907 EffectHandle *handle,
908 bool unpinIfLast) {
909
910 Mutex::Autolock _l(mLock);
911 ALOGV("disconnectEffect() %p effect %p", this, effect.get());
912 // delete the effect module if removing last handle on it
913 if (effect->removeHandle(handle) == 0) {
914 if (!effect->isPinned() || unpinIfLast) {
915 removeEffect_l(effect);
916 AudioSystem::unregisterEffect(effect->id());
917 }
918 }
919}
920
921// ----------------------------------------------------------------------------
922// Playback
923// ----------------------------------------------------------------------------
924
925AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
926 AudioStreamOut* output,
927 audio_io_handle_t id,
928 audio_devices_t device,
929 type_t type)
930 : ThreadBase(audioFlinger, id, device, AUDIO_DEVICE_NONE, type),
931 mMixBuffer(NULL), mSuspended(0), mBytesWritten(0),
932 // mStreamTypes[] initialized in constructor body
933 mOutput(output),
934 mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
935 mMixerStatus(MIXER_IDLE),
936 mMixerStatusIgnoringFastTracks(MIXER_IDLE),
937 standbyDelay(AudioFlinger::mStandbyTimeInNsecs),
938 mScreenState(AudioFlinger::mScreenState),
939 // index 0 is reserved for normal mixer's submix
940 mFastTrackAvailMask(((1 << FastMixerState::kMaxFastTracks) - 1) & ~1)
941{
942 snprintf(mName, kNameLength, "AudioOut_%X", id);
Glenn Kasten9e58b552013-01-18 15:09:48 -0800943 mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mName);
Eric Laurent81784c32012-11-19 14:55:58 -0800944
945 // Assumes constructor is called by AudioFlinger with it's mLock held, but
946 // it would be safer to explicitly pass initial masterVolume/masterMute as
947 // parameter.
948 //
949 // If the HAL we are using has support for master volume or master mute,
950 // then do not attenuate or mute during mixing (just leave the volume at 1.0
951 // and the mute set to false).
952 mMasterVolume = audioFlinger->masterVolume_l();
953 mMasterMute = audioFlinger->masterMute_l();
954 if (mOutput && mOutput->audioHwDev) {
955 if (mOutput->audioHwDev->canSetMasterVolume()) {
956 mMasterVolume = 1.0;
957 }
958
959 if (mOutput->audioHwDev->canSetMasterMute()) {
960 mMasterMute = false;
961 }
962 }
963
964 readOutputParameters();
965
966 // mStreamTypes[AUDIO_STREAM_CNT] is initialized by stream_type_t default constructor
967 // There is no AUDIO_STREAM_MIN, and ++ operator does not compile
968 for (audio_stream_type_t stream = (audio_stream_type_t) 0; stream < AUDIO_STREAM_CNT;
969 stream = (audio_stream_type_t) (stream + 1)) {
970 mStreamTypes[stream].volume = mAudioFlinger->streamVolume_l(stream);
971 mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
972 }
973 // mStreamTypes[AUDIO_STREAM_CNT] exists but isn't explicitly initialized here,
974 // because mAudioFlinger doesn't have one to copy from
975}
976
977AudioFlinger::PlaybackThread::~PlaybackThread()
978{
Glenn Kasten9e58b552013-01-18 15:09:48 -0800979 mAudioFlinger->unregisterWriter(mNBLogWriter);
Eric Laurent81784c32012-11-19 14:55:58 -0800980 delete [] mMixBuffer;
981}
982
983void AudioFlinger::PlaybackThread::dump(int fd, const Vector<String16>& args)
984{
985 dumpInternals(fd, args);
986 dumpTracks(fd, args);
987 dumpEffectChains(fd, args);
988}
989
990void AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args)
991{
992 const size_t SIZE = 256;
993 char buffer[SIZE];
994 String8 result;
995
996 result.appendFormat("Output thread %p stream volumes in dB:\n ", this);
997 for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
998 const stream_type_t *st = &mStreamTypes[i];
999 if (i > 0) {
1000 result.appendFormat(", ");
1001 }
1002 result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
1003 if (st->mute) {
1004 result.append("M");
1005 }
1006 }
1007 result.append("\n");
1008 write(fd, result.string(), result.length());
1009 result.clear();
1010
1011 snprintf(buffer, SIZE, "Output thread %p tracks\n", this);
1012 result.append(buffer);
1013 Track::appendDumpHeader(result);
1014 for (size_t i = 0; i < mTracks.size(); ++i) {
1015 sp<Track> track = mTracks[i];
1016 if (track != 0) {
1017 track->dump(buffer, SIZE);
1018 result.append(buffer);
1019 }
1020 }
1021
1022 snprintf(buffer, SIZE, "Output thread %p active tracks\n", this);
1023 result.append(buffer);
1024 Track::appendDumpHeader(result);
1025 for (size_t i = 0; i < mActiveTracks.size(); ++i) {
1026 sp<Track> track = mActiveTracks[i].promote();
1027 if (track != 0) {
1028 track->dump(buffer, SIZE);
1029 result.append(buffer);
1030 }
1031 }
1032 write(fd, result.string(), result.size());
1033
1034 // These values are "raw"; they will wrap around. See prepareTracks_l() for a better way.
1035 FastTrackUnderruns underruns = getFastTrackUnderruns(0);
1036 fdprintf(fd, "Normal mixer raw underrun counters: partial=%u empty=%u\n",
1037 underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
1038}
1039
1040void AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String16>& args)
1041{
1042 const size_t SIZE = 256;
1043 char buffer[SIZE];
1044 String8 result;
1045
1046 snprintf(buffer, SIZE, "\nOutput thread %p internals\n", this);
1047 result.append(buffer);
1048 snprintf(buffer, SIZE, "last write occurred (msecs): %llu\n",
1049 ns2ms(systemTime() - mLastWriteTime));
1050 result.append(buffer);
1051 snprintf(buffer, SIZE, "total writes: %d\n", mNumWrites);
1052 result.append(buffer);
1053 snprintf(buffer, SIZE, "delayed writes: %d\n", mNumDelayedWrites);
1054 result.append(buffer);
1055 snprintf(buffer, SIZE, "blocked in write: %d\n", mInWrite);
1056 result.append(buffer);
1057 snprintf(buffer, SIZE, "suspend count: %d\n", mSuspended);
1058 result.append(buffer);
1059 snprintf(buffer, SIZE, "mix buffer : %p\n", mMixBuffer);
1060 result.append(buffer);
1061 write(fd, result.string(), result.size());
1062 fdprintf(fd, "Fast track availMask=%#x\n", mFastTrackAvailMask);
1063
1064 dumpBase(fd, args);
1065}
1066
1067// Thread virtuals
1068status_t AudioFlinger::PlaybackThread::readyToRun()
1069{
1070 status_t status = initCheck();
1071 if (status == NO_ERROR) {
1072 ALOGI("AudioFlinger's thread %p ready to run", this);
1073 } else {
1074 ALOGE("No working audio driver found.");
1075 }
1076 return status;
1077}
1078
1079void AudioFlinger::PlaybackThread::onFirstRef()
1080{
1081 run(mName, ANDROID_PRIORITY_URGENT_AUDIO);
1082}
1083
1084// ThreadBase virtuals
1085void AudioFlinger::PlaybackThread::preExit()
1086{
1087 ALOGV(" preExit()");
1088 // FIXME this is using hard-coded strings but in the future, this functionality will be
1089 // converted to use audio HAL extensions required to support tunneling
1090 mOutput->stream->common.set_parameters(&mOutput->stream->common, "exiting=1");
1091}
1092
1093// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
1094sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
1095 const sp<AudioFlinger::Client>& client,
1096 audio_stream_type_t streamType,
1097 uint32_t sampleRate,
1098 audio_format_t format,
1099 audio_channel_mask_t channelMask,
1100 size_t frameCount,
1101 const sp<IMemory>& sharedBuffer,
1102 int sessionId,
1103 IAudioFlinger::track_flags_t *flags,
1104 pid_t tid,
1105 status_t *status)
1106{
1107 sp<Track> track;
1108 status_t lStatus;
1109
1110 bool isTimed = (*flags & IAudioFlinger::TRACK_TIMED) != 0;
1111
1112 // client expresses a preference for FAST, but we get the final say
1113 if (*flags & IAudioFlinger::TRACK_FAST) {
1114 if (
1115 // not timed
1116 (!isTimed) &&
1117 // either of these use cases:
1118 (
1119 // use case 1: shared buffer with any frame count
1120 (
1121 (sharedBuffer != 0)
1122 ) ||
1123 // use case 2: callback handler and frame count is default or at least as large as HAL
1124 (
1125 (tid != -1) &&
1126 ((frameCount == 0) ||
1127 (frameCount >= (mFrameCount * kFastTrackMultiplier)))
1128 )
1129 ) &&
1130 // PCM data
1131 audio_is_linear_pcm(format) &&
1132 // mono or stereo
1133 ( (channelMask == AUDIO_CHANNEL_OUT_MONO) ||
1134 (channelMask == AUDIO_CHANNEL_OUT_STEREO) ) &&
1135#ifndef FAST_TRACKS_AT_NON_NATIVE_SAMPLE_RATE
1136 // hardware sample rate
1137 (sampleRate == mSampleRate) &&
1138#endif
1139 // normal mixer has an associated fast mixer
1140 hasFastMixer() &&
1141 // there are sufficient fast track slots available
1142 (mFastTrackAvailMask != 0)
1143 // FIXME test that MixerThread for this fast track has a capable output HAL
1144 // FIXME add a permission test also?
1145 ) {
1146 // if frameCount not specified, then it defaults to fast mixer (HAL) frame count
1147 if (frameCount == 0) {
1148 frameCount = mFrameCount * kFastTrackMultiplier;
1149 }
1150 ALOGV("AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%d mFrameCount=%d",
1151 frameCount, mFrameCount);
1152 } else {
1153 ALOGV("AUDIO_OUTPUT_FLAG_FAST denied: isTimed=%d sharedBuffer=%p frameCount=%d "
1154 "mFrameCount=%d format=%d isLinear=%d channelMask=%#x sampleRate=%u mSampleRate=%u "
1155 "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
1156 isTimed, sharedBuffer.get(), frameCount, mFrameCount, format,
1157 audio_is_linear_pcm(format),
1158 channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
1159 *flags &= ~IAudioFlinger::TRACK_FAST;
1160 // For compatibility with AudioTrack calculation, buffer depth is forced
1161 // to be at least 2 x the normal mixer frame count and cover audio hardware latency.
1162 // This is probably too conservative, but legacy application code may depend on it.
1163 // If you change this calculation, also review the start threshold which is related.
1164 uint32_t latencyMs = mOutput->stream->get_latency(mOutput->stream);
1165 uint32_t minBufCount = latencyMs / ((1000 * mNormalFrameCount) / mSampleRate);
1166 if (minBufCount < 2) {
1167 minBufCount = 2;
1168 }
1169 size_t minFrameCount = mNormalFrameCount * minBufCount;
1170 if (frameCount < minFrameCount) {
1171 frameCount = minFrameCount;
1172 }
1173 }
1174 }
1175
1176 if (mType == DIRECT) {
1177 if ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM) {
1178 if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
1179 ALOGE("createTrack_l() Bad parameter: sampleRate %u format %d, channelMask 0x%08x "
1180 "for output %p with format %d",
1181 sampleRate, format, channelMask, mOutput, mFormat);
1182 lStatus = BAD_VALUE;
1183 goto Exit;
1184 }
1185 }
1186 } else {
1187 // Resampler implementation limits input sampling rate to 2 x output sampling rate.
1188 if (sampleRate > mSampleRate*2) {
1189 ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
1190 lStatus = BAD_VALUE;
1191 goto Exit;
1192 }
1193 }
1194
1195 lStatus = initCheck();
1196 if (lStatus != NO_ERROR) {
1197 ALOGE("Audio driver not initialized.");
1198 goto Exit;
1199 }
1200
1201 { // scope for mLock
1202 Mutex::Autolock _l(mLock);
1203
1204 // all tracks in same audio session must share the same routing strategy otherwise
1205 // conflicts will happen when tracks are moved from one output to another by audio policy
1206 // manager
1207 uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
1208 for (size_t i = 0; i < mTracks.size(); ++i) {
1209 sp<Track> t = mTracks[i];
1210 if (t != 0 && !t->isOutputTrack()) {
1211 uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
1212 if (sessionId == t->sessionId() && strategy != actual) {
1213 ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
1214 strategy, actual);
1215 lStatus = BAD_VALUE;
1216 goto Exit;
1217 }
1218 }
1219 }
1220
1221 if (!isTimed) {
1222 track = new Track(this, client, streamType, sampleRate, format,
1223 channelMask, frameCount, sharedBuffer, sessionId, *flags);
1224 } else {
1225 track = TimedTrack::create(this, client, streamType, sampleRate, format,
1226 channelMask, frameCount, sharedBuffer, sessionId);
1227 }
1228 if (track == 0 || track->getCblk() == NULL || track->name() < 0) {
1229 lStatus = NO_MEMORY;
1230 goto Exit;
1231 }
1232 mTracks.add(track);
1233
1234 sp<EffectChain> chain = getEffectChain_l(sessionId);
1235 if (chain != 0) {
1236 ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
1237 track->setMainBuffer(chain->inBuffer());
1238 chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
1239 chain->incTrackCnt();
1240 }
1241
1242 if ((*flags & IAudioFlinger::TRACK_FAST) && (tid != -1)) {
1243 pid_t callingPid = IPCThreadState::self()->getCallingPid();
1244 // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
1245 // so ask activity manager to do this on our behalf
1246 sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp);
1247 }
1248 }
1249
1250 lStatus = NO_ERROR;
1251
1252Exit:
1253 if (status) {
1254 *status = lStatus;
1255 }
1256 return track;
1257}
1258
1259uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
1260{
1261 return latency;
1262}
1263
1264uint32_t AudioFlinger::PlaybackThread::latency() const
1265{
1266 Mutex::Autolock _l(mLock);
1267 return latency_l();
1268}
1269uint32_t AudioFlinger::PlaybackThread::latency_l() const
1270{
1271 if (initCheck() == NO_ERROR) {
1272 return correctLatency_l(mOutput->stream->get_latency(mOutput->stream));
1273 } else {
1274 return 0;
1275 }
1276}
1277
1278void AudioFlinger::PlaybackThread::setMasterVolume(float value)
1279{
1280 Mutex::Autolock _l(mLock);
1281 // Don't apply master volume in SW if our HAL can do it for us.
1282 if (mOutput && mOutput->audioHwDev &&
1283 mOutput->audioHwDev->canSetMasterVolume()) {
1284 mMasterVolume = 1.0;
1285 } else {
1286 mMasterVolume = value;
1287 }
1288}
1289
1290void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
1291{
1292 Mutex::Autolock _l(mLock);
1293 // Don't apply master mute in SW if our HAL can do it for us.
1294 if (mOutput && mOutput->audioHwDev &&
1295 mOutput->audioHwDev->canSetMasterMute()) {
1296 mMasterMute = false;
1297 } else {
1298 mMasterMute = muted;
1299 }
1300}
1301
1302void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
1303{
1304 Mutex::Autolock _l(mLock);
1305 mStreamTypes[stream].volume = value;
1306}
1307
1308void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
1309{
1310 Mutex::Autolock _l(mLock);
1311 mStreamTypes[stream].mute = muted;
1312}
1313
1314float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
1315{
1316 Mutex::Autolock _l(mLock);
1317 return mStreamTypes[stream].volume;
1318}
1319
1320// addTrack_l() must be called with ThreadBase::mLock held
1321status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
1322{
1323 status_t status = ALREADY_EXISTS;
1324
1325 // set retry count for buffer fill
1326 track->mRetryCount = kMaxTrackStartupRetries;
1327 if (mActiveTracks.indexOf(track) < 0) {
1328 // the track is newly added, make sure it fills up all its
1329 // buffers before playing. This is to ensure the client will
1330 // effectively get the latency it requested.
Glenn Kasten9f80dd22012-12-18 15:57:32 -08001331 track->mFillingUpStatus = track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
Eric Laurent81784c32012-11-19 14:55:58 -08001332 track->mResetDone = false;
1333 track->mPresentationCompleteFrames = 0;
1334 mActiveTracks.add(track);
Eric Laurentd0107bc2013-06-11 14:38:48 -07001335 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
1336 if (chain != 0) {
1337 ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
1338 track->sessionId());
1339 chain->incActiveTrackCnt();
Eric Laurent81784c32012-11-19 14:55:58 -08001340 }
1341
1342 status = NO_ERROR;
1343 }
1344
1345 ALOGV("mWaitWorkCV.broadcast");
1346 mWaitWorkCV.broadcast();
1347
1348 return status;
1349}
1350
1351// destroyTrack_l() must be called with ThreadBase::mLock held
1352void AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
1353{
1354 track->mState = TrackBase::TERMINATED;
1355 // active tracks are removed by threadLoop()
1356 if (mActiveTracks.indexOf(track) < 0) {
1357 removeTrack_l(track);
1358 }
1359}
1360
1361void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
1362{
1363 track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
1364 mTracks.remove(track);
1365 deleteTrackName_l(track->name());
1366 // redundant as track is about to be destroyed, for dumpsys only
1367 track->mName = -1;
1368 if (track->isFastTrack()) {
1369 int index = track->mFastIndex;
1370 ALOG_ASSERT(0 < index && index < (int)FastMixerState::kMaxFastTracks);
1371 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
1372 mFastTrackAvailMask |= 1 << index;
1373 // redundant as track is about to be destroyed, for dumpsys only
1374 track->mFastIndex = -1;
1375 }
1376 sp<EffectChain> chain = getEffectChain_l(track->sessionId());
1377 if (chain != 0) {
1378 chain->decTrackCnt();
1379 }
1380}
1381
1382String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
1383{
1384 String8 out_s8 = String8("");
1385 char *s;
1386
1387 Mutex::Autolock _l(mLock);
1388 if (initCheck() != NO_ERROR) {
1389 return out_s8;
1390 }
1391
1392 s = mOutput->stream->common.get_parameters(&mOutput->stream->common, keys.string());
1393 out_s8 = String8(s);
1394 free(s);
1395 return out_s8;
1396}
1397
1398// audioConfigChanged_l() must be called with AudioFlinger::mLock held
1399void AudioFlinger::PlaybackThread::audioConfigChanged_l(int event, int param) {
1400 AudioSystem::OutputDescriptor desc;
1401 void *param2 = NULL;
1402
1403 ALOGV("PlaybackThread::audioConfigChanged_l, thread %p, event %d, param %d", this, event,
1404 param);
1405
1406 switch (event) {
1407 case AudioSystem::OUTPUT_OPENED:
1408 case AudioSystem::OUTPUT_CONFIG_CHANGED:
1409 desc.channels = mChannelMask;
1410 desc.samplingRate = mSampleRate;
1411 desc.format = mFormat;
1412 desc.frameCount = mNormalFrameCount; // FIXME see
1413 // AudioFlinger::frameCount(audio_io_handle_t)
1414 desc.latency = latency();
1415 param2 = &desc;
1416 break;
1417
1418 case AudioSystem::STREAM_CONFIG_CHANGED:
1419 param2 = &param;
1420 case AudioSystem::OUTPUT_CLOSED:
1421 default:
1422 break;
1423 }
1424 mAudioFlinger->audioConfigChanged_l(event, mId, param2);
1425}
1426
1427void AudioFlinger::PlaybackThread::readOutputParameters()
1428{
1429 mSampleRate = mOutput->stream->common.get_sample_rate(&mOutput->stream->common);
1430 mChannelMask = mOutput->stream->common.get_channels(&mOutput->stream->common);
1431 mChannelCount = (uint16_t)popcount(mChannelMask);
1432 mFormat = mOutput->stream->common.get_format(&mOutput->stream->common);
1433 mFrameSize = audio_stream_frame_size(&mOutput->stream->common);
1434 mFrameCount = mOutput->stream->common.get_buffer_size(&mOutput->stream->common) / mFrameSize;
1435 if (mFrameCount & 15) {
1436 ALOGW("HAL output buffer size is %u frames but AudioMixer requires multiples of 16 frames",
1437 mFrameCount);
1438 }
1439
1440 // Calculate size of normal mix buffer relative to the HAL output buffer size
1441 double multiplier = 1.0;
1442 if (mType == MIXER && (kUseFastMixer == FastMixer_Static ||
1443 kUseFastMixer == FastMixer_Dynamic)) {
1444 size_t minNormalFrameCount = (kMinNormalMixBufferSizeMs * mSampleRate) / 1000;
1445 size_t maxNormalFrameCount = (kMaxNormalMixBufferSizeMs * mSampleRate) / 1000;
1446 // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
1447 minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
1448 maxNormalFrameCount = maxNormalFrameCount & ~15;
1449 if (maxNormalFrameCount < minNormalFrameCount) {
1450 maxNormalFrameCount = minNormalFrameCount;
1451 }
1452 multiplier = (double) minNormalFrameCount / (double) mFrameCount;
1453 if (multiplier <= 1.0) {
1454 multiplier = 1.0;
1455 } else if (multiplier <= 2.0) {
1456 if (2 * mFrameCount <= maxNormalFrameCount) {
1457 multiplier = 2.0;
1458 } else {
1459 multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
1460 }
1461 } else {
1462 // prefer an even multiplier, for compatibility with doubling of fast tracks due to HAL
1463 // SRC (it would be unusual for the normal mix buffer size to not be a multiple of fast
1464 // track, but we sometimes have to do this to satisfy the maximum frame count
1465 // constraint)
1466 // FIXME this rounding up should not be done if no HAL SRC
1467 uint32_t truncMult = (uint32_t) multiplier;
1468 if ((truncMult & 1)) {
1469 if ((truncMult + 1) * mFrameCount <= maxNormalFrameCount) {
1470 ++truncMult;
1471 }
1472 }
1473 multiplier = (double) truncMult;
1474 }
1475 }
1476 mNormalFrameCount = multiplier * mFrameCount;
1477 // round up to nearest 16 frames to satisfy AudioMixer
1478 mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
1479 ALOGI("HAL output buffer size %u frames, normal mix buffer size %u frames", mFrameCount,
1480 mNormalFrameCount);
1481
1482 delete[] mMixBuffer;
1483 mMixBuffer = new int16_t[mNormalFrameCount * mChannelCount];
1484 memset(mMixBuffer, 0, mNormalFrameCount * mChannelCount * sizeof(int16_t));
1485
1486 // force reconfiguration of effect chains and engines to take new buffer size and audio
1487 // parameters into account
1488 // Note that mLock is not held when readOutputParameters() is called from the constructor
1489 // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
1490 // matter.
1491 // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
1492 Vector< sp<EffectChain> > effectChains = mEffectChains;
1493 for (size_t i = 0; i < effectChains.size(); i ++) {
1494 mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(), this, this, false);
1495 }
1496}
1497
1498
1499status_t AudioFlinger::PlaybackThread::getRenderPosition(size_t *halFrames, size_t *dspFrames)
1500{
1501 if (halFrames == NULL || dspFrames == NULL) {
1502 return BAD_VALUE;
1503 }
1504 Mutex::Autolock _l(mLock);
1505 if (initCheck() != NO_ERROR) {
1506 return INVALID_OPERATION;
1507 }
1508 size_t framesWritten = mBytesWritten / mFrameSize;
1509 *halFrames = framesWritten;
1510
1511 if (isSuspended()) {
1512 // return an estimation of rendered frames when the output is suspended
1513 size_t latencyFrames = (latency_l() * mSampleRate) / 1000;
1514 *dspFrames = framesWritten >= latencyFrames ? framesWritten - latencyFrames : 0;
1515 return NO_ERROR;
1516 } else {
1517 return mOutput->stream->get_render_position(mOutput->stream, dspFrames);
1518 }
1519}
1520
1521uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId) const
1522{
1523 Mutex::Autolock _l(mLock);
1524 uint32_t result = 0;
1525 if (getEffectChain_l(sessionId) != 0) {
1526 result = EFFECT_SESSION;
1527 }
1528
1529 for (size_t i = 0; i < mTracks.size(); ++i) {
1530 sp<Track> track = mTracks[i];
Glenn Kasten5736c352012-12-04 12:12:34 -08001531 if (sessionId == track->sessionId() && !track->isInvalid()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001532 result |= TRACK_SESSION;
1533 break;
1534 }
1535 }
1536
1537 return result;
1538}
1539
1540uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(int sessionId)
1541{
1542 // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
1543 // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
1544 if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1545 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
1546 }
1547 for (size_t i = 0; i < mTracks.size(); i++) {
1548 sp<Track> track = mTracks[i];
Glenn Kasten5736c352012-12-04 12:12:34 -08001549 if (sessionId == track->sessionId() && !track->isInvalid()) {
Eric Laurent81784c32012-11-19 14:55:58 -08001550 return AudioSystem::getStrategyForStream(track->streamType());
1551 }
1552 }
1553 return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
1554}
1555
1556
1557AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
1558{
1559 Mutex::Autolock _l(mLock);
1560 return mOutput;
1561}
1562
1563AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
1564{
1565 Mutex::Autolock _l(mLock);
1566 AudioStreamOut *output = mOutput;
1567 mOutput = NULL;
1568 // FIXME FastMixer might also have a raw ptr to mOutputSink;
1569 // must push a NULL and wait for ack
1570 mOutputSink.clear();
1571 mPipeSink.clear();
1572 mNormalSink.clear();
1573 return output;
1574}
1575
1576// this method must always be called either with ThreadBase mLock held or inside the thread loop
1577audio_stream_t* AudioFlinger::PlaybackThread::stream() const
1578{
1579 if (mOutput == NULL) {
1580 return NULL;
1581 }
1582 return &mOutput->stream->common;
1583}
1584
1585uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
1586{
1587 return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
1588}
1589
1590status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
1591{
1592 if (!isValidSyncEvent(event)) {
1593 return BAD_VALUE;
1594 }
1595
1596 Mutex::Autolock _l(mLock);
1597
1598 for (size_t i = 0; i < mTracks.size(); ++i) {
1599 sp<Track> track = mTracks[i];
1600 if (event->triggerSession() == track->sessionId()) {
1601 (void) track->setSyncEvent(event);
1602 return NO_ERROR;
1603 }
1604 }
1605
1606 return NAME_NOT_FOUND;
1607}
1608
1609bool AudioFlinger::PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event) const
1610{
1611 return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
1612}
1613
1614void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
1615 const Vector< sp<Track> >& tracksToRemove)
1616{
1617 size_t count = tracksToRemove.size();
1618 if (CC_UNLIKELY(count)) {
1619 for (size_t i = 0 ; i < count ; i++) {
1620 const sp<Track>& track = tracksToRemove.itemAt(i);
1621 if ((track->sharedBuffer() != 0) &&
1622 (track->mState == TrackBase::ACTIVE || track->mState == TrackBase::RESUMING)) {
1623 AudioSystem::stopOutput(mId, track->streamType(), track->sessionId());
1624 }
1625 }
1626 }
1627
1628}
1629
1630void AudioFlinger::PlaybackThread::checkSilentMode_l()
1631{
1632 if (!mMasterMute) {
1633 char value[PROPERTY_VALUE_MAX];
1634 if (property_get("ro.audio.silent", value, "0") > 0) {
1635 char *endptr;
1636 unsigned long ul = strtoul(value, &endptr, 0);
1637 if (*endptr == '\0' && ul != 0) {
1638 ALOGD("Silence is golden");
1639 // The setprop command will not allow a property to be changed after
1640 // the first time it is set, so we don't have to worry about un-muting.
1641 setMasterMute_l(true);
1642 }
1643 }
1644 }
1645}
1646
1647// shared by MIXER and DIRECT, overridden by DUPLICATING
1648void AudioFlinger::PlaybackThread::threadLoop_write()
1649{
1650 // FIXME rewrite to reduce number of system calls
1651 mLastWriteTime = systemTime();
1652 mInWrite = true;
1653 int bytesWritten;
1654
1655 // If an NBAIO sink is present, use it to write the normal mixer's submix
1656 if (mNormalSink != 0) {
1657#define mBitShift 2 // FIXME
1658 size_t count = mixBufferSize >> mBitShift;
Simon Wilson2d590962012-11-29 15:18:50 -08001659 ATRACE_BEGIN("write");
Eric Laurent81784c32012-11-19 14:55:58 -08001660 // update the setpoint when AudioFlinger::mScreenState changes
1661 uint32_t screenState = AudioFlinger::mScreenState;
1662 if (screenState != mScreenState) {
1663 mScreenState = screenState;
1664 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
1665 if (pipe != NULL) {
1666 pipe->setAvgFrames((mScreenState & 1) ?
1667 (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
1668 }
1669 }
1670 ssize_t framesWritten = mNormalSink->write(mMixBuffer, count);
Simon Wilson2d590962012-11-29 15:18:50 -08001671 ATRACE_END();
Eric Laurent81784c32012-11-19 14:55:58 -08001672 if (framesWritten > 0) {
1673 bytesWritten = framesWritten << mBitShift;
1674 } else {
1675 bytesWritten = framesWritten;
1676 }
1677 // otherwise use the HAL / AudioStreamOut directly
1678 } else {
1679 // Direct output thread.
1680 bytesWritten = (int)mOutput->stream->write(mOutput->stream, mMixBuffer, mixBufferSize);
1681 }
1682
1683 if (bytesWritten > 0) {
1684 mBytesWritten += mixBufferSize;
1685 }
1686 mNumWrites++;
1687 mInWrite = false;
1688}
1689
1690/*
1691The derived values that are cached:
1692 - mixBufferSize from frame count * frame size
1693 - activeSleepTime from activeSleepTimeUs()
1694 - idleSleepTime from idleSleepTimeUs()
1695 - standbyDelay from mActiveSleepTimeUs (DIRECT only)
1696 - maxPeriod from frame count and sample rate (MIXER only)
1697
1698The parameters that affect these derived values are:
1699 - frame count
1700 - frame size
1701 - sample rate
1702 - device type: A2DP or not
1703 - device latency
1704 - format: PCM or not
1705 - active sleep time
1706 - idle sleep time
1707*/
1708
1709void AudioFlinger::PlaybackThread::cacheParameters_l()
1710{
1711 mixBufferSize = mNormalFrameCount * mFrameSize;
1712 activeSleepTime = activeSleepTimeUs();
1713 idleSleepTime = idleSleepTimeUs();
1714}
1715
1716void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
1717{
Glenn Kasten7c027242012-12-26 14:43:16 -08001718 ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %d",
Eric Laurent81784c32012-11-19 14:55:58 -08001719 this, streamType, mTracks.size());
1720 Mutex::Autolock _l(mLock);
1721
1722 size_t size = mTracks.size();
1723 for (size_t i = 0; i < size; i++) {
1724 sp<Track> t = mTracks[i];
1725 if (t->streamType() == streamType) {
Glenn Kasten5736c352012-12-04 12:12:34 -08001726 t->invalidate();
Eric Laurent81784c32012-11-19 14:55:58 -08001727 }
1728 }
1729}
1730
1731status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
1732{
1733 int session = chain->sessionId();
1734 int16_t *buffer = mMixBuffer;
1735 bool ownsBuffer = false;
1736
1737 ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
1738 if (session > 0) {
1739 // Only one effect chain can be present in direct output thread and it uses
1740 // the mix buffer as input
1741 if (mType != DIRECT) {
1742 size_t numSamples = mNormalFrameCount * mChannelCount;
1743 buffer = new int16_t[numSamples];
1744 memset(buffer, 0, numSamples * sizeof(int16_t));
1745 ALOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session);
1746 ownsBuffer = true;
1747 }
1748
1749 // Attach all tracks with same session ID to this chain.
1750 for (size_t i = 0; i < mTracks.size(); ++i) {
1751 sp<Track> track = mTracks[i];
1752 if (session == track->sessionId()) {
1753 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(),
1754 buffer);
1755 track->setMainBuffer(buffer);
1756 chain->incTrackCnt();
1757 }
1758 }
1759
1760 // indicate all active tracks in the chain
1761 for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
1762 sp<Track> track = mActiveTracks[i].promote();
1763 if (track == 0) {
1764 continue;
1765 }
1766 if (session == track->sessionId()) {
1767 ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
1768 chain->incActiveTrackCnt();
1769 }
1770 }
1771 }
1772
1773 chain->setInBuffer(buffer, ownsBuffer);
1774 chain->setOutBuffer(mMixBuffer);
1775 // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect
1776 // chains list in order to be processed last as it contains output stage effects
1777 // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
1778 // session AUDIO_SESSION_OUTPUT_STAGE to be processed
1779 // after track specific effects and before output stage
1780 // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
1781 // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX
1782 // Effect chain for other sessions are inserted at beginning of effect
1783 // chains list to be processed before output mix effects. Relative order between other
1784 // sessions is not important
1785 size_t size = mEffectChains.size();
1786 size_t i = 0;
1787 for (i = 0; i < size; i++) {
1788 if (mEffectChains[i]->sessionId() < session) {
1789 break;
1790 }
1791 }
1792 mEffectChains.insertAt(chain, i);
1793 checkSuspendOnAddEffectChain_l(chain);
1794
1795 return NO_ERROR;
1796}
1797
1798size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
1799{
1800 int session = chain->sessionId();
1801
1802 ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
1803
1804 for (size_t i = 0; i < mEffectChains.size(); i++) {
1805 if (chain == mEffectChains[i]) {
1806 mEffectChains.removeAt(i);
1807 // detach all active tracks from the chain
1808 for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
1809 sp<Track> track = mActiveTracks[i].promote();
1810 if (track == 0) {
1811 continue;
1812 }
1813 if (session == track->sessionId()) {
1814 ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
1815 chain.get(), session);
1816 chain->decActiveTrackCnt();
1817 }
1818 }
1819
1820 // detach all tracks with same session ID from this chain
1821 for (size_t i = 0; i < mTracks.size(); ++i) {
1822 sp<Track> track = mTracks[i];
1823 if (session == track->sessionId()) {
1824 track->setMainBuffer(mMixBuffer);
1825 chain->decTrackCnt();
1826 }
1827 }
1828 break;
1829 }
1830 }
1831 return mEffectChains.size();
1832}
1833
1834status_t AudioFlinger::PlaybackThread::attachAuxEffect(
1835 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
1836{
1837 Mutex::Autolock _l(mLock);
1838 return attachAuxEffect_l(track, EffectId);
1839}
1840
1841status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
1842 const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
1843{
1844 status_t status = NO_ERROR;
1845
1846 if (EffectId == 0) {
1847 track->setAuxBuffer(0, NULL);
1848 } else {
1849 // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
1850 sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
1851 if (effect != 0) {
1852 if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
1853 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
1854 } else {
1855 status = INVALID_OPERATION;
1856 }
1857 } else {
1858 status = BAD_VALUE;
1859 }
1860 }
1861 return status;
1862}
1863
1864void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
1865{
1866 for (size_t i = 0; i < mTracks.size(); ++i) {
1867 sp<Track> track = mTracks[i];
1868 if (track->auxEffectId() == effectId) {
1869 attachAuxEffect_l(track, 0);
1870 }
1871 }
1872}
1873
1874bool AudioFlinger::PlaybackThread::threadLoop()
1875{
1876 Vector< sp<Track> > tracksToRemove;
1877
1878 standbyTime = systemTime();
1879
1880 // MIXER
1881 nsecs_t lastWarning = 0;
1882
1883 // DUPLICATING
1884 // FIXME could this be made local to while loop?
1885 writeFrames = 0;
1886
1887 cacheParameters_l();
1888 sleepTime = idleSleepTime;
1889
1890 if (mType == MIXER) {
1891 sleepTimeShift = 0;
1892 }
1893
1894 CpuStats cpuStats;
1895 const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
1896
1897 acquireWakeLock();
1898
Glenn Kasten9e58b552013-01-18 15:09:48 -08001899 // mNBLogWriter->log can only be called while thread mutex mLock is held.
1900 // So if you need to log when mutex is unlocked, set logString to a non-NULL string,
1901 // and then that string will be logged at the next convenient opportunity.
1902 const char *logString = NULL;
1903
Eric Laurent81784c32012-11-19 14:55:58 -08001904 while (!exitPending())
1905 {
1906 cpuStats.sample(myName);
1907
1908 Vector< sp<EffectChain> > effectChains;
1909
1910 processConfigEvents();
1911
1912 { // scope for mLock
1913
1914 Mutex::Autolock _l(mLock);
1915
Glenn Kasten9e58b552013-01-18 15:09:48 -08001916 if (logString != NULL) {
1917 mNBLogWriter->logTimestamp();
1918 mNBLogWriter->log(logString);
1919 logString = NULL;
1920 }
1921
Eric Laurent81784c32012-11-19 14:55:58 -08001922 if (checkForNewParameters_l()) {
1923 cacheParameters_l();
1924 }
1925
1926 saveOutputTracks();
1927
1928 // put audio hardware into standby after short delay
1929 if (CC_UNLIKELY((!mActiveTracks.size() && systemTime() > standbyTime) ||
1930 isSuspended())) {
1931 if (!mStandby) {
1932
1933 threadLoop_standby();
1934
1935 mStandby = true;
1936 }
1937
1938 if (!mActiveTracks.size() && mConfigEvents.isEmpty()) {
1939 // we're about to wait, flush the binder command buffer
1940 IPCThreadState::self()->flushCommands();
1941
1942 clearOutputTracks();
1943
1944 if (exitPending()) {
1945 break;
1946 }
1947
1948 releaseWakeLock_l();
1949 // wait until we have something to do...
1950 ALOGV("%s going to sleep", myName.string());
1951 mWaitWorkCV.wait(mLock);
1952 ALOGV("%s waking up", myName.string());
1953 acquireWakeLock_l();
1954
1955 mMixerStatus = MIXER_IDLE;
1956 mMixerStatusIgnoringFastTracks = MIXER_IDLE;
1957 mBytesWritten = 0;
1958
1959 checkSilentMode_l();
1960
1961 standbyTime = systemTime() + standbyDelay;
1962 sleepTime = idleSleepTime;
1963 if (mType == MIXER) {
1964 sleepTimeShift = 0;
1965 }
1966
1967 continue;
1968 }
1969 }
1970
1971 // mMixerStatusIgnoringFastTracks is also updated internally
1972 mMixerStatus = prepareTracks_l(&tracksToRemove);
1973
1974 // prevent any changes in effect chain list and in each effect chain
1975 // during mixing and effect process as the audio buffers could be deleted
1976 // or modified if an effect is created or deleted
1977 lockEffectChains_l(effectChains);
1978 }
1979
1980 if (CC_LIKELY(mMixerStatus == MIXER_TRACKS_READY)) {
1981 threadLoop_mix();
1982 } else {
1983 threadLoop_sleepTime();
1984 }
1985
1986 if (isSuspended()) {
1987 sleepTime = suspendSleepTimeUs();
1988 mBytesWritten += mixBufferSize;
1989 }
1990
1991 // only process effects if we're going to write
1992 if (sleepTime == 0) {
1993 for (size_t i = 0; i < effectChains.size(); i ++) {
1994 effectChains[i]->process_l();
1995 }
1996 }
1997
1998 // enable changes in effect chain
1999 unlockEffectChains(effectChains);
2000
2001 // sleepTime == 0 means we must write to audio hardware
2002 if (sleepTime == 0) {
2003
2004 threadLoop_write();
2005
2006if (mType == MIXER) {
2007 // write blocked detection
2008 nsecs_t now = systemTime();
2009 nsecs_t delta = now - mLastWriteTime;
2010 if (!mStandby && delta > maxPeriod) {
2011 mNumDelayedWrites++;
2012 if ((now - lastWarning) > kWarningThrottleNs) {
Alex Ray371eb972012-11-30 11:11:54 -08002013 ATRACE_NAME("underrun");
Eric Laurent81784c32012-11-19 14:55:58 -08002014 ALOGW("write blocked for %llu msecs, %d delayed writes, thread %p",
2015 ns2ms(delta), mNumDelayedWrites, this);
2016 lastWarning = now;
2017 }
2018 }
2019}
2020
2021 mStandby = false;
2022 } else {
2023 usleep(sleepTime);
2024 }
2025
2026 // Finally let go of removed track(s), without the lock held
2027 // since we can't guarantee the destructors won't acquire that
2028 // same lock. This will also mutate and push a new fast mixer state.
2029 threadLoop_removeTracks(tracksToRemove);
2030 tracksToRemove.clear();
2031
2032 // FIXME I don't understand the need for this here;
2033 // it was in the original code but maybe the
2034 // assignment in saveOutputTracks() makes this unnecessary?
2035 clearOutputTracks();
2036
2037 // Effect chains will be actually deleted here if they were removed from
2038 // mEffectChains list during mixing or effects processing
2039 effectChains.clear();
2040
2041 // FIXME Note that the above .clear() is no longer necessary since effectChains
2042 // is now local to this block, but will keep it for now (at least until merge done).
2043 }
2044
2045 // for DuplicatingThread, standby mode is handled by the outputTracks, otherwise ...
2046 if (mType == MIXER || mType == DIRECT) {
2047 // put output stream into standby mode
2048 if (!mStandby) {
2049 mOutput->stream->common.standby(&mOutput->stream->common);
2050 }
2051 }
2052
2053 releaseWakeLock();
2054
2055 ALOGV("Thread %p type %d exiting", this, mType);
2056 return false;
2057}
2058
2059
2060// ----------------------------------------------------------------------------
2061
2062AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
2063 audio_io_handle_t id, audio_devices_t device, type_t type)
2064 : PlaybackThread(audioFlinger, output, id, device, type),
2065 // mAudioMixer below
2066 // mFastMixer below
2067 mFastMixerFutex(0)
2068 // mOutputSink below
2069 // mPipeSink below
2070 // mNormalSink below
2071{
2072 ALOGV("MixerThread() id=%d device=%#x type=%d", id, device, type);
2073 ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%d, mFormat=%d, mFrameSize=%u, "
2074 "mFrameCount=%d, mNormalFrameCount=%d",
2075 mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
2076 mNormalFrameCount);
2077 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
2078
2079 // FIXME - Current mixer implementation only supports stereo output
2080 if (mChannelCount != FCC_2) {
2081 ALOGE("Invalid audio hardware channel count %d", mChannelCount);
2082 }
2083
2084 // create an NBAIO sink for the HAL output stream, and negotiate
2085 mOutputSink = new AudioStreamOutSink(output->stream);
2086 size_t numCounterOffers = 0;
2087 const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount)};
2088 ssize_t index = mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
2089 ALOG_ASSERT(index == 0);
2090
2091 // initialize fast mixer depending on configuration
2092 bool initFastMixer;
2093 switch (kUseFastMixer) {
2094 case FastMixer_Never:
2095 initFastMixer = false;
2096 break;
2097 case FastMixer_Always:
2098 initFastMixer = true;
2099 break;
2100 case FastMixer_Static:
2101 case FastMixer_Dynamic:
2102 initFastMixer = mFrameCount < mNormalFrameCount;
2103 break;
2104 }
2105 if (initFastMixer) {
2106
2107 // create a MonoPipe to connect our submix to FastMixer
2108 NBAIO_Format format = mOutputSink->format();
2109 // This pipe depth compensates for scheduling latency of the normal mixer thread.
2110 // When it wakes up after a maximum latency, it runs a few cycles quickly before
2111 // finally blocking. Note the pipe implementation rounds up the request to a power of 2.
2112 MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
2113 const NBAIO_Format offers[1] = {format};
2114 size_t numCounterOffers = 0;
2115 ssize_t index = monoPipe->negotiate(offers, 1, NULL, numCounterOffers);
2116 ALOG_ASSERT(index == 0);
2117 monoPipe->setAvgFrames((mScreenState & 1) ?
2118 (monoPipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
2119 mPipeSink = monoPipe;
2120
Glenn Kasten46909e72013-02-26 09:20:22 -08002121#ifdef TEE_SINK
Glenn Kastenda6ef132013-01-10 12:31:01 -08002122 if (mTeeSinkOutputEnabled) {
2123 // create a Pipe to archive a copy of FastMixer's output for dumpsys
2124 Pipe *teeSink = new Pipe(mTeeSinkOutputFrames, format);
2125 numCounterOffers = 0;
2126 index = teeSink->negotiate(offers, 1, NULL, numCounterOffers);
2127 ALOG_ASSERT(index == 0);
2128 mTeeSink = teeSink;
2129 PipeReader *teeSource = new PipeReader(*teeSink);
2130 numCounterOffers = 0;
2131 index = teeSource->negotiate(offers, 1, NULL, numCounterOffers);
2132 ALOG_ASSERT(index == 0);
2133 mTeeSource = teeSource;
2134 }
Glenn Kasten46909e72013-02-26 09:20:22 -08002135#endif
Eric Laurent81784c32012-11-19 14:55:58 -08002136
2137 // create fast mixer and configure it initially with just one fast track for our submix
2138 mFastMixer = new FastMixer();
2139 FastMixerStateQueue *sq = mFastMixer->sq();
2140#ifdef STATE_QUEUE_DUMP
2141 sq->setObserverDump(&mStateQueueObserverDump);
2142 sq->setMutatorDump(&mStateQueueMutatorDump);
2143#endif
2144 FastMixerState *state = sq->begin();
2145 FastTrack *fastTrack = &state->mFastTracks[0];
2146 // wrap the source side of the MonoPipe to make it an AudioBufferProvider
2147 fastTrack->mBufferProvider = new SourceAudioBufferProvider(new MonoPipeReader(monoPipe));
2148 fastTrack->mVolumeProvider = NULL;
2149 fastTrack->mGeneration++;
2150 state->mFastTracksGen++;
2151 state->mTrackMask = 1;
2152 // fast mixer will use the HAL output sink
2153 state->mOutputSink = mOutputSink.get();
2154 state->mOutputSinkGen++;
2155 state->mFrameCount = mFrameCount;
2156 state->mCommand = FastMixerState::COLD_IDLE;
2157 // already done in constructor initialization list
2158 //mFastMixerFutex = 0;
2159 state->mColdFutexAddr = &mFastMixerFutex;
2160 state->mColdGen++;
2161 state->mDumpState = &mFastMixerDumpState;
Glenn Kasten46909e72013-02-26 09:20:22 -08002162#ifdef TEE_SINK
Eric Laurent81784c32012-11-19 14:55:58 -08002163 state->mTeeSink = mTeeSink.get();
Glenn Kasten46909e72013-02-26 09:20:22 -08002164#endif
Glenn Kasten9e58b552013-01-18 15:09:48 -08002165 mFastMixerNBLogWriter = audioFlinger->newWriter_l(kFastMixerLogSize, "FastMixer");
2166 state->mNBLogWriter = mFastMixerNBLogWriter.get();
Eric Laurent81784c32012-11-19 14:55:58 -08002167 sq->end();
2168 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
2169
2170 // start the fast mixer
2171 mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
2172 pid_t tid = mFastMixer->getTid();
2173 int err = requestPriority(getpid_cached, tid, kPriorityFastMixer);
2174 if (err != 0) {
2175 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
2176 kPriorityFastMixer, getpid_cached, tid, err);
2177 }
2178
2179#ifdef AUDIO_WATCHDOG
2180 // create and start the watchdog
2181 mAudioWatchdog = new AudioWatchdog();
2182 mAudioWatchdog->setDump(&mAudioWatchdogDump);
2183 mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
2184 tid = mAudioWatchdog->getTid();
2185 err = requestPriority(getpid_cached, tid, kPriorityFastMixer);
2186 if (err != 0) {
2187 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
2188 kPriorityFastMixer, getpid_cached, tid, err);
2189 }
2190#endif
2191
2192 } else {
2193 mFastMixer = NULL;
2194 }
2195
2196 switch (kUseFastMixer) {
2197 case FastMixer_Never:
2198 case FastMixer_Dynamic:
2199 mNormalSink = mOutputSink;
2200 break;
2201 case FastMixer_Always:
2202 mNormalSink = mPipeSink;
2203 break;
2204 case FastMixer_Static:
2205 mNormalSink = initFastMixer ? mPipeSink : mOutputSink;
2206 break;
2207 }
2208}
2209
2210AudioFlinger::MixerThread::~MixerThread()
2211{
2212 if (mFastMixer != NULL) {
2213 FastMixerStateQueue *sq = mFastMixer->sq();
2214 FastMixerState *state = sq->begin();
2215 if (state->mCommand == FastMixerState::COLD_IDLE) {
2216 int32_t old = android_atomic_inc(&mFastMixerFutex);
2217 if (old == -1) {
2218 __futex_syscall3(&mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
2219 }
2220 }
2221 state->mCommand = FastMixerState::EXIT;
2222 sq->end();
2223 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
2224 mFastMixer->join();
2225 // Though the fast mixer thread has exited, it's state queue is still valid.
2226 // We'll use that extract the final state which contains one remaining fast track
2227 // corresponding to our sub-mix.
2228 state = sq->begin();
2229 ALOG_ASSERT(state->mTrackMask == 1);
2230 FastTrack *fastTrack = &state->mFastTracks[0];
2231 ALOG_ASSERT(fastTrack->mBufferProvider != NULL);
2232 delete fastTrack->mBufferProvider;
2233 sq->end(false /*didModify*/);
2234 delete mFastMixer;
2235#ifdef AUDIO_WATCHDOG
2236 if (mAudioWatchdog != 0) {
2237 mAudioWatchdog->requestExit();
2238 mAudioWatchdog->requestExitAndWait();
2239 mAudioWatchdog.clear();
2240 }
2241#endif
2242 }
Glenn Kasten9e58b552013-01-18 15:09:48 -08002243 mAudioFlinger->unregisterWriter(mFastMixerNBLogWriter);
Eric Laurent81784c32012-11-19 14:55:58 -08002244 delete mAudioMixer;
2245}
2246
2247
2248uint32_t AudioFlinger::MixerThread::correctLatency_l(uint32_t latency) const
2249{
2250 if (mFastMixer != NULL) {
2251 MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
2252 latency += (pipe->getAvgFrames() * 1000) / mSampleRate;
2253 }
2254 return latency;
2255}
2256
2257
2258void AudioFlinger::MixerThread::threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove)
2259{
2260 PlaybackThread::threadLoop_removeTracks(tracksToRemove);
2261}
2262
2263void AudioFlinger::MixerThread::threadLoop_write()
2264{
2265 // FIXME we should only do one push per cycle; confirm this is true
2266 // Start the fast mixer if it's not already running
2267 if (mFastMixer != NULL) {
2268 FastMixerStateQueue *sq = mFastMixer->sq();
2269 FastMixerState *state = sq->begin();
2270 if (state->mCommand != FastMixerState::MIX_WRITE &&
2271 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)) {
2272 if (state->mCommand == FastMixerState::COLD_IDLE) {
2273 int32_t old = android_atomic_inc(&mFastMixerFutex);
2274 if (old == -1) {
2275 __futex_syscall3(&mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
2276 }
2277#ifdef AUDIO_WATCHDOG
2278 if (mAudioWatchdog != 0) {
2279 mAudioWatchdog->resume();
2280 }
2281#endif
2282 }
2283 state->mCommand = FastMixerState::MIX_WRITE;
2284 sq->end();
2285 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
2286 if (kUseFastMixer == FastMixer_Dynamic) {
2287 mNormalSink = mPipeSink;
2288 }
2289 } else {
2290 sq->end(false /*didModify*/);
2291 }
2292 }
2293 PlaybackThread::threadLoop_write();
2294}
2295
2296void AudioFlinger::MixerThread::threadLoop_standby()
2297{
2298 // Idle the fast mixer if it's currently running
2299 if (mFastMixer != NULL) {
2300 FastMixerStateQueue *sq = mFastMixer->sq();
2301 FastMixerState *state = sq->begin();
2302 if (!(state->mCommand & FastMixerState::IDLE)) {
2303 state->mCommand = FastMixerState::COLD_IDLE;
2304 state->mColdFutexAddr = &mFastMixerFutex;
2305 state->mColdGen++;
2306 mFastMixerFutex = 0;
2307 sq->end();
2308 // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
2309 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
2310 if (kUseFastMixer == FastMixer_Dynamic) {
2311 mNormalSink = mOutputSink;
2312 }
2313#ifdef AUDIO_WATCHDOG
2314 if (mAudioWatchdog != 0) {
2315 mAudioWatchdog->pause();
2316 }
2317#endif
2318 } else {
2319 sq->end(false /*didModify*/);
2320 }
2321 }
2322 PlaybackThread::threadLoop_standby();
2323}
2324
2325// shared by MIXER and DIRECT, overridden by DUPLICATING
2326void AudioFlinger::PlaybackThread::threadLoop_standby()
2327{
2328 ALOGV("Audio hardware entering standby, mixer %p, suspend count %d", this, mSuspended);
2329 mOutput->stream->common.standby(&mOutput->stream->common);
2330}
2331
2332void AudioFlinger::MixerThread::threadLoop_mix()
2333{
2334 // obtain the presentation timestamp of the next output buffer
2335 int64_t pts;
2336 status_t status = INVALID_OPERATION;
2337
2338 if (mNormalSink != 0) {
2339 status = mNormalSink->getNextWriteTimestamp(&pts);
2340 } else {
2341 status = mOutputSink->getNextWriteTimestamp(&pts);
2342 }
2343
2344 if (status != NO_ERROR) {
2345 pts = AudioBufferProvider::kInvalidPTS;
2346 }
2347
2348 // mix buffers...
2349 mAudioMixer->process(pts);
2350 // increase sleep time progressively when application underrun condition clears.
2351 // Only increase sleep time if the mixer is ready for two consecutive times to avoid
2352 // that a steady state of alternating ready/not ready conditions keeps the sleep time
2353 // such that we would underrun the audio HAL.
2354 if ((sleepTime == 0) && (sleepTimeShift > 0)) {
2355 sleepTimeShift--;
2356 }
2357 sleepTime = 0;
2358 standbyTime = systemTime() + standbyDelay;
2359 //TODO: delay standby when effects have a tail
2360}
2361
2362void AudioFlinger::MixerThread::threadLoop_sleepTime()
2363{
2364 // If no tracks are ready, sleep once for the duration of an output
2365 // buffer size, then write 0s to the output
2366 if (sleepTime == 0) {
2367 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
2368 sleepTime = activeSleepTime >> sleepTimeShift;
2369 if (sleepTime < kMinThreadSleepTimeUs) {
2370 sleepTime = kMinThreadSleepTimeUs;
2371 }
2372 // reduce sleep time in case of consecutive application underruns to avoid
2373 // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
2374 // duration we would end up writing less data than needed by the audio HAL if
2375 // the condition persists.
2376 if (sleepTimeShift < kMaxThreadSleepTimeShift) {
2377 sleepTimeShift++;
2378 }
2379 } else {
2380 sleepTime = idleSleepTime;
2381 }
2382 } else if (mBytesWritten != 0 || (mMixerStatus == MIXER_TRACKS_ENABLED)) {
2383 memset (mMixBuffer, 0, mixBufferSize);
2384 sleepTime = 0;
2385 ALOGV_IF(mBytesWritten == 0 && (mMixerStatus == MIXER_TRACKS_ENABLED),
2386 "anticipated start");
2387 }
2388 // TODO add standby time extension fct of effect tail
2389}
2390
2391// prepareTracks_l() must be called with ThreadBase::mLock held
2392AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
2393 Vector< sp<Track> > *tracksToRemove)
2394{
2395
2396 mixer_state mixerStatus = MIXER_IDLE;
2397 // find out which tracks need to be processed
2398 size_t count = mActiveTracks.size();
2399 size_t mixedTracks = 0;
2400 size_t tracksWithEffect = 0;
2401 // counts only _active_ fast tracks
2402 size_t fastTracks = 0;
2403 uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset
2404
2405 float masterVolume = mMasterVolume;
2406 bool masterMute = mMasterMute;
2407
2408 if (masterMute) {
2409 masterVolume = 0;
2410 }
2411 // Delegate master volume control to effect in output mix effect chain if needed
2412 sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
2413 if (chain != 0) {
2414 uint32_t v = (uint32_t)(masterVolume * (1 << 24));
2415 chain->setVolume_l(&v, &v);
2416 masterVolume = (float)((v + (1 << 23)) >> 24);
2417 chain.clear();
2418 }
2419
2420 // prepare a new state to push
2421 FastMixerStateQueue *sq = NULL;
2422 FastMixerState *state = NULL;
2423 bool didModify = false;
2424 FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED;
2425 if (mFastMixer != NULL) {
2426 sq = mFastMixer->sq();
2427 state = sq->begin();
2428 }
2429
2430 for (size_t i=0 ; i<count ; i++) {
2431 sp<Track> t = mActiveTracks[i].promote();
2432 if (t == 0) {
2433 continue;
2434 }
2435
2436 // this const just means the local variable doesn't change
2437 Track* const track = t.get();
2438
2439 // process fast tracks
2440 if (track->isFastTrack()) {
2441
2442 // It's theoretically possible (though unlikely) for a fast track to be created
2443 // and then removed within the same normal mix cycle. This is not a problem, as
2444 // the track never becomes active so it's fast mixer slot is never touched.
2445 // The converse, of removing an (active) track and then creating a new track
2446 // at the identical fast mixer slot within the same normal mix cycle,
2447 // is impossible because the slot isn't marked available until the end of each cycle.
2448 int j = track->mFastIndex;
2449 ALOG_ASSERT(0 < j && j < (int)FastMixerState::kMaxFastTracks);
2450 ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j)));
2451 FastTrack *fastTrack = &state->mFastTracks[j];
2452
2453 // Determine whether the track is currently in underrun condition,
2454 // and whether it had a recent underrun.
2455 FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j];
2456 FastTrackUnderruns underruns = ftDump->mUnderruns;
2457 uint32_t recentFull = (underruns.mBitFields.mFull -
2458 track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
2459 uint32_t recentPartial = (underruns.mBitFields.mPartial -
2460 track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
2461 uint32_t recentEmpty = (underruns.mBitFields.mEmpty -
2462 track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
2463 uint32_t recentUnderruns = recentPartial + recentEmpty;
2464 track->mObservedUnderruns = underruns;
2465 // don't count underruns that occur while stopping or pausing
2466 // or stopped which can occur when flush() is called while active
2467 if (!(track->isStopping() || track->isPausing() || track->isStopped())) {
2468 track->mUnderrunCount += recentUnderruns;
2469 }
2470
2471 // This is similar to the state machine for normal tracks,
2472 // with a few modifications for fast tracks.
2473 bool isActive = true;
2474 switch (track->mState) {
2475 case TrackBase::STOPPING_1:
2476 // track stays active in STOPPING_1 state until first underrun
2477 if (recentUnderruns > 0) {
2478 track->mState = TrackBase::STOPPING_2;
2479 }
2480 break;
2481 case TrackBase::PAUSING:
2482 // ramp down is not yet implemented
2483 track->setPaused();
2484 break;
2485 case TrackBase::RESUMING:
2486 // ramp up is not yet implemented
2487 track->mState = TrackBase::ACTIVE;
2488 break;
2489 case TrackBase::ACTIVE:
2490 if (recentFull > 0 || recentPartial > 0) {
2491 // track has provided at least some frames recently: reset retry count
2492 track->mRetryCount = kMaxTrackRetries;
2493 }
2494 if (recentUnderruns == 0) {
2495 // no recent underruns: stay active
2496 break;
2497 }
2498 // there has recently been an underrun of some kind
2499 if (track->sharedBuffer() == 0) {
2500 // were any of the recent underruns "empty" (no frames available)?
2501 if (recentEmpty == 0) {
2502 // no, then ignore the partial underruns as they are allowed indefinitely
2503 break;
2504 }
2505 // there has recently been an "empty" underrun: decrement the retry counter
2506 if (--(track->mRetryCount) > 0) {
2507 break;
2508 }
2509 // indicate to client process that the track was disabled because of underrun;
2510 // it will then automatically call start() when data is available
2511 android_atomic_or(CBLK_DISABLED, &track->mCblk->flags);
2512 // remove from active list, but state remains ACTIVE [confusing but true]
2513 isActive = false;
2514 break;
2515 }
2516 // fall through
2517 case TrackBase::STOPPING_2:
2518 case TrackBase::PAUSED:
2519 case TrackBase::TERMINATED:
2520 case TrackBase::STOPPED:
2521 case TrackBase::FLUSHED: // flush() while active
2522 // Check for presentation complete if track is inactive
2523 // We have consumed all the buffers of this track.
2524 // This would be incomplete if we auto-paused on underrun
2525 {
2526 size_t audioHALFrames =
2527 (mOutput->stream->get_latency(mOutput->stream)*mSampleRate) / 1000;
2528 size_t framesWritten = mBytesWritten / mFrameSize;
2529 if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) {
2530 // track stays in active list until presentation is complete
2531 break;
2532 }
2533 }
2534 if (track->isStopping_2()) {
2535 track->mState = TrackBase::STOPPED;
2536 }
2537 if (track->isStopped()) {
2538 // Can't reset directly, as fast mixer is still polling this track
2539 // track->reset();
2540 // So instead mark this track as needing to be reset after push with ack
2541 resetMask |= 1 << i;
2542 }
2543 isActive = false;
2544 break;
2545 case TrackBase::IDLE:
2546 default:
2547 LOG_FATAL("unexpected track state %d", track->mState);
2548 }
2549
2550 if (isActive) {
2551 // was it previously inactive?
2552 if (!(state->mTrackMask & (1 << j))) {
2553 ExtendedAudioBufferProvider *eabp = track;
2554 VolumeProvider *vp = track;
2555 fastTrack->mBufferProvider = eabp;
2556 fastTrack->mVolumeProvider = vp;
2557 fastTrack->mSampleRate = track->mSampleRate;
2558 fastTrack->mChannelMask = track->mChannelMask;
2559 fastTrack->mGeneration++;
2560 state->mTrackMask |= 1 << j;
2561 didModify = true;
2562 // no acknowledgement required for newly active tracks
2563 }
2564 // cache the combined master volume and stream type volume for fast mixer; this
2565 // lacks any synchronization or barrier so VolumeProvider may read a stale value
Glenn Kastene4756fe2012-11-29 13:38:14 -08002566 track->mCachedVolume = masterVolume * mStreamTypes[track->streamType()].volume;
Eric Laurent81784c32012-11-19 14:55:58 -08002567 ++fastTracks;
2568 } else {
2569 // was it previously active?
2570 if (state->mTrackMask & (1 << j)) {
2571 fastTrack->mBufferProvider = NULL;
2572 fastTrack->mGeneration++;
2573 state->mTrackMask &= ~(1 << j);
2574 didModify = true;
2575 // If any fast tracks were removed, we must wait for acknowledgement
2576 // because we're about to decrement the last sp<> on those tracks.
2577 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
2578 } else {
2579 LOG_FATAL("fast track %d should have been active", j);
2580 }
2581 tracksToRemove->add(track);
2582 // Avoids a misleading display in dumpsys
2583 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
2584 }
2585 continue;
2586 }
2587
2588 { // local variable scope to avoid goto warning
2589
2590 audio_track_cblk_t* cblk = track->cblk();
2591
2592 // The first time a track is added we wait
2593 // for all its buffers to be filled before processing it
2594 int name = track->name();
2595 // make sure that we have enough frames to mix one full buffer.
2596 // enforce this condition only once to enable draining the buffer in case the client
2597 // app does not call stop() and relies on underrun to stop:
2598 // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
2599 // during last round
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002600 size_t desiredFrames;
2601 if (t->sampleRate() == mSampleRate) {
2602 desiredFrames = mNormalFrameCount;
2603 } else {
2604 // +1 for rounding and +1 for additional sample needed for interpolation
2605 desiredFrames = (mNormalFrameCount * t->sampleRate()) / mSampleRate + 1 + 1;
2606 // add frames already consumed but not yet released by the resampler
2607 // because cblk->framesReady() will include these frames
2608 desiredFrames += mAudioMixer->getUnreleasedFrames(track->name());
2609 // the minimum track buffer size is normally twice the number of frames necessary
2610 // to fill one buffer and the resampler should not leave more than one buffer worth
2611 // of unreleased frames after each pass, but just in case...
2612 ALOG_ASSERT(desiredFrames <= cblk->frameCount_);
2613 }
Eric Laurent81784c32012-11-19 14:55:58 -08002614 uint32_t minFrames = 1;
2615 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
2616 (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002617 minFrames = desiredFrames;
Eric Laurent81784c32012-11-19 14:55:58 -08002618 }
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002619 // It's not safe to call framesReady() for a static buffer track, so assume it's ready
2620 size_t framesReady;
2621 if (track->sharedBuffer() == 0) {
2622 framesReady = track->framesReady();
2623 } else if (track->isStopped()) {
2624 framesReady = 0;
2625 } else {
2626 framesReady = 1;
2627 }
2628 if ((framesReady >= minFrames) && track->isReady() &&
Eric Laurent81784c32012-11-19 14:55:58 -08002629 !track->isPaused() && !track->isTerminated())
2630 {
2631 ALOGVV("track %d u=%08x, s=%08x [OK] on thread %p", name, cblk->user, cblk->server,
2632 this);
2633
2634 mixedTracks++;
2635
2636 // track->mainBuffer() != mMixBuffer means there is an effect chain
2637 // connected to the track
2638 chain.clear();
2639 if (track->mainBuffer() != mMixBuffer) {
2640 chain = getEffectChain_l(track->sessionId());
2641 // Delegate volume control to effect in track effect chain if needed
2642 if (chain != 0) {
2643 tracksWithEffect++;
2644 } else {
2645 ALOGW("prepareTracks_l(): track %d attached to effect but no chain found on "
2646 "session %d",
2647 name, track->sessionId());
2648 }
2649 }
2650
2651
2652 int param = AudioMixer::VOLUME;
2653 if (track->mFillingUpStatus == Track::FS_FILLED) {
2654 // no ramp for the first volume setting
2655 track->mFillingUpStatus = Track::FS_ACTIVE;
2656 if (track->mState == TrackBase::RESUMING) {
2657 track->mState = TrackBase::ACTIVE;
2658 param = AudioMixer::RAMP_VOLUME;
2659 }
2660 mAudioMixer->setParameter(name, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
2661 } else if (cblk->server != 0) {
2662 // If the track is stopped before the first frame was mixed,
2663 // do not apply ramp
2664 param = AudioMixer::RAMP_VOLUME;
2665 }
2666
2667 // compute volume for this track
2668 uint32_t vl, vr, va;
Glenn Kastene4756fe2012-11-29 13:38:14 -08002669 if (track->isPausing() || mStreamTypes[track->streamType()].mute) {
Eric Laurent81784c32012-11-19 14:55:58 -08002670 vl = vr = va = 0;
2671 if (track->isPausing()) {
2672 track->setPaused();
2673 }
2674 } else {
2675
2676 // read original volumes with volume control
2677 float typeVolume = mStreamTypes[track->streamType()].volume;
2678 float v = masterVolume * typeVolume;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002679 AudioTrackServerProxy *proxy = track->mAudioTrackServerProxy;
Glenn Kastene3aa6592012-12-04 12:22:46 -08002680 uint32_t vlr = proxy->getVolumeLR();
Eric Laurent81784c32012-11-19 14:55:58 -08002681 vl = vlr & 0xFFFF;
2682 vr = vlr >> 16;
2683 // track volumes come from shared memory, so can't be trusted and must be clamped
2684 if (vl > MAX_GAIN_INT) {
2685 ALOGV("Track left volume out of range: %04X", vl);
2686 vl = MAX_GAIN_INT;
2687 }
2688 if (vr > MAX_GAIN_INT) {
2689 ALOGV("Track right volume out of range: %04X", vr);
2690 vr = MAX_GAIN_INT;
2691 }
2692 // now apply the master volume and stream type volume
2693 vl = (uint32_t)(v * vl) << 12;
2694 vr = (uint32_t)(v * vr) << 12;
2695 // assuming master volume and stream type volume each go up to 1.0,
2696 // vl and vr are now in 8.24 format
2697
Glenn Kastene3aa6592012-12-04 12:22:46 -08002698 uint16_t sendLevel = proxy->getSendLevel_U4_12();
Eric Laurent81784c32012-11-19 14:55:58 -08002699 // send level comes from shared memory and so may be corrupt
2700 if (sendLevel > MAX_GAIN_INT) {
2701 ALOGV("Track send level out of range: %04X", sendLevel);
2702 sendLevel = MAX_GAIN_INT;
2703 }
2704 va = (uint32_t)(v * sendLevel);
2705 }
2706 // Delegate volume control to effect in track effect chain if needed
2707 if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
2708 // Do not ramp volume if volume is controlled by effect
2709 param = AudioMixer::VOLUME;
2710 track->mHasVolumeController = true;
2711 } else {
2712 // force no volume ramp when volume controller was just disabled or removed
2713 // from effect chain to avoid volume spike
2714 if (track->mHasVolumeController) {
2715 param = AudioMixer::VOLUME;
2716 }
2717 track->mHasVolumeController = false;
2718 }
2719
2720 // Convert volumes from 8.24 to 4.12 format
2721 // This additional clamping is needed in case chain->setVolume_l() overshot
2722 vl = (vl + (1 << 11)) >> 12;
2723 if (vl > MAX_GAIN_INT) {
2724 vl = MAX_GAIN_INT;
2725 }
2726 vr = (vr + (1 << 11)) >> 12;
2727 if (vr > MAX_GAIN_INT) {
2728 vr = MAX_GAIN_INT;
2729 }
2730
2731 if (va > MAX_GAIN_INT) {
2732 va = MAX_GAIN_INT; // va is uint32_t, so no need to check for -
2733 }
2734
2735 // XXX: these things DON'T need to be done each time
2736 mAudioMixer->setBufferProvider(name, track);
2737 mAudioMixer->enable(name);
2738
2739 mAudioMixer->setParameter(name, param, AudioMixer::VOLUME0, (void *)vl);
2740 mAudioMixer->setParameter(name, param, AudioMixer::VOLUME1, (void *)vr);
2741 mAudioMixer->setParameter(name, param, AudioMixer::AUXLEVEL, (void *)va);
2742 mAudioMixer->setParameter(
2743 name,
2744 AudioMixer::TRACK,
2745 AudioMixer::FORMAT, (void *)track->format());
2746 mAudioMixer->setParameter(
2747 name,
2748 AudioMixer::TRACK,
2749 AudioMixer::CHANNEL_MASK, (void *)track->channelMask());
Glenn Kastene3aa6592012-12-04 12:22:46 -08002750 // limit track sample rate to 2 x output sample rate, which changes at re-configuration
2751 uint32_t maxSampleRate = mSampleRate * 2;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002752 uint32_t reqSampleRate = track->mAudioTrackServerProxy->getSampleRate();
Glenn Kastene3aa6592012-12-04 12:22:46 -08002753 if (reqSampleRate == 0) {
2754 reqSampleRate = mSampleRate;
2755 } else if (reqSampleRate > maxSampleRate) {
2756 reqSampleRate = maxSampleRate;
2757 }
Eric Laurent81784c32012-11-19 14:55:58 -08002758 mAudioMixer->setParameter(
2759 name,
2760 AudioMixer::RESAMPLE,
2761 AudioMixer::SAMPLE_RATE,
Glenn Kastene3aa6592012-12-04 12:22:46 -08002762 (void *)reqSampleRate);
Eric Laurent81784c32012-11-19 14:55:58 -08002763 mAudioMixer->setParameter(
2764 name,
2765 AudioMixer::TRACK,
2766 AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
2767 mAudioMixer->setParameter(
2768 name,
2769 AudioMixer::TRACK,
2770 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
2771
2772 // reset retry count
2773 track->mRetryCount = kMaxTrackRetries;
2774
2775 // If one track is ready, set the mixer ready if:
2776 // - the mixer was not ready during previous round OR
2777 // - no other track is not ready
2778 if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY ||
2779 mixerStatus != MIXER_TRACKS_ENABLED) {
2780 mixerStatus = MIXER_TRACKS_READY;
2781 }
2782 } else {
Glenn Kasten9f80dd22012-12-18 15:57:32 -08002783 // only implemented for normal tracks, not fast tracks
2784 if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) {
2785 // we missed desiredFrames whatever the actual number of frames missing was
2786 cblk->u.mStreaming.mUnderrunFrames += desiredFrames;
2787 // FIXME also wake futex so that underrun is noticed more quickly
2788 (void) android_atomic_or(CBLK_UNDERRUN, &cblk->flags);
2789 }
Eric Laurent81784c32012-11-19 14:55:58 -08002790 // clear effect chain input buffer if an active track underruns to avoid sending
2791 // previous audio buffer again to effects
2792 chain = getEffectChain_l(track->sessionId());
2793 if (chain != 0) {
2794 chain->clearInputBuffer();
2795 }
2796
2797 ALOGVV("track %d u=%08x, s=%08x [NOT READY] on thread %p", name, cblk->user,
2798 cblk->server, this);
2799 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
2800 track->isStopped() || track->isPaused()) {
2801 // We have consumed all the buffers of this track.
2802 // Remove it from the list of active tracks.
2803 // TODO: use actual buffer filling status instead of latency when available from
2804 // audio HAL
2805 size_t audioHALFrames = (latency_l() * mSampleRate) / 1000;
2806 size_t framesWritten = mBytesWritten / mFrameSize;
2807 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
2808 if (track->isStopped()) {
2809 track->reset();
2810 }
2811 tracksToRemove->add(track);
2812 }
2813 } else {
2814 track->mUnderrunCount++;
2815 // No buffers for this track. Give it a few chances to
2816 // fill a buffer, then remove it from active list.
2817 if (--(track->mRetryCount) <= 0) {
Glenn Kastenc9b2e202013-02-26 11:32:32 -08002818 ALOGI("BUFFER TIMEOUT: remove(%d) from active list on thread %p", name, this);
Eric Laurent81784c32012-11-19 14:55:58 -08002819 tracksToRemove->add(track);
2820 // indicate to client process that the track was disabled because of underrun;
2821 // it will then automatically call start() when data is available
2822 android_atomic_or(CBLK_DISABLED, &cblk->flags);
2823 // If one track is not ready, mark the mixer also not ready if:
2824 // - the mixer was ready during previous round OR
2825 // - no other track is ready
2826 } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY ||
2827 mixerStatus != MIXER_TRACKS_READY) {
2828 mixerStatus = MIXER_TRACKS_ENABLED;
2829 }
2830 }
2831 mAudioMixer->disable(name);
2832 }
2833
2834 } // local variable scope to avoid goto warning
2835track_is_ready: ;
2836
2837 }
2838
2839 // Push the new FastMixer state if necessary
2840 bool pauseAudioWatchdog = false;
2841 if (didModify) {
2842 state->mFastTracksGen++;
2843 // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
2844 if (kUseFastMixer == FastMixer_Dynamic &&
2845 state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) {
2846 state->mCommand = FastMixerState::COLD_IDLE;
2847 state->mColdFutexAddr = &mFastMixerFutex;
2848 state->mColdGen++;
2849 mFastMixerFutex = 0;
2850 if (kUseFastMixer == FastMixer_Dynamic) {
2851 mNormalSink = mOutputSink;
2852 }
2853 // If we go into cold idle, need to wait for acknowledgement
2854 // so that fast mixer stops doing I/O.
2855 block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
2856 pauseAudioWatchdog = true;
2857 }
Eric Laurent81784c32012-11-19 14:55:58 -08002858 }
2859 if (sq != NULL) {
2860 sq->end(didModify);
2861 sq->push(block);
2862 }
2863#ifdef AUDIO_WATCHDOG
2864 if (pauseAudioWatchdog && mAudioWatchdog != 0) {
2865 mAudioWatchdog->pause();
2866 }
2867#endif
2868
2869 // Now perform the deferred reset on fast tracks that have stopped
2870 while (resetMask != 0) {
2871 size_t i = __builtin_ctz(resetMask);
2872 ALOG_ASSERT(i < count);
2873 resetMask &= ~(1 << i);
2874 sp<Track> t = mActiveTracks[i].promote();
2875 if (t == 0) {
2876 continue;
2877 }
2878 Track* track = t.get();
2879 ALOG_ASSERT(track->isFastTrack() && track->isStopped());
2880 track->reset();
2881 }
2882
2883 // remove all the tracks that need to be...
2884 count = tracksToRemove->size();
2885 if (CC_UNLIKELY(count)) {
2886 for (size_t i=0 ; i<count ; i++) {
2887 const sp<Track>& track = tracksToRemove->itemAt(i);
2888 mActiveTracks.remove(track);
2889 if (track->mainBuffer() != mMixBuffer) {
2890 chain = getEffectChain_l(track->sessionId());
2891 if (chain != 0) {
2892 ALOGV("stopping track on chain %p for session Id: %d", chain.get(),
2893 track->sessionId());
2894 chain->decActiveTrackCnt();
2895 }
2896 }
2897 if (track->isTerminated()) {
2898 removeTrack_l(track);
2899 }
2900 }
2901 }
2902
2903 // mix buffer must be cleared if all tracks are connected to an
2904 // effect chain as in this case the mixer will not write to
2905 // mix buffer and track effects will accumulate into it
2906 if ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
2907 (mixedTracks == 0 && fastTracks > 0)) {
2908 // FIXME as a performance optimization, should remember previous zero status
2909 memset(mMixBuffer, 0, mNormalFrameCount * mChannelCount * sizeof(int16_t));
2910 }
2911
2912 // if any fast tracks, then status is ready
2913 mMixerStatusIgnoringFastTracks = mixerStatus;
2914 if (fastTracks > 0) {
2915 mixerStatus = MIXER_TRACKS_READY;
2916 }
2917 return mixerStatus;
2918}
2919
2920// getTrackName_l() must be called with ThreadBase::mLock held
2921int AudioFlinger::MixerThread::getTrackName_l(audio_channel_mask_t channelMask, int sessionId)
2922{
2923 return mAudioMixer->getTrackName(channelMask, sessionId);
2924}
2925
2926// deleteTrackName_l() must be called with ThreadBase::mLock held
2927void AudioFlinger::MixerThread::deleteTrackName_l(int name)
2928{
2929 ALOGV("remove track (%d) and delete from mixer", name);
2930 mAudioMixer->deleteTrackName(name);
2931}
2932
2933// checkForNewParameters_l() must be called with ThreadBase::mLock held
2934bool AudioFlinger::MixerThread::checkForNewParameters_l()
2935{
2936 // if !&IDLE, holds the FastMixer state to restore after new parameters processed
2937 FastMixerState::Command previousCommand = FastMixerState::HOT_IDLE;
2938 bool reconfig = false;
2939
2940 while (!mNewParameters.isEmpty()) {
2941
2942 if (mFastMixer != NULL) {
2943 FastMixerStateQueue *sq = mFastMixer->sq();
2944 FastMixerState *state = sq->begin();
2945 if (!(state->mCommand & FastMixerState::IDLE)) {
2946 previousCommand = state->mCommand;
2947 state->mCommand = FastMixerState::HOT_IDLE;
2948 sq->end();
2949 sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
2950 } else {
2951 sq->end(false /*didModify*/);
2952 }
2953 }
2954
2955 status_t status = NO_ERROR;
2956 String8 keyValuePair = mNewParameters[0];
2957 AudioParameter param = AudioParameter(keyValuePair);
2958 int value;
2959
2960 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
2961 reconfig = true;
2962 }
2963 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
2964 if ((audio_format_t) value != AUDIO_FORMAT_PCM_16_BIT) {
2965 status = BAD_VALUE;
2966 } else {
2967 reconfig = true;
2968 }
2969 }
2970 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
2971 if (value != AUDIO_CHANNEL_OUT_STEREO) {
2972 status = BAD_VALUE;
2973 } else {
2974 reconfig = true;
2975 }
2976 }
2977 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
2978 // do not accept frame count changes if tracks are open as the track buffer
2979 // size depends on frame count and correct behavior would not be guaranteed
2980 // if frame count is changed after track creation
2981 if (!mTracks.isEmpty()) {
2982 status = INVALID_OPERATION;
2983 } else {
2984 reconfig = true;
2985 }
2986 }
2987 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
2988#ifdef ADD_BATTERY_DATA
2989 // when changing the audio output device, call addBatteryData to notify
2990 // the change
2991 if (mOutDevice != value) {
2992 uint32_t params = 0;
2993 // check whether speaker is on
2994 if (value & AUDIO_DEVICE_OUT_SPEAKER) {
2995 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
2996 }
2997
2998 audio_devices_t deviceWithoutSpeaker
2999 = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER;
3000 // check if any other device (except speaker) is on
3001 if (value & deviceWithoutSpeaker ) {
3002 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
3003 }
3004
3005 if (params != 0) {
3006 addBatteryData(params);
3007 }
3008 }
3009#endif
3010
3011 // forward device change to effects that have requested to be
3012 // aware of attached audio device.
Eric Laurent7e1139c2013-06-06 18:29:01 -07003013 if (value != AUDIO_DEVICE_NONE) {
3014 mOutDevice = value;
3015 for (size_t i = 0; i < mEffectChains.size(); i++) {
3016 mEffectChains[i]->setDevice_l(mOutDevice);
3017 }
Eric Laurent81784c32012-11-19 14:55:58 -08003018 }
3019 }
3020
3021 if (status == NO_ERROR) {
3022 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
3023 keyValuePair.string());
3024 if (!mStandby && status == INVALID_OPERATION) {
3025 mOutput->stream->common.standby(&mOutput->stream->common);
3026 mStandby = true;
3027 mBytesWritten = 0;
3028 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
3029 keyValuePair.string());
3030 }
3031 if (status == NO_ERROR && reconfig) {
3032 delete mAudioMixer;
3033 // for safety in case readOutputParameters() accesses mAudioMixer (it doesn't)
3034 mAudioMixer = NULL;
3035 readOutputParameters();
3036 mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
3037 for (size_t i = 0; i < mTracks.size() ; i++) {
3038 int name = getTrackName_l(mTracks[i]->mChannelMask, mTracks[i]->mSessionId);
3039 if (name < 0) {
3040 break;
3041 }
3042 mTracks[i]->mName = name;
Eric Laurent81784c32012-11-19 14:55:58 -08003043 }
3044 sendIoConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
3045 }
3046 }
3047
3048 mNewParameters.removeAt(0);
3049
3050 mParamStatus = status;
3051 mParamCond.signal();
3052 // wait for condition with time out in case the thread calling ThreadBase::setParameters()
3053 // already timed out waiting for the status and will never signal the condition.
3054 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeoutNs);
3055 }
3056
3057 if (!(previousCommand & FastMixerState::IDLE)) {
3058 ALOG_ASSERT(mFastMixer != NULL);
3059 FastMixerStateQueue *sq = mFastMixer->sq();
3060 FastMixerState *state = sq->begin();
3061 ALOG_ASSERT(state->mCommand == FastMixerState::HOT_IDLE);
3062 state->mCommand = previousCommand;
3063 sq->end();
3064 sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
3065 }
3066
3067 return reconfig;
3068}
3069
3070
3071void AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16>& args)
3072{
3073 const size_t SIZE = 256;
3074 char buffer[SIZE];
3075 String8 result;
3076
3077 PlaybackThread::dumpInternals(fd, args);
3078
3079 snprintf(buffer, SIZE, "AudioMixer tracks: %08x\n", mAudioMixer->trackNames());
3080 result.append(buffer);
3081 write(fd, result.string(), result.size());
3082
3083 // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
3084 FastMixerDumpState copy = mFastMixerDumpState;
3085 copy.dump(fd);
3086
3087#ifdef STATE_QUEUE_DUMP
3088 // Similar for state queue
3089 StateQueueObserverDump observerCopy = mStateQueueObserverDump;
3090 observerCopy.dump(fd);
3091 StateQueueMutatorDump mutatorCopy = mStateQueueMutatorDump;
3092 mutatorCopy.dump(fd);
3093#endif
3094
Glenn Kasten46909e72013-02-26 09:20:22 -08003095#ifdef TEE_SINK
Eric Laurent81784c32012-11-19 14:55:58 -08003096 // Write the tee output to a .wav file
3097 dumpTee(fd, mTeeSource, mId);
Glenn Kasten46909e72013-02-26 09:20:22 -08003098#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003099
3100#ifdef AUDIO_WATCHDOG
3101 if (mAudioWatchdog != 0) {
3102 // Make a non-atomic copy of audio watchdog dump so it won't change underneath us
3103 AudioWatchdogDump wdCopy = mAudioWatchdogDump;
3104 wdCopy.dump(fd);
3105 }
3106#endif
3107}
3108
3109uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
3110{
3111 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
3112}
3113
3114uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
3115{
3116 return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
3117}
3118
3119void AudioFlinger::MixerThread::cacheParameters_l()
3120{
3121 PlaybackThread::cacheParameters_l();
3122
3123 // FIXME: Relaxed timing because of a certain device that can't meet latency
3124 // Should be reduced to 2x after the vendor fixes the driver issue
3125 // increase threshold again due to low power audio mode. The way this warning
3126 // threshold is calculated and its usefulness should be reconsidered anyway.
3127 maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
3128}
3129
3130// ----------------------------------------------------------------------------
3131
3132AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
3133 AudioStreamOut* output, audio_io_handle_t id, audio_devices_t device)
3134 : PlaybackThread(audioFlinger, output, id, device, DIRECT)
3135 // mLeftVolFloat, mRightVolFloat
3136{
3137}
3138
3139AudioFlinger::DirectOutputThread::~DirectOutputThread()
3140{
3141}
3142
3143AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
3144 Vector< sp<Track> > *tracksToRemove
3145)
3146{
Eric Laurentd595b7c2013-04-03 17:27:56 -07003147 size_t count = mActiveTracks.size();
Eric Laurent81784c32012-11-19 14:55:58 -08003148 mixer_state mixerStatus = MIXER_IDLE;
3149
3150 // find out which tracks need to be processed
Eric Laurentd595b7c2013-04-03 17:27:56 -07003151 for (size_t i = 0; i < count; i++) {
3152 sp<Track> t = mActiveTracks[i].promote();
Eric Laurent81784c32012-11-19 14:55:58 -08003153 // The track died recently
3154 if (t == 0) {
Eric Laurentd595b7c2013-04-03 17:27:56 -07003155 continue;
Eric Laurent81784c32012-11-19 14:55:58 -08003156 }
3157
3158 Track* const track = t.get();
3159 audio_track_cblk_t* cblk = track->cblk();
3160
3161 // The first time a track is added we wait
3162 // for all its buffers to be filled before processing it
3163 uint32_t minFrames;
3164 if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing()) {
3165 minFrames = mNormalFrameCount;
3166 } else {
3167 minFrames = 1;
3168 }
3169 if ((track->framesReady() >= minFrames) && track->isReady() &&
3170 !track->isPaused() && !track->isTerminated())
3171 {
3172 ALOGVV("track %d u=%08x, s=%08x [OK]", track->name(), cblk->user, cblk->server);
3173
3174 if (track->mFillingUpStatus == Track::FS_FILLED) {
3175 track->mFillingUpStatus = Track::FS_ACTIVE;
3176 mLeftVolFloat = mRightVolFloat = 0;
3177 if (track->mState == TrackBase::RESUMING) {
3178 track->mState = TrackBase::ACTIVE;
3179 }
3180 }
3181
3182 // compute volume for this track
3183 float left, right;
Glenn Kastene4756fe2012-11-29 13:38:14 -08003184 if (mMasterMute || track->isPausing() || mStreamTypes[track->streamType()].mute) {
Eric Laurent81784c32012-11-19 14:55:58 -08003185 left = right = 0;
3186 if (track->isPausing()) {
3187 track->setPaused();
3188 }
3189 } else {
3190 float typeVolume = mStreamTypes[track->streamType()].volume;
3191 float v = mMasterVolume * typeVolume;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003192 uint32_t vlr = track->mAudioTrackServerProxy->getVolumeLR();
Eric Laurent81784c32012-11-19 14:55:58 -08003193 float v_clamped = v * (vlr & 0xFFFF);
3194 if (v_clamped > MAX_GAIN) {
3195 v_clamped = MAX_GAIN;
3196 }
3197 left = v_clamped/MAX_GAIN;
3198 v_clamped = v * (vlr >> 16);
3199 if (v_clamped > MAX_GAIN) {
3200 v_clamped = MAX_GAIN;
3201 }
3202 right = v_clamped/MAX_GAIN;
3203 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07003204 // Only consider last track started for volume and mixer state control.
3205 // This is the last entry in mActiveTracks unless a track underruns.
3206 // As we only care about the transition phase between two tracks on a
3207 // direct output, it is not a problem to ignore the underrun case.
3208 if (i == (count - 1)) {
3209 if (left != mLeftVolFloat || right != mRightVolFloat) {
3210 mLeftVolFloat = left;
3211 mRightVolFloat = right;
Eric Laurent81784c32012-11-19 14:55:58 -08003212
Eric Laurentd595b7c2013-04-03 17:27:56 -07003213 // Convert volumes from float to 8.24
3214 uint32_t vl = (uint32_t)(left * (1 << 24));
3215 uint32_t vr = (uint32_t)(right * (1 << 24));
Eric Laurent81784c32012-11-19 14:55:58 -08003216
Eric Laurentd595b7c2013-04-03 17:27:56 -07003217 // Delegate volume control to effect in track effect chain if needed
3218 // only one effect chain can be present on DirectOutputThread, so if
3219 // there is one, the track is connected to it
3220 if (!mEffectChains.isEmpty()) {
3221 // Do not ramp volume if volume is controlled by effect
3222 mEffectChains[0]->setVolume_l(&vl, &vr);
3223 left = (float)vl / (1 << 24);
3224 right = (float)vr / (1 << 24);
3225 }
3226 mOutput->stream->set_volume(mOutput->stream, left, right);
Eric Laurent81784c32012-11-19 14:55:58 -08003227 }
Eric Laurent81784c32012-11-19 14:55:58 -08003228
Eric Laurentd595b7c2013-04-03 17:27:56 -07003229 // reset retry count
3230 track->mRetryCount = kMaxTrackRetriesDirect;
3231 mActiveTrack = t;
3232 mixerStatus = MIXER_TRACKS_READY;
3233 }
Eric Laurent81784c32012-11-19 14:55:58 -08003234 } else {
Eric Laurentd595b7c2013-04-03 17:27:56 -07003235 // clear effect chain input buffer if the last active track started underruns
3236 // to avoid sending previous audio buffer again to effects
3237 if (!mEffectChains.isEmpty() && (i == (count -1))) {
Eric Laurent81784c32012-11-19 14:55:58 -08003238 mEffectChains[0]->clearInputBuffer();
3239 }
3240
3241 ALOGVV("track %d u=%08x, s=%08x [NOT READY]", track->name(), cblk->user, cblk->server);
3242 if ((track->sharedBuffer() != 0) || track->isTerminated() ||
3243 track->isStopped() || track->isPaused()) {
3244 // We have consumed all the buffers of this track.
3245 // Remove it from the list of active tracks.
3246 // TODO: implement behavior for compressed audio
3247 size_t audioHALFrames = (latency_l() * mSampleRate) / 1000;
3248 size_t framesWritten = mBytesWritten / mFrameSize;
3249 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
3250 if (track->isStopped()) {
3251 track->reset();
3252 }
Eric Laurentd595b7c2013-04-03 17:27:56 -07003253 tracksToRemove->add(track);
Eric Laurent81784c32012-11-19 14:55:58 -08003254 }
3255 } else {
3256 // No buffers for this track. Give it a few chances to
3257 // fill a buffer, then remove it from active list.
Eric Laurentd595b7c2013-04-03 17:27:56 -07003258 // Only consider last track started for mixer state control
Eric Laurent81784c32012-11-19 14:55:58 -08003259 if (--(track->mRetryCount) <= 0) {
3260 ALOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name());
Eric Laurentd595b7c2013-04-03 17:27:56 -07003261 tracksToRemove->add(track);
3262 } else if (i == (count -1)){
Eric Laurent81784c32012-11-19 14:55:58 -08003263 mixerStatus = MIXER_TRACKS_ENABLED;
3264 }
3265 }
3266 }
3267 }
3268
Eric Laurent81784c32012-11-19 14:55:58 -08003269 // remove all the tracks that need to be...
Eric Laurentd595b7c2013-04-03 17:27:56 -07003270 count = tracksToRemove->size();
3271 if (CC_UNLIKELY(count)) {
3272 for (size_t i = 0 ; i < count ; i++) {
3273 const sp<Track>& track = tracksToRemove->itemAt(i);
3274 mActiveTracks.remove(track);
3275 if (!mEffectChains.isEmpty()) {
3276 ALOGV("stopping track on chain %p for session Id: %d", mEffectChains[0].get(),
3277 track->sessionId());
3278 mEffectChains[0]->decActiveTrackCnt();
3279 }
3280 if (track->isTerminated()) {
3281 removeTrack_l(track);
3282 }
Eric Laurent81784c32012-11-19 14:55:58 -08003283 }
3284 }
3285
3286 return mixerStatus;
3287}
3288
3289void AudioFlinger::DirectOutputThread::threadLoop_mix()
3290{
3291 AudioBufferProvider::Buffer buffer;
3292 size_t frameCount = mFrameCount;
3293 int8_t *curBuf = (int8_t *)mMixBuffer;
3294 // output audio to hardware
3295 while (frameCount) {
3296 buffer.frameCount = frameCount;
3297 mActiveTrack->getNextBuffer(&buffer);
3298 if (CC_UNLIKELY(buffer.raw == NULL)) {
3299 memset(curBuf, 0, frameCount * mFrameSize);
3300 break;
3301 }
3302 memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
3303 frameCount -= buffer.frameCount;
3304 curBuf += buffer.frameCount * mFrameSize;
3305 mActiveTrack->releaseBuffer(&buffer);
3306 }
3307 sleepTime = 0;
3308 standbyTime = systemTime() + standbyDelay;
3309 mActiveTrack.clear();
3310
3311}
3312
3313void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
3314{
3315 if (sleepTime == 0) {
3316 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
3317 sleepTime = activeSleepTime;
3318 } else {
3319 sleepTime = idleSleepTime;
3320 }
3321 } else if (mBytesWritten != 0 && audio_is_linear_pcm(mFormat)) {
3322 memset(mMixBuffer, 0, mFrameCount * mFrameSize);
3323 sleepTime = 0;
3324 }
3325}
3326
3327// getTrackName_l() must be called with ThreadBase::mLock held
3328int AudioFlinger::DirectOutputThread::getTrackName_l(audio_channel_mask_t channelMask,
3329 int sessionId)
3330{
3331 return 0;
3332}
3333
3334// deleteTrackName_l() must be called with ThreadBase::mLock held
3335void AudioFlinger::DirectOutputThread::deleteTrackName_l(int name)
3336{
3337}
3338
3339// checkForNewParameters_l() must be called with ThreadBase::mLock held
3340bool AudioFlinger::DirectOutputThread::checkForNewParameters_l()
3341{
3342 bool reconfig = false;
3343
3344 while (!mNewParameters.isEmpty()) {
3345 status_t status = NO_ERROR;
3346 String8 keyValuePair = mNewParameters[0];
3347 AudioParameter param = AudioParameter(keyValuePair);
3348 int value;
3349
3350 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
3351 // do not accept frame count changes if tracks are open as the track buffer
3352 // size depends on frame count and correct behavior would not be garantied
3353 // if frame count is changed after track creation
3354 if (!mTracks.isEmpty()) {
3355 status = INVALID_OPERATION;
3356 } else {
3357 reconfig = true;
3358 }
3359 }
3360 if (status == NO_ERROR) {
3361 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
3362 keyValuePair.string());
3363 if (!mStandby && status == INVALID_OPERATION) {
3364 mOutput->stream->common.standby(&mOutput->stream->common);
3365 mStandby = true;
3366 mBytesWritten = 0;
3367 status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
3368 keyValuePair.string());
3369 }
3370 if (status == NO_ERROR && reconfig) {
3371 readOutputParameters();
3372 sendIoConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
3373 }
3374 }
3375
3376 mNewParameters.removeAt(0);
3377
3378 mParamStatus = status;
3379 mParamCond.signal();
3380 // wait for condition with time out in case the thread calling ThreadBase::setParameters()
3381 // already timed out waiting for the status and will never signal the condition.
3382 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeoutNs);
3383 }
3384 return reconfig;
3385}
3386
3387uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
3388{
3389 uint32_t time;
3390 if (audio_is_linear_pcm(mFormat)) {
3391 time = PlaybackThread::activeSleepTimeUs();
3392 } else {
3393 time = 10000;
3394 }
3395 return time;
3396}
3397
3398uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
3399{
3400 uint32_t time;
3401 if (audio_is_linear_pcm(mFormat)) {
3402 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
3403 } else {
3404 time = 10000;
3405 }
3406 return time;
3407}
3408
3409uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
3410{
3411 uint32_t time;
3412 if (audio_is_linear_pcm(mFormat)) {
3413 time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
3414 } else {
3415 time = 10000;
3416 }
3417 return time;
3418}
3419
3420void AudioFlinger::DirectOutputThread::cacheParameters_l()
3421{
3422 PlaybackThread::cacheParameters_l();
3423
3424 // use shorter standby delay as on normal output to release
3425 // hardware resources as soon as possible
3426 standbyDelay = microseconds(activeSleepTime*2);
3427}
3428
3429// ----------------------------------------------------------------------------
3430
3431AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
3432 AudioFlinger::MixerThread* mainThread, audio_io_handle_t id)
3433 : MixerThread(audioFlinger, mainThread->getOutput(), id, mainThread->outDevice(),
3434 DUPLICATING),
3435 mWaitTimeMs(UINT_MAX)
3436{
3437 addOutputTrack(mainThread);
3438}
3439
3440AudioFlinger::DuplicatingThread::~DuplicatingThread()
3441{
3442 for (size_t i = 0; i < mOutputTracks.size(); i++) {
3443 mOutputTracks[i]->destroy();
3444 }
3445}
3446
3447void AudioFlinger::DuplicatingThread::threadLoop_mix()
3448{
3449 // mix buffers...
3450 if (outputsReady(outputTracks)) {
3451 mAudioMixer->process(AudioBufferProvider::kInvalidPTS);
3452 } else {
3453 memset(mMixBuffer, 0, mixBufferSize);
3454 }
3455 sleepTime = 0;
3456 writeFrames = mNormalFrameCount;
3457 standbyTime = systemTime() + standbyDelay;
3458}
3459
3460void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
3461{
3462 if (sleepTime == 0) {
3463 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
3464 sleepTime = activeSleepTime;
3465 } else {
3466 sleepTime = idleSleepTime;
3467 }
3468 } else if (mBytesWritten != 0) {
3469 if (mMixerStatus == MIXER_TRACKS_ENABLED) {
3470 writeFrames = mNormalFrameCount;
3471 memset(mMixBuffer, 0, mixBufferSize);
3472 } else {
3473 // flush remaining overflow buffers in output tracks
3474 writeFrames = 0;
3475 }
3476 sleepTime = 0;
3477 }
3478}
3479
3480void AudioFlinger::DuplicatingThread::threadLoop_write()
3481{
3482 for (size_t i = 0; i < outputTracks.size(); i++) {
3483 outputTracks[i]->write(mMixBuffer, writeFrames);
3484 }
3485 mBytesWritten += mixBufferSize;
3486}
3487
3488void AudioFlinger::DuplicatingThread::threadLoop_standby()
3489{
3490 // DuplicatingThread implements standby by stopping all tracks
3491 for (size_t i = 0; i < outputTracks.size(); i++) {
3492 outputTracks[i]->stop();
3493 }
3494}
3495
3496void AudioFlinger::DuplicatingThread::saveOutputTracks()
3497{
3498 outputTracks = mOutputTracks;
3499}
3500
3501void AudioFlinger::DuplicatingThread::clearOutputTracks()
3502{
3503 outputTracks.clear();
3504}
3505
3506void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
3507{
3508 Mutex::Autolock _l(mLock);
3509 // FIXME explain this formula
3510 size_t frameCount = (3 * mNormalFrameCount * mSampleRate) / thread->sampleRate();
3511 OutputTrack *outputTrack = new OutputTrack(thread,
3512 this,
3513 mSampleRate,
3514 mFormat,
3515 mChannelMask,
3516 frameCount);
3517 if (outputTrack->cblk() != NULL) {
3518 thread->setStreamVolume(AUDIO_STREAM_CNT, 1.0f);
3519 mOutputTracks.add(outputTrack);
3520 ALOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread);
3521 updateWaitTime_l();
3522 }
3523}
3524
3525void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
3526{
3527 Mutex::Autolock _l(mLock);
3528 for (size_t i = 0; i < mOutputTracks.size(); i++) {
3529 if (mOutputTracks[i]->thread() == thread) {
3530 mOutputTracks[i]->destroy();
3531 mOutputTracks.removeAt(i);
3532 updateWaitTime_l();
3533 return;
3534 }
3535 }
3536 ALOGV("removeOutputTrack(): unkonwn thread: %p", thread);
3537}
3538
3539// caller must hold mLock
3540void AudioFlinger::DuplicatingThread::updateWaitTime_l()
3541{
3542 mWaitTimeMs = UINT_MAX;
3543 for (size_t i = 0; i < mOutputTracks.size(); i++) {
3544 sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
3545 if (strong != 0) {
3546 uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
3547 if (waitTimeMs < mWaitTimeMs) {
3548 mWaitTimeMs = waitTimeMs;
3549 }
3550 }
3551 }
3552}
3553
3554
3555bool AudioFlinger::DuplicatingThread::outputsReady(
3556 const SortedVector< sp<OutputTrack> > &outputTracks)
3557{
3558 for (size_t i = 0; i < outputTracks.size(); i++) {
3559 sp<ThreadBase> thread = outputTracks[i]->thread().promote();
3560 if (thread == 0) {
3561 ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
3562 outputTracks[i].get());
3563 return false;
3564 }
3565 PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
3566 // see note at standby() declaration
3567 if (playbackThread->standby() && !playbackThread->isSuspended()) {
3568 ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
3569 thread.get());
3570 return false;
3571 }
3572 }
3573 return true;
3574}
3575
3576uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
3577{
3578 return (mWaitTimeMs * 1000) / 2;
3579}
3580
3581void AudioFlinger::DuplicatingThread::cacheParameters_l()
3582{
3583 // updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
3584 updateWaitTime_l();
3585
3586 MixerThread::cacheParameters_l();
3587}
3588
3589// ----------------------------------------------------------------------------
3590// Record
3591// ----------------------------------------------------------------------------
3592
3593AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
3594 AudioStreamIn *input,
3595 uint32_t sampleRate,
3596 audio_channel_mask_t channelMask,
3597 audio_io_handle_t id,
Eric Laurentd3922f72013-02-01 17:57:04 -08003598 audio_devices_t outDevice,
Glenn Kasten46909e72013-02-26 09:20:22 -08003599 audio_devices_t inDevice
3600#ifdef TEE_SINK
3601 , const sp<NBAIO_Sink>& teeSink
3602#endif
3603 ) :
Eric Laurentd3922f72013-02-01 17:57:04 -08003604 ThreadBase(audioFlinger, id, outDevice, inDevice, RECORD),
Eric Laurent81784c32012-11-19 14:55:58 -08003605 mInput(input), mResampler(NULL), mRsmpOutBuffer(NULL), mRsmpInBuffer(NULL),
3606 // mRsmpInIndex and mInputBytes set by readInputParameters()
3607 mReqChannelCount(popcount(channelMask)),
Glenn Kasten46909e72013-02-26 09:20:22 -08003608 mReqSampleRate(sampleRate)
Eric Laurent81784c32012-11-19 14:55:58 -08003609 // mBytesRead is only meaningful while active, and so is cleared in start()
3610 // (but might be better to also clear here for dump?)
Glenn Kasten46909e72013-02-26 09:20:22 -08003611#ifdef TEE_SINK
3612 , mTeeSink(teeSink)
3613#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003614{
3615 snprintf(mName, kNameLength, "AudioIn_%X", id);
3616
3617 readInputParameters();
3618
3619}
3620
3621
3622AudioFlinger::RecordThread::~RecordThread()
3623{
3624 delete[] mRsmpInBuffer;
3625 delete mResampler;
3626 delete[] mRsmpOutBuffer;
3627}
3628
3629void AudioFlinger::RecordThread::onFirstRef()
3630{
3631 run(mName, PRIORITY_URGENT_AUDIO);
3632}
3633
3634status_t AudioFlinger::RecordThread::readyToRun()
3635{
3636 status_t status = initCheck();
3637 ALOGW_IF(status != NO_ERROR,"RecordThread %p could not initialize", this);
3638 return status;
3639}
3640
3641bool AudioFlinger::RecordThread::threadLoop()
3642{
3643 AudioBufferProvider::Buffer buffer;
3644 sp<RecordTrack> activeTrack;
3645 Vector< sp<EffectChain> > effectChains;
3646
3647 nsecs_t lastWarning = 0;
3648
3649 inputStandBy();
3650 acquireWakeLock();
3651
3652 // used to verify we've read at least once before evaluating how many bytes were read
3653 bool readOnce = false;
3654
3655 // start recording
3656 while (!exitPending()) {
3657
3658 processConfigEvents();
3659
3660 { // scope for mLock
3661 Mutex::Autolock _l(mLock);
3662 checkForNewParameters_l();
3663 if (mActiveTrack == 0 && mConfigEvents.isEmpty()) {
3664 standby();
3665
3666 if (exitPending()) {
3667 break;
3668 }
3669
3670 releaseWakeLock_l();
3671 ALOGV("RecordThread: loop stopping");
3672 // go to sleep
3673 mWaitWorkCV.wait(mLock);
3674 ALOGV("RecordThread: loop starting");
3675 acquireWakeLock_l();
3676 continue;
3677 }
3678 if (mActiveTrack != 0) {
3679 if (mActiveTrack->mState == TrackBase::PAUSING) {
3680 standby();
3681 mActiveTrack.clear();
3682 mStartStopCond.broadcast();
3683 } else if (mActiveTrack->mState == TrackBase::RESUMING) {
3684 if (mReqChannelCount != mActiveTrack->channelCount()) {
3685 mActiveTrack.clear();
3686 mStartStopCond.broadcast();
3687 } else if (readOnce) {
3688 // record start succeeds only if first read from audio input
3689 // succeeds
3690 if (mBytesRead >= 0) {
3691 mActiveTrack->mState = TrackBase::ACTIVE;
3692 } else {
3693 mActiveTrack.clear();
3694 }
3695 mStartStopCond.broadcast();
3696 }
3697 mStandby = false;
3698 } else if (mActiveTrack->mState == TrackBase::TERMINATED) {
3699 removeTrack_l(mActiveTrack);
3700 mActiveTrack.clear();
3701 }
3702 }
3703 lockEffectChains_l(effectChains);
3704 }
3705
3706 if (mActiveTrack != 0) {
3707 if (mActiveTrack->mState != TrackBase::ACTIVE &&
3708 mActiveTrack->mState != TrackBase::RESUMING) {
3709 unlockEffectChains(effectChains);
3710 usleep(kRecordThreadSleepUs);
3711 continue;
3712 }
3713 for (size_t i = 0; i < effectChains.size(); i ++) {
3714 effectChains[i]->process_l();
3715 }
3716
3717 buffer.frameCount = mFrameCount;
Glenn Kasten9f80dd22012-12-18 15:57:32 -08003718 status_t status = mActiveTrack->getNextBuffer(&buffer);
3719 if (CC_LIKELY(status == NO_ERROR)) {
Eric Laurent81784c32012-11-19 14:55:58 -08003720 readOnce = true;
3721 size_t framesOut = buffer.frameCount;
3722 if (mResampler == NULL) {
3723 // no resampling
3724 while (framesOut) {
3725 size_t framesIn = mFrameCount - mRsmpInIndex;
3726 if (framesIn) {
3727 int8_t *src = (int8_t *)mRsmpInBuffer + mRsmpInIndex * mFrameSize;
3728 int8_t *dst = buffer.i8 + (buffer.frameCount - framesOut) *
3729 mActiveTrack->mFrameSize;
3730 if (framesIn > framesOut)
3731 framesIn = framesOut;
3732 mRsmpInIndex += framesIn;
3733 framesOut -= framesIn;
3734 if (mChannelCount == mReqChannelCount ||
3735 mFormat != AUDIO_FORMAT_PCM_16_BIT) {
3736 memcpy(dst, src, framesIn * mFrameSize);
3737 } else {
3738 if (mChannelCount == 1) {
3739 upmix_to_stereo_i16_from_mono_i16((int16_t *)dst,
3740 (int16_t *)src, framesIn);
3741 } else {
3742 downmix_to_mono_i16_from_stereo_i16((int16_t *)dst,
3743 (int16_t *)src, framesIn);
3744 }
3745 }
3746 }
3747 if (framesOut && mFrameCount == mRsmpInIndex) {
3748 void *readInto;
3749 if (framesOut == mFrameCount &&
3750 (mChannelCount == mReqChannelCount ||
3751 mFormat != AUDIO_FORMAT_PCM_16_BIT)) {
3752 readInto = buffer.raw;
3753 framesOut = 0;
3754 } else {
3755 readInto = mRsmpInBuffer;
3756 mRsmpInIndex = 0;
3757 }
Glenn Kastenc9b2e202013-02-26 11:32:32 -08003758 mBytesRead = mInput->stream->read(mInput->stream, readInto,
3759 mInputBytes);
Eric Laurent81784c32012-11-19 14:55:58 -08003760 if (mBytesRead <= 0) {
3761 if ((mBytesRead < 0) && (mActiveTrack->mState == TrackBase::ACTIVE))
3762 {
3763 ALOGE("Error reading audio input");
3764 // Force input into standby so that it tries to
3765 // recover at next read attempt
3766 inputStandBy();
3767 usleep(kRecordThreadSleepUs);
3768 }
3769 mRsmpInIndex = mFrameCount;
3770 framesOut = 0;
3771 buffer.frameCount = 0;
Glenn Kasten46909e72013-02-26 09:20:22 -08003772 }
3773#ifdef TEE_SINK
3774 else if (mTeeSink != 0) {
Eric Laurent81784c32012-11-19 14:55:58 -08003775 (void) mTeeSink->write(readInto,
3776 mBytesRead >> Format_frameBitShift(mTeeSink->format()));
3777 }
Glenn Kasten46909e72013-02-26 09:20:22 -08003778#endif
Eric Laurent81784c32012-11-19 14:55:58 -08003779 }
3780 }
3781 } else {
3782 // resampling
3783
3784 memset(mRsmpOutBuffer, 0, framesOut * 2 * sizeof(int32_t));
3785 // alter output frame count as if we were expecting stereo samples
3786 if (mChannelCount == 1 && mReqChannelCount == 1) {
3787 framesOut >>= 1;
3788 }
3789 mResampler->resample(mRsmpOutBuffer, framesOut,
3790 this /* AudioBufferProvider* */);
3791 // ditherAndClamp() works as long as all buffers returned by
3792 // mActiveTrack->getNextBuffer() are 32 bit aligned which should be always true.
3793 if (mChannelCount == 2 && mReqChannelCount == 1) {
3794 ditherAndClamp(mRsmpOutBuffer, mRsmpOutBuffer, framesOut);
3795 // the resampler always outputs stereo samples:
3796 // do post stereo to mono conversion
3797 downmix_to_mono_i16_from_stereo_i16(buffer.i16, (int16_t *)mRsmpOutBuffer,
3798 framesOut);
3799 } else {
3800 ditherAndClamp((int32_t *)buffer.raw, mRsmpOutBuffer, framesOut);
3801 }
3802
3803 }
3804 if (mFramestoDrop == 0) {
3805 mActiveTrack->releaseBuffer(&buffer);
3806 } else {
3807 if (mFramestoDrop > 0) {
3808 mFramestoDrop -= buffer.frameCount;
3809 if (mFramestoDrop <= 0) {
3810 clearSyncStartEvent();
3811 }
3812 } else {
3813 mFramestoDrop += buffer.frameCount;
3814 if (mFramestoDrop >= 0 || mSyncStartEvent == 0 ||
3815 mSyncStartEvent->isCancelled()) {
3816 ALOGW("Synced record %s, session %d, trigger session %d",
3817 (mFramestoDrop >= 0) ? "timed out" : "cancelled",
3818 mActiveTrack->sessionId(),
3819 (mSyncStartEvent != 0) ? mSyncStartEvent->triggerSession() : 0);
3820 clearSyncStartEvent();
3821 }
3822 }
3823 }
3824 mActiveTrack->clearOverflow();
3825 }
3826 // client isn't retrieving buffers fast enough
3827 else {
3828 if (!mActiveTrack->setOverflow()) {
3829 nsecs_t now = systemTime();
3830 if ((now - lastWarning) > kWarningThrottleNs) {
3831 ALOGW("RecordThread: buffer overflow");
3832 lastWarning = now;
3833 }
3834 }
3835 // Release the processor for a while before asking for a new buffer.
3836 // This will give the application more chance to read from the buffer and
3837 // clear the overflow.
3838 usleep(kRecordThreadSleepUs);
3839 }
3840 }
3841 // enable changes in effect chain
3842 unlockEffectChains(effectChains);
3843 effectChains.clear();
3844 }
3845
3846 standby();
3847
3848 {
3849 Mutex::Autolock _l(mLock);
3850 mActiveTrack.clear();
3851 mStartStopCond.broadcast();
3852 }
3853
3854 releaseWakeLock();
3855
3856 ALOGV("RecordThread %p exiting", this);
3857 return false;
3858}
3859
3860void AudioFlinger::RecordThread::standby()
3861{
3862 if (!mStandby) {
3863 inputStandBy();
3864 mStandby = true;
3865 }
3866}
3867
3868void AudioFlinger::RecordThread::inputStandBy()
3869{
3870 mInput->stream->common.standby(&mInput->stream->common);
3871}
3872
3873sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
3874 const sp<AudioFlinger::Client>& client,
3875 uint32_t sampleRate,
3876 audio_format_t format,
3877 audio_channel_mask_t channelMask,
3878 size_t frameCount,
3879 int sessionId,
3880 IAudioFlinger::track_flags_t flags,
3881 pid_t tid,
3882 status_t *status)
3883{
3884 sp<RecordTrack> track;
3885 status_t lStatus;
3886
3887 lStatus = initCheck();
3888 if (lStatus != NO_ERROR) {
3889 ALOGE("Audio driver not initialized.");
3890 goto Exit;
3891 }
3892
3893 // FIXME use flags and tid similar to createTrack_l()
3894
3895 { // scope for mLock
3896 Mutex::Autolock _l(mLock);
3897
3898 track = new RecordTrack(this, client, sampleRate,
3899 format, channelMask, frameCount, sessionId);
3900
3901 if (track->getCblk() == 0) {
3902 lStatus = NO_MEMORY;
3903 goto Exit;
3904 }
3905 mTracks.add(track);
3906
3907 // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
3908 bool suspend = audio_is_bluetooth_sco_device(mInDevice) &&
3909 mAudioFlinger->btNrecIsOff();
3910 setEffectSuspended_l(FX_IID_AEC, suspend, sessionId);
3911 setEffectSuspended_l(FX_IID_NS, suspend, sessionId);
3912 }
3913 lStatus = NO_ERROR;
3914
3915Exit:
3916 if (status) {
3917 *status = lStatus;
3918 }
3919 return track;
3920}
3921
3922status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
3923 AudioSystem::sync_event_t event,
3924 int triggerSession)
3925{
3926 ALOGV("RecordThread::start event %d, triggerSession %d", event, triggerSession);
3927 sp<ThreadBase> strongMe = this;
3928 status_t status = NO_ERROR;
3929
3930 if (event == AudioSystem::SYNC_EVENT_NONE) {
3931 clearSyncStartEvent();
3932 } else if (event != AudioSystem::SYNC_EVENT_SAME) {
3933 mSyncStartEvent = mAudioFlinger->createSyncEvent(event,
3934 triggerSession,
3935 recordTrack->sessionId(),
3936 syncStartEventCallback,
3937 this);
3938 // Sync event can be cancelled by the trigger session if the track is not in a
3939 // compatible state in which case we start record immediately
3940 if (mSyncStartEvent->isCancelled()) {
3941 clearSyncStartEvent();
3942 } else {
3943 // do not wait for the event for more than AudioSystem::kSyncRecordStartTimeOutMs
3944 mFramestoDrop = - ((AudioSystem::kSyncRecordStartTimeOutMs * mReqSampleRate) / 1000);
3945 }
3946 }
3947
3948 {
3949 AutoMutex lock(mLock);
3950 if (mActiveTrack != 0) {
3951 if (recordTrack != mActiveTrack.get()) {
3952 status = -EBUSY;
3953 } else if (mActiveTrack->mState == TrackBase::PAUSING) {
3954 mActiveTrack->mState = TrackBase::ACTIVE;
3955 }
3956 return status;
3957 }
3958
3959 recordTrack->mState = TrackBase::IDLE;
3960 mActiveTrack = recordTrack;
3961 mLock.unlock();
3962 status_t status = AudioSystem::startInput(mId);
3963 mLock.lock();
3964 if (status != NO_ERROR) {
3965 mActiveTrack.clear();
3966 clearSyncStartEvent();
3967 return status;
3968 }
3969 mRsmpInIndex = mFrameCount;
3970 mBytesRead = 0;
3971 if (mResampler != NULL) {
3972 mResampler->reset();
3973 }
3974 mActiveTrack->mState = TrackBase::RESUMING;
3975 // signal thread to start
3976 ALOGV("Signal record thread");
3977 mWaitWorkCV.broadcast();
3978 // do not wait for mStartStopCond if exiting
3979 if (exitPending()) {
3980 mActiveTrack.clear();
3981 status = INVALID_OPERATION;
3982 goto startError;
3983 }
3984 mStartStopCond.wait(mLock);
3985 if (mActiveTrack == 0) {
3986 ALOGV("Record failed to start");
3987 status = BAD_VALUE;
3988 goto startError;
3989 }
3990 ALOGV("Record started OK");
3991 return status;
3992 }
Glenn Kasten7c027242012-12-26 14:43:16 -08003993
Eric Laurent81784c32012-11-19 14:55:58 -08003994startError:
3995 AudioSystem::stopInput(mId);
3996 clearSyncStartEvent();
3997 return status;
3998}
3999
4000void AudioFlinger::RecordThread::clearSyncStartEvent()
4001{
4002 if (mSyncStartEvent != 0) {
4003 mSyncStartEvent->cancel();
4004 }
4005 mSyncStartEvent.clear();
4006 mFramestoDrop = 0;
4007}
4008
4009void AudioFlinger::RecordThread::syncStartEventCallback(const wp<SyncEvent>& event)
4010{
4011 sp<SyncEvent> strongEvent = event.promote();
4012
4013 if (strongEvent != 0) {
4014 RecordThread *me = (RecordThread *)strongEvent->cookie();
4015 me->handleSyncStartEvent(strongEvent);
4016 }
4017}
4018
4019void AudioFlinger::RecordThread::handleSyncStartEvent(const sp<SyncEvent>& event)
4020{
4021 if (event == mSyncStartEvent) {
4022 // TODO: use actual buffer filling status instead of 2 buffers when info is available
4023 // from audio HAL
4024 mFramestoDrop = mFrameCount * 2;
4025 }
4026}
4027
4028bool AudioFlinger::RecordThread::stop_l(RecordThread::RecordTrack* recordTrack) {
4029 ALOGV("RecordThread::stop");
4030 if (recordTrack != mActiveTrack.get() || recordTrack->mState == TrackBase::PAUSING) {
4031 return false;
4032 }
4033 recordTrack->mState = TrackBase::PAUSING;
4034 // do not wait for mStartStopCond if exiting
4035 if (exitPending()) {
4036 return true;
4037 }
4038 mStartStopCond.wait(mLock);
4039 // if we have been restarted, recordTrack == mActiveTrack.get() here
4040 if (exitPending() || recordTrack != mActiveTrack.get()) {
4041 ALOGV("Record stopped OK");
4042 return true;
4043 }
4044 return false;
4045}
4046
4047bool AudioFlinger::RecordThread::isValidSyncEvent(const sp<SyncEvent>& event) const
4048{
4049 return false;
4050}
4051
4052status_t AudioFlinger::RecordThread::setSyncEvent(const sp<SyncEvent>& event)
4053{
4054#if 0 // This branch is currently dead code, but is preserved in case it will be needed in future
4055 if (!isValidSyncEvent(event)) {
4056 return BAD_VALUE;
4057 }
4058
4059 int eventSession = event->triggerSession();
4060 status_t ret = NAME_NOT_FOUND;
4061
4062 Mutex::Autolock _l(mLock);
4063
4064 for (size_t i = 0; i < mTracks.size(); i++) {
4065 sp<RecordTrack> track = mTracks[i];
4066 if (eventSession == track->sessionId()) {
4067 (void) track->setSyncEvent(event);
4068 ret = NO_ERROR;
4069 }
4070 }
4071 return ret;
4072#else
4073 return BAD_VALUE;
4074#endif
4075}
4076
4077// destroyTrack_l() must be called with ThreadBase::mLock held
4078void AudioFlinger::RecordThread::destroyTrack_l(const sp<RecordTrack>& track)
4079{
4080 track->mState = TrackBase::TERMINATED;
4081 // active tracks are removed by threadLoop()
4082 if (mActiveTrack != track) {
4083 removeTrack_l(track);
4084 }
4085}
4086
4087void AudioFlinger::RecordThread::removeTrack_l(const sp<RecordTrack>& track)
4088{
4089 mTracks.remove(track);
4090 // need anything related to effects here?
4091}
4092
4093void AudioFlinger::RecordThread::dump(int fd, const Vector<String16>& args)
4094{
4095 dumpInternals(fd, args);
4096 dumpTracks(fd, args);
4097 dumpEffectChains(fd, args);
4098}
4099
4100void AudioFlinger::RecordThread::dumpInternals(int fd, const Vector<String16>& args)
4101{
4102 const size_t SIZE = 256;
4103 char buffer[SIZE];
4104 String8 result;
4105
4106 snprintf(buffer, SIZE, "\nInput thread %p internals\n", this);
4107 result.append(buffer);
4108
4109 if (mActiveTrack != 0) {
4110 snprintf(buffer, SIZE, "In index: %d\n", mRsmpInIndex);
4111 result.append(buffer);
4112 snprintf(buffer, SIZE, "In size: %d\n", mInputBytes);
4113 result.append(buffer);
4114 snprintf(buffer, SIZE, "Resampling: %d\n", (mResampler != NULL));
4115 result.append(buffer);
4116 snprintf(buffer, SIZE, "Out channel count: %u\n", mReqChannelCount);
4117 result.append(buffer);
4118 snprintf(buffer, SIZE, "Out sample rate: %u\n", mReqSampleRate);
4119 result.append(buffer);
4120 } else {
4121 result.append("No active record client\n");
4122 }
4123
4124 write(fd, result.string(), result.size());
4125
4126 dumpBase(fd, args);
4127}
4128
4129void AudioFlinger::RecordThread::dumpTracks(int fd, const Vector<String16>& args)
4130{
4131 const size_t SIZE = 256;
4132 char buffer[SIZE];
4133 String8 result;
4134
4135 snprintf(buffer, SIZE, "Input thread %p tracks\n", this);
4136 result.append(buffer);
4137 RecordTrack::appendDumpHeader(result);
4138 for (size_t i = 0; i < mTracks.size(); ++i) {
4139 sp<RecordTrack> track = mTracks[i];
4140 if (track != 0) {
4141 track->dump(buffer, SIZE);
4142 result.append(buffer);
4143 }
4144 }
4145
4146 if (mActiveTrack != 0) {
4147 snprintf(buffer, SIZE, "\nInput thread %p active tracks\n", this);
4148 result.append(buffer);
4149 RecordTrack::appendDumpHeader(result);
4150 mActiveTrack->dump(buffer, SIZE);
4151 result.append(buffer);
4152
4153 }
4154 write(fd, result.string(), result.size());
4155}
4156
4157// AudioBufferProvider interface
4158status_t AudioFlinger::RecordThread::getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts)
4159{
4160 size_t framesReq = buffer->frameCount;
4161 size_t framesReady = mFrameCount - mRsmpInIndex;
4162 int channelCount;
4163
4164 if (framesReady == 0) {
4165 mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes);
4166 if (mBytesRead <= 0) {
4167 if ((mBytesRead < 0) && (mActiveTrack->mState == TrackBase::ACTIVE)) {
4168 ALOGE("RecordThread::getNextBuffer() Error reading audio input");
4169 // Force input into standby so that it tries to
4170 // recover at next read attempt
4171 inputStandBy();
4172 usleep(kRecordThreadSleepUs);
4173 }
4174 buffer->raw = NULL;
4175 buffer->frameCount = 0;
4176 return NOT_ENOUGH_DATA;
4177 }
4178 mRsmpInIndex = 0;
4179 framesReady = mFrameCount;
4180 }
4181
4182 if (framesReq > framesReady) {
4183 framesReq = framesReady;
4184 }
4185
4186 if (mChannelCount == 1 && mReqChannelCount == 2) {
4187 channelCount = 1;
4188 } else {
4189 channelCount = 2;
4190 }
4191 buffer->raw = mRsmpInBuffer + mRsmpInIndex * channelCount;
4192 buffer->frameCount = framesReq;
4193 return NO_ERROR;
4194}
4195
4196// AudioBufferProvider interface
4197void AudioFlinger::RecordThread::releaseBuffer(AudioBufferProvider::Buffer* buffer)
4198{
4199 mRsmpInIndex += buffer->frameCount;
4200 buffer->frameCount = 0;
4201}
4202
4203bool AudioFlinger::RecordThread::checkForNewParameters_l()
4204{
4205 bool reconfig = false;
4206
4207 while (!mNewParameters.isEmpty()) {
4208 status_t status = NO_ERROR;
4209 String8 keyValuePair = mNewParameters[0];
4210 AudioParameter param = AudioParameter(keyValuePair);
4211 int value;
4212 audio_format_t reqFormat = mFormat;
4213 uint32_t reqSamplingRate = mReqSampleRate;
4214 uint32_t reqChannelCount = mReqChannelCount;
4215
4216 if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
4217 reqSamplingRate = value;
4218 reconfig = true;
4219 }
4220 if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
4221 reqFormat = (audio_format_t) value;
4222 reconfig = true;
4223 }
4224 if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
4225 reqChannelCount = popcount(value);
4226 reconfig = true;
4227 }
4228 if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
4229 // do not accept frame count changes if tracks are open as the track buffer
4230 // size depends on frame count and correct behavior would not be guaranteed
4231 // if frame count is changed after track creation
4232 if (mActiveTrack != 0) {
4233 status = INVALID_OPERATION;
4234 } else {
4235 reconfig = true;
4236 }
4237 }
4238 if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
4239 // forward device change to effects that have requested to be
4240 // aware of attached audio device.
4241 for (size_t i = 0; i < mEffectChains.size(); i++) {
4242 mEffectChains[i]->setDevice_l(value);
4243 }
4244
4245 // store input device and output device but do not forward output device to audio HAL.
4246 // Note that status is ignored by the caller for output device
4247 // (see AudioFlinger::setParameters()
4248 if (audio_is_output_devices(value)) {
4249 mOutDevice = value;
4250 status = BAD_VALUE;
4251 } else {
4252 mInDevice = value;
4253 // disable AEC and NS if the device is a BT SCO headset supporting those
4254 // pre processings
4255 if (mTracks.size() > 0) {
4256 bool suspend = audio_is_bluetooth_sco_device(mInDevice) &&
4257 mAudioFlinger->btNrecIsOff();
4258 for (size_t i = 0; i < mTracks.size(); i++) {
4259 sp<RecordTrack> track = mTracks[i];
4260 setEffectSuspended_l(FX_IID_AEC, suspend, track->sessionId());
4261 setEffectSuspended_l(FX_IID_NS, suspend, track->sessionId());
4262 }
4263 }
4264 }
4265 }
4266 if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR &&
4267 mAudioSource != (audio_source_t)value) {
4268 // forward device change to effects that have requested to be
4269 // aware of attached audio device.
4270 for (size_t i = 0; i < mEffectChains.size(); i++) {
4271 mEffectChains[i]->setAudioSource_l((audio_source_t)value);
4272 }
4273 mAudioSource = (audio_source_t)value;
4274 }
4275 if (status == NO_ERROR) {
4276 status = mInput->stream->common.set_parameters(&mInput->stream->common,
4277 keyValuePair.string());
4278 if (status == INVALID_OPERATION) {
4279 inputStandBy();
4280 status = mInput->stream->common.set_parameters(&mInput->stream->common,
4281 keyValuePair.string());
4282 }
4283 if (reconfig) {
4284 if (status == BAD_VALUE &&
4285 reqFormat == mInput->stream->common.get_format(&mInput->stream->common) &&
4286 reqFormat == AUDIO_FORMAT_PCM_16_BIT &&
Glenn Kastenc4974312012-12-14 07:13:28 -08004287 (mInput->stream->common.get_sample_rate(&mInput->stream->common)
Eric Laurent81784c32012-11-19 14:55:58 -08004288 <= (2 * reqSamplingRate)) &&
4289 popcount(mInput->stream->common.get_channels(&mInput->stream->common))
4290 <= FCC_2 &&
4291 (reqChannelCount <= FCC_2)) {
4292 status = NO_ERROR;
4293 }
4294 if (status == NO_ERROR) {
4295 readInputParameters();
4296 sendIoConfigEvent_l(AudioSystem::INPUT_CONFIG_CHANGED);
4297 }
4298 }
4299 }
4300
4301 mNewParameters.removeAt(0);
4302
4303 mParamStatus = status;
4304 mParamCond.signal();
4305 // wait for condition with time out in case the thread calling ThreadBase::setParameters()
4306 // already timed out waiting for the status and will never signal the condition.
4307 mWaitWorkCV.waitRelative(mLock, kSetParametersTimeoutNs);
4308 }
4309 return reconfig;
4310}
4311
4312String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
4313{
4314 char *s;
4315 String8 out_s8 = String8();
4316
4317 Mutex::Autolock _l(mLock);
4318 if (initCheck() != NO_ERROR) {
4319 return out_s8;
4320 }
4321
4322 s = mInput->stream->common.get_parameters(&mInput->stream->common, keys.string());
4323 out_s8 = String8(s);
4324 free(s);
4325 return out_s8;
4326}
4327
4328void AudioFlinger::RecordThread::audioConfigChanged_l(int event, int param) {
4329 AudioSystem::OutputDescriptor desc;
4330 void *param2 = NULL;
4331
4332 switch (event) {
4333 case AudioSystem::INPUT_OPENED:
4334 case AudioSystem::INPUT_CONFIG_CHANGED:
4335 desc.channels = mChannelMask;
4336 desc.samplingRate = mSampleRate;
4337 desc.format = mFormat;
4338 desc.frameCount = mFrameCount;
4339 desc.latency = 0;
4340 param2 = &desc;
4341 break;
4342
4343 case AudioSystem::INPUT_CLOSED:
4344 default:
4345 break;
4346 }
4347 mAudioFlinger->audioConfigChanged_l(event, mId, param2);
4348}
4349
4350void AudioFlinger::RecordThread::readInputParameters()
4351{
4352 delete mRsmpInBuffer;
4353 // mRsmpInBuffer is always assigned a new[] below
4354 delete mRsmpOutBuffer;
4355 mRsmpOutBuffer = NULL;
4356 delete mResampler;
4357 mResampler = NULL;
4358
4359 mSampleRate = mInput->stream->common.get_sample_rate(&mInput->stream->common);
4360 mChannelMask = mInput->stream->common.get_channels(&mInput->stream->common);
4361 mChannelCount = (uint16_t)popcount(mChannelMask);
4362 mFormat = mInput->stream->common.get_format(&mInput->stream->common);
4363 mFrameSize = audio_stream_frame_size(&mInput->stream->common);
4364 mInputBytes = mInput->stream->common.get_buffer_size(&mInput->stream->common);
4365 mFrameCount = mInputBytes / mFrameSize;
4366 mNormalFrameCount = mFrameCount; // not used by record, but used by input effects
4367 mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount];
4368
4369 if (mSampleRate != mReqSampleRate && mChannelCount <= FCC_2 && mReqChannelCount <= FCC_2)
4370 {
4371 int channelCount;
4372 // optimization: if mono to mono, use the resampler in stereo to stereo mode to avoid
4373 // stereo to mono post process as the resampler always outputs stereo.
4374 if (mChannelCount == 1 && mReqChannelCount == 2) {
4375 channelCount = 1;
4376 } else {
4377 channelCount = 2;
4378 }
4379 mResampler = AudioResampler::create(16, channelCount, mReqSampleRate);
4380 mResampler->setSampleRate(mSampleRate);
4381 mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN);
4382 mRsmpOutBuffer = new int32_t[mFrameCount * 2];
4383
4384 // optmization: if mono to mono, alter input frame count as if we were inputing
4385 // stereo samples
4386 if (mChannelCount == 1 && mReqChannelCount == 1) {
4387 mFrameCount >>= 1;
4388 }
4389
4390 }
4391 mRsmpInIndex = mFrameCount;
4392}
4393
4394unsigned int AudioFlinger::RecordThread::getInputFramesLost()
4395{
4396 Mutex::Autolock _l(mLock);
4397 if (initCheck() != NO_ERROR) {
4398 return 0;
4399 }
4400
4401 return mInput->stream->get_input_frames_lost(mInput->stream);
4402}
4403
4404uint32_t AudioFlinger::RecordThread::hasAudioSession(int sessionId) const
4405{
4406 Mutex::Autolock _l(mLock);
4407 uint32_t result = 0;
4408 if (getEffectChain_l(sessionId) != 0) {
4409 result = EFFECT_SESSION;
4410 }
4411
4412 for (size_t i = 0; i < mTracks.size(); ++i) {
4413 if (sessionId == mTracks[i]->sessionId()) {
4414 result |= TRACK_SESSION;
4415 break;
4416 }
4417 }
4418
4419 return result;
4420}
4421
4422KeyedVector<int, bool> AudioFlinger::RecordThread::sessionIds() const
4423{
4424 KeyedVector<int, bool> ids;
4425 Mutex::Autolock _l(mLock);
4426 for (size_t j = 0; j < mTracks.size(); ++j) {
4427 sp<RecordThread::RecordTrack> track = mTracks[j];
4428 int sessionId = track->sessionId();
4429 if (ids.indexOfKey(sessionId) < 0) {
4430 ids.add(sessionId, true);
4431 }
4432 }
4433 return ids;
4434}
4435
4436AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
4437{
4438 Mutex::Autolock _l(mLock);
4439 AudioStreamIn *input = mInput;
4440 mInput = NULL;
4441 return input;
4442}
4443
4444// this method must always be called either with ThreadBase mLock held or inside the thread loop
4445audio_stream_t* AudioFlinger::RecordThread::stream() const
4446{
4447 if (mInput == NULL) {
4448 return NULL;
4449 }
4450 return &mInput->stream->common;
4451}
4452
4453status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
4454{
4455 // only one chain per input thread
4456 if (mEffectChains.size() != 0) {
4457 return INVALID_OPERATION;
4458 }
4459 ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
4460
4461 chain->setInBuffer(NULL);
4462 chain->setOutBuffer(NULL);
4463
4464 checkSuspendOnAddEffectChain_l(chain);
4465
4466 mEffectChains.add(chain);
4467
4468 return NO_ERROR;
4469}
4470
4471size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
4472{
4473 ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
4474 ALOGW_IF(mEffectChains.size() != 1,
4475 "removeEffectChain_l() %p invalid chain size %d on thread %p",
4476 chain.get(), mEffectChains.size(), this);
4477 if (mEffectChains.size() == 1) {
4478 mEffectChains.removeAt(0);
4479 }
4480 return 0;
4481}
4482
4483}; // namespace android