AudioFlinger.cpp revision 6146c08f0c3dd8b9e5788063aa433f304a810602 
1/*
2**
3** Copyright 2007, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18
19#define LOG_TAG "AudioFlinger"
20//#define LOG_NDEBUG 0
21
22#include "Configuration.h"
23#include <dirent.h>
24#include <math.h>
25#include <signal.h>
26#include <sys/time.h>
27#include <sys/resource.h>
28
29#include <binder/IPCThreadState.h>
30#include <binder/IServiceManager.h>
31#include <utils/Log.h>
32#include <utils/Trace.h>
33#include <binder/Parcel.h>
34#include <utils/String16.h>
35#include <utils/threads.h>
36#include <utils/Atomic.h>
37
38#include <cutils/bitops.h>
39#include <cutils/properties.h>
40
41#include <system/audio.h>
42#include <hardware/audio.h>
43
44#include "AudioMixer.h"
45#include "AudioFlinger.h"
46#include "ServiceUtilities.h"
47
48#include <media/EffectsFactoryApi.h>
49#include <audio_effects/effect_visualizer.h>
50#include <audio_effects/effect_ns.h>
51#include <audio_effects/effect_aec.h>
52
53#include <audio_utils/primitives.h>
54
55#include <powermanager/PowerManager.h>
56
57#include <common_time/cc_helper.h>
58
59#include <media/IMediaLogService.h>
60
61#include <media/nbaio/Pipe.h>
62#include <media/nbaio/PipeReader.h>
63#include <media/AudioParameter.h>
64#include <private/android_filesystem_config.h>
65
66// ----------------------------------------------------------------------------
67
68// Note: the following macro is used for extremely verbose logging message.  In
69// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
70// 0; but one side effect of this is to turn all LOGV's as well.  Some messages
71// are so verbose that we want to suppress them even when we have ALOG_ASSERT
72// turned on.  Do not uncomment the #def below unless you really know what you
73// are doing and want to see all of the extremely verbose messages.
74//#define VERY_VERY_VERBOSE_LOGGING
75#ifdef VERY_VERY_VERBOSE_LOGGING
76#define ALOGVV ALOGV
77#else
78#define ALOGVV(a...) do { } while(0)
79#endif
80
81namespace android {
82
83static const char kDeadlockedString[] = "AudioFlinger may be deadlocked\n";
84static const char kHardwareLockedString[] = "Hardware lock is taken\n";
85static const char kClientLockedString[] = "Client lock is taken\n";
86
87
88nsecs_t AudioFlinger::mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
89
90uint32_t AudioFlinger::mScreenState;
91
92#ifdef TEE_SINK
93bool AudioFlinger::mTeeSinkInputEnabled = false;
94bool AudioFlinger::mTeeSinkOutputEnabled = false;
95bool AudioFlinger::mTeeSinkTrackEnabled = false;
96
97size_t AudioFlinger::mTeeSinkInputFrames = kTeeSinkInputFramesDefault;
98size_t AudioFlinger::mTeeSinkOutputFrames = kTeeSinkOutputFramesDefault;
99size_t AudioFlinger::mTeeSinkTrackFrames = kTeeSinkTrackFramesDefault;
100#endif
101
102// In order to avoid invalidating offloaded tracks each time a Visualizer is turned on and off
103// we define a minimum time during which a global effect is considered enabled.
104static const nsecs_t kMinGlobalEffectEnabletimeNs = seconds(7200);
105
106// ----------------------------------------------------------------------------
107
108const char *formatToString(audio_format_t format) {
109    switch(format) {
110    case AUDIO_FORMAT_PCM_SUB_8_BIT: return "pcm8";
111    case AUDIO_FORMAT_PCM_SUB_16_BIT: return "pcm16";
112    case AUDIO_FORMAT_PCM_SUB_32_BIT: return "pcm32";
113    case AUDIO_FORMAT_PCM_SUB_8_24_BIT: return "pcm8.24";
114    case AUDIO_FORMAT_PCM_SUB_24_BIT_PACKED: return "pcm24";
115    case AUDIO_FORMAT_PCM_SUB_FLOAT: return "pcmfloat";
116    case AUDIO_FORMAT_MP3: return "mp3";
117    case AUDIO_FORMAT_AMR_NB: return "amr-nb";
118    case AUDIO_FORMAT_AMR_WB: return "amr-wb";
119    case AUDIO_FORMAT_AAC: return "aac";
120    case AUDIO_FORMAT_HE_AAC_V1: return "he-aac-v1";
121    case AUDIO_FORMAT_HE_AAC_V2: return "he-aac-v2";
122    case AUDIO_FORMAT_VORBIS: return "vorbis";
123    default:
124        break;
125    }
126    return "unknown";
127}
128
129static int load_audio_interface(const char *if_name, audio_hw_device_t **dev)
130{
131    const hw_module_t *mod;
132    int rc;
133
134    rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, &mod);
135    ALOGE_IF(rc, "%s couldn't load audio hw module %s.%s (%s)", __func__,
136                 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
137    if (rc) {
138        goto out;
139    }
140    rc = audio_hw_device_open(mod, dev);
141    ALOGE_IF(rc, "%s couldn't open audio hw device in %s.%s (%s)", __func__,
142                 AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
143    if (rc) {
144        goto out;
145    }
146    if ((*dev)->common.version < AUDIO_DEVICE_API_VERSION_MIN) {
147        ALOGE("%s wrong audio hw device version %04x", __func__, (*dev)->common.version);
148        rc = BAD_VALUE;
149        goto out;
150    }
151    return 0;
152
153out:
154    *dev = NULL;
155    return rc;
156}
157
158// ----------------------------------------------------------------------------
159
160AudioFlinger::AudioFlinger()
161    : BnAudioFlinger(),
162      mPrimaryHardwareDev(NULL),
163      mAudioHwDevs(NULL),
164      mHardwareStatus(AUDIO_HW_IDLE),
165      mMasterVolume(1.0f),
166      mMasterMute(false),
167      mNextUniqueId(1),
168      mMode(AUDIO_MODE_INVALID),
169      mBtNrecIsOff(false),
170      mIsLowRamDevice(true),
171      mIsDeviceTypeKnown(false),
172      mGlobalEffectEnableTime(0),
173      mPrimaryOutputSampleRate(0)
174{
175    getpid_cached = getpid();
176    char value[PROPERTY_VALUE_MAX];
177    bool doLog = (property_get("ro.test_harness", value, "0") > 0) && (atoi(value) == 1);
178    if (doLog) {
179        mLogMemoryDealer = new MemoryDealer(kLogMemorySize, "LogWriters", MemoryHeapBase::READ_ONLY);
180    }
181
182#ifdef TEE_SINK
183    (void) property_get("ro.debuggable", value, "0");
184    int debuggable = atoi(value);
185    int teeEnabled = 0;
186    if (debuggable) {
187        (void) property_get("af.tee", value, "0");
188        teeEnabled = atoi(value);
189    }
190    // FIXME symbolic constants here
191    if (teeEnabled & 1) {
192        mTeeSinkInputEnabled = true;
193    }
194    if (teeEnabled & 2) {
195        mTeeSinkOutputEnabled = true;
196    }
197    if (teeEnabled & 4) {
198        mTeeSinkTrackEnabled = true;
199    }
200#endif
201}
202
203void AudioFlinger::onFirstRef()
204{
205    int rc = 0;
206
207    Mutex::Autolock _l(mLock);
208
209    /* TODO: move all this work into an Init() function */
210    char val_str[PROPERTY_VALUE_MAX] = { 0 };
211    if (property_get("ro.audio.flinger_standbytime_ms", val_str, NULL) >= 0) {
212        uint32_t int_val;
213        if (1 == sscanf(val_str, "%u", &int_val)) {
214            mStandbyTimeInNsecs = milliseconds(int_val);
215            ALOGI("Using %u mSec as standby time.", int_val);
216        } else {
217            mStandbyTimeInNsecs = kDefaultStandbyTimeInNsecs;
218            ALOGI("Using default %u mSec as standby time.",
219                    (uint32_t)(mStandbyTimeInNsecs / 1000000));
220        }
221    }
222
223    mPatchPanel = new PatchPanel(this);
224
225    mMode = AUDIO_MODE_NORMAL;
226}
227
228AudioFlinger::~AudioFlinger()
229{
230    while (!mRecordThreads.isEmpty()) {
231        // closeInput_nonvirtual() will remove specified entry from mRecordThreads
232        closeInput_nonvirtual(mRecordThreads.keyAt(0));
233    }
234    while (!mPlaybackThreads.isEmpty()) {
235        // closeOutput_nonvirtual() will remove specified entry from mPlaybackThreads
236        closeOutput_nonvirtual(mPlaybackThreads.keyAt(0));
237    }
238
239    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
240        // no mHardwareLock needed, as there are no other references to this
241        audio_hw_device_close(mAudioHwDevs.valueAt(i)->hwDevice());
242        delete mAudioHwDevs.valueAt(i);
243    }
244
245    // Tell media.log service about any old writers that still need to be unregistered
246    sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log"));
247    if (binder != 0) {
248        sp<IMediaLogService> mediaLogService(interface_cast<IMediaLogService>(binder));
249        for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
250            sp<IMemory> iMemory(mUnregisteredWriters.top()->getIMemory());
251            mUnregisteredWriters.pop();
252            mediaLogService->unregisterWriter(iMemory);
253        }
254    }
255
256}
257
258static const char * const audio_interfaces[] = {
259    AUDIO_HARDWARE_MODULE_ID_PRIMARY,
260    AUDIO_HARDWARE_MODULE_ID_A2DP,
261    AUDIO_HARDWARE_MODULE_ID_USB,
262};
263#define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0])))
264
265AudioFlinger::AudioHwDevice* AudioFlinger::findSuitableHwDev_l(
266        audio_module_handle_t module,
267        audio_devices_t devices)
268{
269    // if module is 0, the request comes from an old policy manager and we should load
270    // well known modules
271    if (module == 0) {
272        ALOGW("findSuitableHwDev_l() loading well know audio hw modules");
273        for (size_t i = 0; i < ARRAY_SIZE(audio_interfaces); i++) {
274            loadHwModule_l(audio_interfaces[i]);
275        }
276        // then try to find a module supporting the requested device.
277        for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
278            AudioHwDevice *audioHwDevice = mAudioHwDevs.valueAt(i);
279            audio_hw_device_t *dev = audioHwDevice->hwDevice();
280            if ((dev->get_supported_devices != NULL) &&
281                    (dev->get_supported_devices(dev) & devices) == devices)
282                return audioHwDevice;
283        }
284    } else {
285        // check a match for the requested module handle
286        AudioHwDevice *audioHwDevice = mAudioHwDevs.valueFor(module);
287        if (audioHwDevice != NULL) {
288            return audioHwDevice;
289        }
290    }
291
292    return NULL;
293}
294
295void AudioFlinger::dumpClients(int fd, const Vector<String16>& args __unused)
296{
297    const size_t SIZE = 256;
298    char buffer[SIZE];
299    String8 result;
300
301    result.append("Clients:\n");
302    for (size_t i = 0; i < mClients.size(); ++i) {
303        sp<Client> client = mClients.valueAt(i).promote();
304        if (client != 0) {
305            snprintf(buffer, SIZE, "  pid: %d\n", client->pid());
306            result.append(buffer);
307        }
308    }
309
310    result.append("Notification Clients:\n");
311    for (size_t i = 0; i < mNotificationClients.size(); ++i) {
312        snprintf(buffer, SIZE, "  pid: %d\n", mNotificationClients.keyAt(i));
313        result.append(buffer);
314    }
315
316    result.append("Global session refs:\n");
317    result.append("  session   pid count\n");
318    for (size_t i = 0; i < mAudioSessionRefs.size(); i++) {
319        AudioSessionRef *r = mAudioSessionRefs[i];
320        snprintf(buffer, SIZE, "  %7d %5d %5d\n", r->mSessionid, r->mPid, r->mCnt);
321        result.append(buffer);
322    }
323    write(fd, result.string(), result.size());
324}
325
326
327void AudioFlinger::dumpInternals(int fd, const Vector<String16>& args __unused)
328{
329    const size_t SIZE = 256;
330    char buffer[SIZE];
331    String8 result;
332    hardware_call_state hardwareStatus = mHardwareStatus;
333
334    snprintf(buffer, SIZE, "Hardware status: %d\n"
335                           "Standby Time mSec: %u\n",
336                            hardwareStatus,
337                            (uint32_t)(mStandbyTimeInNsecs / 1000000));
338    result.append(buffer);
339    write(fd, result.string(), result.size());
340}
341
342void AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args __unused)
343{
344    const size_t SIZE = 256;
345    char buffer[SIZE];
346    String8 result;
347    snprintf(buffer, SIZE, "Permission Denial: "
348            "can't dump AudioFlinger from pid=%d, uid=%d\n",
349            IPCThreadState::self()->getCallingPid(),
350            IPCThreadState::self()->getCallingUid());
351    result.append(buffer);
352    write(fd, result.string(), result.size());
353}
354
355bool AudioFlinger::dumpTryLock(Mutex& mutex)
356{
357    bool locked = false;
358    for (int i = 0; i < kDumpLockRetries; ++i) {
359        if (mutex.tryLock() == NO_ERROR) {
360            locked = true;
361            break;
362        }
363        usleep(kDumpLockSleepUs);
364    }
365    return locked;
366}
367
368status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
369{
370    if (!dumpAllowed()) {
371        dumpPermissionDenial(fd, args);
372    } else {
373        // get state of hardware lock
374        bool hardwareLocked = dumpTryLock(mHardwareLock);
375        if (!hardwareLocked) {
376            String8 result(kHardwareLockedString);
377            write(fd, result.string(), result.size());
378        } else {
379            mHardwareLock.unlock();
380        }
381
382        bool locked = dumpTryLock(mLock);
383
384        // failed to lock - AudioFlinger is probably deadlocked
385        if (!locked) {
386            String8 result(kDeadlockedString);
387            write(fd, result.string(), result.size());
388        }
389
390        bool clientLocked = dumpTryLock(mClientLock);
391        if (!clientLocked) {
392            String8 result(kClientLockedString);
393            write(fd, result.string(), result.size());
394        }
395        dumpClients(fd, args);
396        if (clientLocked) {
397            mClientLock.unlock();
398        }
399
400        dumpInternals(fd, args);
401
402        // dump playback threads
403        for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
404            mPlaybackThreads.valueAt(i)->dump(fd, args);
405        }
406
407        // dump record threads
408        for (size_t i = 0; i < mRecordThreads.size(); i++) {
409            mRecordThreads.valueAt(i)->dump(fd, args);
410        }
411
412        // dump all hardware devs
413        for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
414            audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
415            dev->dump(dev, fd);
416        }
417
418#ifdef TEE_SINK
419        // dump the serially shared record tee sink
420        if (mRecordTeeSource != 0) {
421            dumpTee(fd, mRecordTeeSource);
422        }
423#endif
424
425        if (locked) {
426            mLock.unlock();
427        }
428
429        // append a copy of media.log here by forwarding fd to it, but don't attempt
430        // to lookup the service if it's not running, as it will block for a second
431        if (mLogMemoryDealer != 0) {
432            sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log"));
433            if (binder != 0) {
434                dprintf(fd, "\nmedia.log:\n");
435                Vector<String16> args;
436                binder->dump(fd, args);
437            }
438        }
439    }
440    return NO_ERROR;
441}
442
443sp<AudioFlinger::Client> AudioFlinger::registerPid(pid_t pid)
444{
445    Mutex::Autolock _cl(mClientLock);
446    // If pid is already in the mClients wp<> map, then use that entry
447    // (for which promote() is always != 0), otherwise create a new entry and Client.
448    sp<Client> client = mClients.valueFor(pid).promote();
449    if (client == 0) {
450        client = new Client(this, pid);
451        mClients.add(pid, client);
452    }
453
454    return client;
455}
456
457sp<NBLog::Writer> AudioFlinger::newWriter_l(size_t size, const char *name)
458{
459    // If there is no memory allocated for logs, return a dummy writer that does nothing
460    if (mLogMemoryDealer == 0) {
461        return new NBLog::Writer();
462    }
463    sp<IBinder> binder = defaultServiceManager()->getService(String16("media.log"));
464    // Similarly if we can't contact the media.log service, also return a dummy writer
465    if (binder == 0) {
466        return new NBLog::Writer();
467    }
468    sp<IMediaLogService> mediaLogService(interface_cast<IMediaLogService>(binder));
469    sp<IMemory> shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
470    // If allocation fails, consult the vector of previously unregistered writers
471    // and garbage-collect one or more them until an allocation succeeds
472    if (shared == 0) {
473        Mutex::Autolock _l(mUnregisteredWritersLock);
474        for (size_t count = mUnregisteredWriters.size(); count > 0; count--) {
475            {
476                // Pick the oldest stale writer to garbage-collect
477                sp<IMemory> iMemory(mUnregisteredWriters[0]->getIMemory());
478                mUnregisteredWriters.removeAt(0);
479                mediaLogService->unregisterWriter(iMemory);
480                // Now the media.log remote reference to IMemory is gone.  When our last local
481                // reference to IMemory also drops to zero at end of this block,
482                // the IMemory destructor will deallocate the region from mLogMemoryDealer.
483            }
484            // Re-attempt the allocation
485            shared = mLogMemoryDealer->allocate(NBLog::Timeline::sharedSize(size));
486            if (shared != 0) {
487                goto success;
488            }
489        }
490        // Even after garbage-collecting all old writers, there is still not enough memory,
491        // so return a dummy writer
492        return new NBLog::Writer();
493    }
494success:
495    mediaLogService->registerWriter(shared, size, name);
496    return new NBLog::Writer(size, shared);
497}
498
499void AudioFlinger::unregisterWriter(const sp<NBLog::Writer>& writer)
500{
501    if (writer == 0) {
502        return;
503    }
504    sp<IMemory> iMemory(writer->getIMemory());
505    if (iMemory == 0) {
506        return;
507    }
508    // Rather than removing the writer immediately, append it to a queue of old writers to
509    // be garbage-collected later.  This allows us to continue to view old logs for a while.
510    Mutex::Autolock _l(mUnregisteredWritersLock);
511    mUnregisteredWriters.push(writer);
512}
513
514// IAudioFlinger interface
515
516
517sp<IAudioTrack> AudioFlinger::createTrack(
518        audio_stream_type_t streamType,
519        uint32_t sampleRate,
520        audio_format_t format,
521        audio_channel_mask_t channelMask,
522        size_t *frameCount,
523        IAudioFlinger::track_flags_t *flags,
524        const sp<IMemory>& sharedBuffer,
525        audio_io_handle_t output,
526        pid_t tid,
527        int *sessionId,
528        int clientUid,
529        status_t *status)
530{
531    sp<PlaybackThread::Track> track;
532    sp<TrackHandle> trackHandle;
533    sp<Client> client;
534    status_t lStatus;
535    int lSessionId;
536
537    // client AudioTrack::set already implements AUDIO_STREAM_DEFAULT => AUDIO_STREAM_MUSIC,
538    // but if someone uses binder directly they could bypass that and cause us to crash
539    if (uint32_t(streamType) >= AUDIO_STREAM_CNT) {
540        ALOGE("createTrack() invalid stream type %d", streamType);
541        lStatus = BAD_VALUE;
542        goto Exit;
543    }
544
545    // further sample rate checks are performed by createTrack_l() depending on the thread type
546    if (sampleRate == 0) {
547        ALOGE("createTrack() invalid sample rate %u", sampleRate);
548        lStatus = BAD_VALUE;
549        goto Exit;
550    }
551
552    // further channel mask checks are performed by createTrack_l() depending on the thread type
553    if (!audio_is_output_channel(channelMask)) {
554        ALOGE("createTrack() invalid channel mask %#x", channelMask);
555        lStatus = BAD_VALUE;
556        goto Exit;
557    }
558
559    // further format checks are performed by createTrack_l() depending on the thread type
560    if (!audio_is_valid_format(format)) {
561        ALOGE("createTrack() invalid format %#x", format);
562        lStatus = BAD_VALUE;
563        goto Exit;
564    }
565
566    if (sharedBuffer != 0 && sharedBuffer->pointer() == NULL) {
567        ALOGE("createTrack() sharedBuffer is non-0 but has NULL pointer()");
568        lStatus = BAD_VALUE;
569        goto Exit;
570    }
571
572    {
573        Mutex::Autolock _l(mLock);
574        PlaybackThread *thread = checkPlaybackThread_l(output);
575        if (thread == NULL) {
576            ALOGE("no playback thread found for output handle %d", output);
577            lStatus = BAD_VALUE;
578            goto Exit;
579        }
580
581        pid_t pid = IPCThreadState::self()->getCallingPid();
582        client = registerPid(pid);
583
584        PlaybackThread *effectThread = NULL;
585        if (sessionId != NULL && *sessionId != AUDIO_SESSION_ALLOCATE) {
586            lSessionId = *sessionId;
587            // check if an effect chain with the same session ID is present on another
588            // output thread and move it here.
589            for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
590                sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
591                if (mPlaybackThreads.keyAt(i) != output) {
592                    uint32_t sessions = t->hasAudioSession(lSessionId);
593                    if (sessions & PlaybackThread::EFFECT_SESSION) {
594                        effectThread = t.get();
595                        break;
596                    }
597                }
598            }
599        } else {
600            // if no audio session id is provided, create one here
601            lSessionId = nextUniqueId();
602            if (sessionId != NULL) {
603                *sessionId = lSessionId;
604            }
605        }
606        ALOGV("createTrack() lSessionId: %d", lSessionId);
607
608        track = thread->createTrack_l(client, streamType, sampleRate, format,
609                channelMask, frameCount, sharedBuffer, lSessionId, flags, tid, clientUid, &lStatus);
610        LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (track == 0));
611        // we don't abort yet if lStatus != NO_ERROR; there is still work to be done regardless
612
613        // move effect chain to this output thread if an effect on same session was waiting
614        // for a track to be created
615        if (lStatus == NO_ERROR && effectThread != NULL) {
616            // no risk of deadlock because AudioFlinger::mLock is held
617            Mutex::Autolock _dl(thread->mLock);
618            Mutex::Autolock _sl(effectThread->mLock);
619            moveEffectChain_l(lSessionId, effectThread, thread, true);
620        }
621
622        // Look for sync events awaiting for a session to be used.
623        for (size_t i = 0; i < mPendingSyncEvents.size(); i++) {
624            if (mPendingSyncEvents[i]->triggerSession() == lSessionId) {
625                if (thread->isValidSyncEvent(mPendingSyncEvents[i])) {
626                    if (lStatus == NO_ERROR) {
627                        (void) track->setSyncEvent(mPendingSyncEvents[i]);
628                    } else {
629                        mPendingSyncEvents[i]->cancel();
630                    }
631                    mPendingSyncEvents.removeAt(i);
632                    i--;
633                }
634            }
635        }
636
637    }
638
639    if (lStatus != NO_ERROR) {
640        // remove local strong reference to Client before deleting the Track so that the
641        // Client destructor is called by the TrackBase destructor with mClientLock held
642        // Don't hold mClientLock when releasing the reference on the track as the
643        // destructor will acquire it.
644        {
645            Mutex::Autolock _cl(mClientLock);
646            client.clear();
647        }
648        track.clear();
649        goto Exit;
650    }
651
652    // return handle to client
653    trackHandle = new TrackHandle(track);
654
655Exit:
656    *status = lStatus;
657    return trackHandle;
658}
659
660uint32_t AudioFlinger::sampleRate(audio_io_handle_t output) const
661{
662    Mutex::Autolock _l(mLock);
663    PlaybackThread *thread = checkPlaybackThread_l(output);
664    if (thread == NULL) {
665        ALOGW("sampleRate() unknown thread %d", output);
666        return 0;
667    }
668    return thread->sampleRate();
669}
670
671int AudioFlinger::channelCount(audio_io_handle_t output) const
672{
673    Mutex::Autolock _l(mLock);
674    PlaybackThread *thread = checkPlaybackThread_l(output);
675    if (thread == NULL) {
676        ALOGW("channelCount() unknown thread %d", output);
677        return 0;
678    }
679    return thread->channelCount();
680}
681
682audio_format_t AudioFlinger::format(audio_io_handle_t output) const
683{
684    Mutex::Autolock _l(mLock);
685    PlaybackThread *thread = checkPlaybackThread_l(output);
686    if (thread == NULL) {
687        ALOGW("format() unknown thread %d", output);
688        return AUDIO_FORMAT_INVALID;
689    }
690    return thread->format();
691}
692
693size_t AudioFlinger::frameCount(audio_io_handle_t output) const
694{
695    Mutex::Autolock _l(mLock);
696    PlaybackThread *thread = checkPlaybackThread_l(output);
697    if (thread == NULL) {
698        ALOGW("frameCount() unknown thread %d", output);
699        return 0;
700    }
701    // FIXME currently returns the normal mixer's frame count to avoid confusing legacy callers;
702    //       should examine all callers and fix them to handle smaller counts
703    return thread->frameCount();
704}
705
706uint32_t AudioFlinger::latency(audio_io_handle_t output) const
707{
708    Mutex::Autolock _l(mLock);
709    PlaybackThread *thread = checkPlaybackThread_l(output);
710    if (thread == NULL) {
711        ALOGW("latency(): no playback thread found for output handle %d", output);
712        return 0;
713    }
714    return thread->latency();
715}
716
717status_t AudioFlinger::setMasterVolume(float value)
718{
719    status_t ret = initCheck();
720    if (ret != NO_ERROR) {
721        return ret;
722    }
723
724    // check calling permissions
725    if (!settingsAllowed()) {
726        return PERMISSION_DENIED;
727    }
728
729    Mutex::Autolock _l(mLock);
730    mMasterVolume = value;
731
732    // Set master volume in the HALs which support it.
733    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
734        AutoMutex lock(mHardwareLock);
735        AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
736
737        mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
738        if (dev->canSetMasterVolume()) {
739            dev->hwDevice()->set_master_volume(dev->hwDevice(), value);
740        }
741        mHardwareStatus = AUDIO_HW_IDLE;
742    }
743
744    // Now set the master volume in each playback thread.  Playback threads
745    // assigned to HALs which do not have master volume support will apply
746    // master volume during the mix operation.  Threads with HALs which do
747    // support master volume will simply ignore the setting.
748    for (size_t i = 0; i < mPlaybackThreads.size(); i++)
749        mPlaybackThreads.valueAt(i)->setMasterVolume(value);
750
751    return NO_ERROR;
752}
753
754status_t AudioFlinger::setMode(audio_mode_t mode)
755{
756    status_t ret = initCheck();
757    if (ret != NO_ERROR) {
758        return ret;
759    }
760
761    // check calling permissions
762    if (!settingsAllowed()) {
763        return PERMISSION_DENIED;
764    }
765    if (uint32_t(mode) >= AUDIO_MODE_CNT) {
766        ALOGW("Illegal value: setMode(%d)", mode);
767        return BAD_VALUE;
768    }
769
770    { // scope for the lock
771        AutoMutex lock(mHardwareLock);
772        audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice();
773        mHardwareStatus = AUDIO_HW_SET_MODE;
774        ret = dev->set_mode(dev, mode);
775        mHardwareStatus = AUDIO_HW_IDLE;
776    }
777
778    if (NO_ERROR == ret) {
779        Mutex::Autolock _l(mLock);
780        mMode = mode;
781        for (size_t i = 0; i < mPlaybackThreads.size(); i++)
782            mPlaybackThreads.valueAt(i)->setMode(mode);
783    }
784
785    return ret;
786}
787
788status_t AudioFlinger::setMicMute(bool state)
789{
790    status_t ret = initCheck();
791    if (ret != NO_ERROR) {
792        return ret;
793    }
794
795    // check calling permissions
796    if (!settingsAllowed()) {
797        return PERMISSION_DENIED;
798    }
799
800    AutoMutex lock(mHardwareLock);
801    audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice();
802    mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
803    ret = dev->set_mic_mute(dev, state);
804    mHardwareStatus = AUDIO_HW_IDLE;
805    return ret;
806}
807
808bool AudioFlinger::getMicMute() const
809{
810    status_t ret = initCheck();
811    if (ret != NO_ERROR) {
812        return false;
813    }
814
815    bool state = AUDIO_MODE_INVALID;
816    AutoMutex lock(mHardwareLock);
817    audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice();
818    mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
819    dev->get_mic_mute(dev, &state);
820    mHardwareStatus = AUDIO_HW_IDLE;
821    return state;
822}
823
824status_t AudioFlinger::setMasterMute(bool muted)
825{
826    status_t ret = initCheck();
827    if (ret != NO_ERROR) {
828        return ret;
829    }
830
831    // check calling permissions
832    if (!settingsAllowed()) {
833        return PERMISSION_DENIED;
834    }
835
836    Mutex::Autolock _l(mLock);
837    mMasterMute = muted;
838
839    // Set master mute in the HALs which support it.
840    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
841        AutoMutex lock(mHardwareLock);
842        AudioHwDevice *dev = mAudioHwDevs.valueAt(i);
843
844        mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
845        if (dev->canSetMasterMute()) {
846            dev->hwDevice()->set_master_mute(dev->hwDevice(), muted);
847        }
848        mHardwareStatus = AUDIO_HW_IDLE;
849    }
850
851    // Now set the master mute in each playback thread.  Playback threads
852    // assigned to HALs which do not have master mute support will apply master
853    // mute during the mix operation.  Threads with HALs which do support master
854    // mute will simply ignore the setting.
855    for (size_t i = 0; i < mPlaybackThreads.size(); i++)
856        mPlaybackThreads.valueAt(i)->setMasterMute(muted);
857
858    return NO_ERROR;
859}
860
861float AudioFlinger::masterVolume() const
862{
863    Mutex::Autolock _l(mLock);
864    return masterVolume_l();
865}
866
867bool AudioFlinger::masterMute() const
868{
869    Mutex::Autolock _l(mLock);
870    return masterMute_l();
871}
872
873float AudioFlinger::masterVolume_l() const
874{
875    return mMasterVolume;
876}
877
878bool AudioFlinger::masterMute_l() const
879{
880    return mMasterMute;
881}
882
883status_t AudioFlinger::setStreamVolume(audio_stream_type_t stream, float value,
884        audio_io_handle_t output)
885{
886    // check calling permissions
887    if (!settingsAllowed()) {
888        return PERMISSION_DENIED;
889    }
890
891    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
892        ALOGE("setStreamVolume() invalid stream %d", stream);
893        return BAD_VALUE;
894    }
895
896    AutoMutex lock(mLock);
897    PlaybackThread *thread = NULL;
898    if (output != AUDIO_IO_HANDLE_NONE) {
899        thread = checkPlaybackThread_l(output);
900        if (thread == NULL) {
901            return BAD_VALUE;
902        }
903    }
904
905    mStreamTypes[stream].volume = value;
906
907    if (thread == NULL) {
908        for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
909            mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value);
910        }
911    } else {
912        thread->setStreamVolume(stream, value);
913    }
914
915    return NO_ERROR;
916}
917
918status_t AudioFlinger::setStreamMute(audio_stream_type_t stream, bool muted)
919{
920    // check calling permissions
921    if (!settingsAllowed()) {
922        return PERMISSION_DENIED;
923    }
924
925    if (uint32_t(stream) >= AUDIO_STREAM_CNT ||
926        uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) {
927        ALOGE("setStreamMute() invalid stream %d", stream);
928        return BAD_VALUE;
929    }
930
931    AutoMutex lock(mLock);
932    mStreamTypes[stream].mute = muted;
933    for (size_t i = 0; i < mPlaybackThreads.size(); i++)
934        mPlaybackThreads.valueAt(i)->setStreamMute(stream, muted);
935
936    return NO_ERROR;
937}
938
939float AudioFlinger::streamVolume(audio_stream_type_t stream, audio_io_handle_t output) const
940{
941    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
942        return 0.0f;
943    }
944
945    AutoMutex lock(mLock);
946    float volume;
947    if (output != AUDIO_IO_HANDLE_NONE) {
948        PlaybackThread *thread = checkPlaybackThread_l(output);
949        if (thread == NULL) {
950            return 0.0f;
951        }
952        volume = thread->streamVolume(stream);
953    } else {
954        volume = streamVolume_l(stream);
955    }
956
957    return volume;
958}
959
960bool AudioFlinger::streamMute(audio_stream_type_t stream) const
961{
962    if (uint32_t(stream) >= AUDIO_STREAM_CNT) {
963        return true;
964    }
965
966    AutoMutex lock(mLock);
967    return streamMute_l(stream);
968}
969
970status_t AudioFlinger::setParameters(audio_io_handle_t ioHandle, const String8& keyValuePairs)
971{
972    ALOGV("setParameters(): io %d, keyvalue %s, calling pid %d",
973            ioHandle, keyValuePairs.string(), IPCThreadState::self()->getCallingPid());
974
975    // check calling permissions
976    if (!settingsAllowed()) {
977        return PERMISSION_DENIED;
978    }
979
980    // AUDIO_IO_HANDLE_NONE means the parameters are global to the audio hardware interface
981    if (ioHandle == AUDIO_IO_HANDLE_NONE) {
982        Mutex::Autolock _l(mLock);
983        status_t final_result = NO_ERROR;
984        {
985            AutoMutex lock(mHardwareLock);
986            mHardwareStatus = AUDIO_HW_SET_PARAMETER;
987            for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
988                audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
989                status_t result = dev->set_parameters(dev, keyValuePairs.string());
990                final_result = result ?: final_result;
991            }
992            mHardwareStatus = AUDIO_HW_IDLE;
993        }
994        // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
995        AudioParameter param = AudioParameter(keyValuePairs);
996        String8 value;
997        if (param.get(String8(AUDIO_PARAMETER_KEY_BT_NREC), value) == NO_ERROR) {
998            bool btNrecIsOff = (value == AUDIO_PARAMETER_VALUE_OFF);
999            if (mBtNrecIsOff != btNrecIsOff) {
1000                for (size_t i = 0; i < mRecordThreads.size(); i++) {
1001                    sp<RecordThread> thread = mRecordThreads.valueAt(i);
1002                    audio_devices_t device = thread->inDevice();
1003                    bool suspend = audio_is_bluetooth_sco_device(device) && btNrecIsOff;
1004                    // collect all of the thread's session IDs
1005                    KeyedVector<int, bool> ids = thread->sessionIds();
1006                    // suspend effects associated with those session IDs
1007                    for (size_t j = 0; j < ids.size(); ++j) {
1008                        int sessionId = ids.keyAt(j);
1009                        thread->setEffectSuspended(FX_IID_AEC,
1010                                                   suspend,
1011                                                   sessionId);
1012                        thread->setEffectSuspended(FX_IID_NS,
1013                                                   suspend,
1014                                                   sessionId);
1015                    }
1016                }
1017                mBtNrecIsOff = btNrecIsOff;
1018            }
1019        }
1020        String8 screenState;
1021        if (param.get(String8(AudioParameter::keyScreenState), screenState) == NO_ERROR) {
1022            bool isOff = screenState == "off";
1023            if (isOff != (AudioFlinger::mScreenState & 1)) {
1024                AudioFlinger::mScreenState = ((AudioFlinger::mScreenState & ~1) + 2) | isOff;
1025            }
1026        }
1027        return final_result;
1028    }
1029
1030    // hold a strong ref on thread in case closeOutput() or closeInput() is called
1031    // and the thread is exited once the lock is released
1032    sp<ThreadBase> thread;
1033    {
1034        Mutex::Autolock _l(mLock);
1035        thread = checkPlaybackThread_l(ioHandle);
1036        if (thread == 0) {
1037            thread = checkRecordThread_l(ioHandle);
1038        } else if (thread == primaryPlaybackThread_l()) {
1039            // indicate output device change to all input threads for pre processing
1040            AudioParameter param = AudioParameter(keyValuePairs);
1041            int value;
1042            if ((param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) &&
1043                    (value != 0)) {
1044                for (size_t i = 0; i < mRecordThreads.size(); i++) {
1045                    mRecordThreads.valueAt(i)->setParameters(keyValuePairs);
1046                }
1047            }
1048        }
1049    }
1050    if (thread != 0) {
1051        return thread->setParameters(keyValuePairs);
1052    }
1053    return BAD_VALUE;
1054}
1055
1056String8 AudioFlinger::getParameters(audio_io_handle_t ioHandle, const String8& keys) const
1057{
1058    ALOGVV("getParameters() io %d, keys %s, calling pid %d",
1059            ioHandle, keys.string(), IPCThreadState::self()->getCallingPid());
1060
1061    Mutex::Autolock _l(mLock);
1062
1063    if (ioHandle == AUDIO_IO_HANDLE_NONE) {
1064        String8 out_s8;
1065
1066        for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1067            char *s;
1068            {
1069            AutoMutex lock(mHardwareLock);
1070            mHardwareStatus = AUDIO_HW_GET_PARAMETER;
1071            audio_hw_device_t *dev = mAudioHwDevs.valueAt(i)->hwDevice();
1072            s = dev->get_parameters(dev, keys.string());
1073            mHardwareStatus = AUDIO_HW_IDLE;
1074            }
1075            out_s8 += String8(s ? s : "");
1076            free(s);
1077        }
1078        return out_s8;
1079    }
1080
1081    PlaybackThread *playbackThread = checkPlaybackThread_l(ioHandle);
1082    if (playbackThread != NULL) {
1083        return playbackThread->getParameters(keys);
1084    }
1085    RecordThread *recordThread = checkRecordThread_l(ioHandle);
1086    if (recordThread != NULL) {
1087        return recordThread->getParameters(keys);
1088    }
1089    return String8("");
1090}
1091
1092size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, audio_format_t format,
1093        audio_channel_mask_t channelMask) const
1094{
1095    status_t ret = initCheck();
1096    if (ret != NO_ERROR) {
1097        return 0;
1098    }
1099
1100    AutoMutex lock(mHardwareLock);
1101    mHardwareStatus = AUDIO_HW_GET_INPUT_BUFFER_SIZE;
1102    struct audio_config config;
1103    memset(&config, 0, sizeof(config));
1104    config.sample_rate = sampleRate;
1105    config.channel_mask = channelMask;
1106    config.format = format;
1107
1108    audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice();
1109    size_t size = dev->get_input_buffer_size(dev, &config);
1110    mHardwareStatus = AUDIO_HW_IDLE;
1111    return size;
1112}
1113
1114uint32_t AudioFlinger::getInputFramesLost(audio_io_handle_t ioHandle) const
1115{
1116    Mutex::Autolock _l(mLock);
1117
1118    RecordThread *recordThread = checkRecordThread_l(ioHandle);
1119    if (recordThread != NULL) {
1120        return recordThread->getInputFramesLost();
1121    }
1122    return 0;
1123}
1124
1125status_t AudioFlinger::setVoiceVolume(float value)
1126{
1127    status_t ret = initCheck();
1128    if (ret != NO_ERROR) {
1129        return ret;
1130    }
1131
1132    // check calling permissions
1133    if (!settingsAllowed()) {
1134        return PERMISSION_DENIED;
1135    }
1136
1137    AutoMutex lock(mHardwareLock);
1138    audio_hw_device_t *dev = mPrimaryHardwareDev->hwDevice();
1139    mHardwareStatus = AUDIO_HW_SET_VOICE_VOLUME;
1140    ret = dev->set_voice_volume(dev, value);
1141    mHardwareStatus = AUDIO_HW_IDLE;
1142
1143    return ret;
1144}
1145
1146status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames,
1147        audio_io_handle_t output) const
1148{
1149    status_t status;
1150
1151    Mutex::Autolock _l(mLock);
1152
1153    PlaybackThread *playbackThread = checkPlaybackThread_l(output);
1154    if (playbackThread != NULL) {
1155        return playbackThread->getRenderPosition(halFrames, dspFrames);
1156    }
1157
1158    return BAD_VALUE;
1159}
1160
1161void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client)
1162{
1163    Mutex::Autolock _l(mLock);
1164    bool clientAdded = false;
1165    {
1166        Mutex::Autolock _cl(mClientLock);
1167
1168        pid_t pid = IPCThreadState::self()->getCallingPid();
1169        if (mNotificationClients.indexOfKey(pid) < 0) {
1170            sp<NotificationClient> notificationClient = new NotificationClient(this,
1171                                                                                client,
1172                                                                                pid);
1173            ALOGV("registerClient() client %p, pid %d", notificationClient.get(), pid);
1174
1175            mNotificationClients.add(pid, notificationClient);
1176
1177            sp<IBinder> binder = client->asBinder();
1178            binder->linkToDeath(notificationClient);
1179            clientAdded = true;
1180        }
1181    }
1182
1183    // mClientLock should not be held here because ThreadBase::sendIoConfigEvent() will lock the
1184    // ThreadBase mutex and the locking order is ThreadBase::mLock then AudioFlinger::mClientLock.
1185    if (clientAdded) {
1186        // the config change is always sent from playback or record threads to avoid deadlock
1187        // with AudioSystem::gLock
1188        for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1189            mPlaybackThreads.valueAt(i)->sendIoConfigEvent(AudioSystem::OUTPUT_OPENED);
1190        }
1191
1192        for (size_t i = 0; i < mRecordThreads.size(); i++) {
1193            mRecordThreads.valueAt(i)->sendIoConfigEvent(AudioSystem::INPUT_OPENED);
1194        }
1195    }
1196}
1197
1198void AudioFlinger::removeNotificationClient(pid_t pid)
1199{
1200    Mutex::Autolock _l(mLock);
1201    {
1202        Mutex::Autolock _cl(mClientLock);
1203        mNotificationClients.removeItem(pid);
1204    }
1205
1206    ALOGV("%d died, releasing its sessions", pid);
1207    size_t num = mAudioSessionRefs.size();
1208    bool removed = false;
1209    for (size_t i = 0; i< num; ) {
1210        AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
1211        ALOGV(" pid %d @ %d", ref->mPid, i);
1212        if (ref->mPid == pid) {
1213            ALOGV(" removing entry for pid %d session %d", pid, ref->mSessionid);
1214            mAudioSessionRefs.removeAt(i);
1215            delete ref;
1216            removed = true;
1217            num--;
1218        } else {
1219            i++;
1220        }
1221    }
1222    if (removed) {
1223        purgeStaleEffects_l();
1224    }
1225}
1226
1227void AudioFlinger::audioConfigChanged(int event, audio_io_handle_t ioHandle, const void *param2)
1228{
1229    Mutex::Autolock _l(mClientLock);
1230    size_t size = mNotificationClients.size();
1231    for (size_t i = 0; i < size; i++) {
1232        mNotificationClients.valueAt(i)->audioFlingerClient()->ioConfigChanged(event,
1233                                                                              ioHandle,
1234                                                                              param2);
1235    }
1236}
1237
1238// removeClient_l() must be called with AudioFlinger::mClientLock held
1239void AudioFlinger::removeClient_l(pid_t pid)
1240{
1241    ALOGV("removeClient_l() pid %d, calling pid %d", pid,
1242            IPCThreadState::self()->getCallingPid());
1243    mClients.removeItem(pid);
1244}
1245
1246// getEffectThread_l() must be called with AudioFlinger::mLock held
1247sp<AudioFlinger::PlaybackThread> AudioFlinger::getEffectThread_l(int sessionId, int EffectId)
1248{
1249    sp<PlaybackThread> thread;
1250
1251    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1252        if (mPlaybackThreads.valueAt(i)->getEffect(sessionId, EffectId) != 0) {
1253            ALOG_ASSERT(thread == 0);
1254            thread = mPlaybackThreads.valueAt(i);
1255        }
1256    }
1257
1258    return thread;
1259}
1260
1261
1262
1263// ----------------------------------------------------------------------------
1264
1265AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
1266    :   RefBase(),
1267        mAudioFlinger(audioFlinger),
1268        // FIXME should be a "k" constant not hard-coded, in .h or ro. property, see 4 lines below
1269        mMemoryDealer(new MemoryDealer(1024*1024, "AudioFlinger::Client")),
1270        mPid(pid),
1271        mTimedTrackCount(0)
1272{
1273    // 1 MB of address space is good for 32 tracks, 8 buffers each, 4 KB/buffer
1274}
1275
1276// Client destructor must be called with AudioFlinger::mClientLock held
1277AudioFlinger::Client::~Client()
1278{
1279    mAudioFlinger->removeClient_l(mPid);
1280}
1281
1282sp<MemoryDealer> AudioFlinger::Client::heap() const
1283{
1284    return mMemoryDealer;
1285}
1286
1287// Reserve one of the limited slots for a timed audio track associated
1288// with this client
1289bool AudioFlinger::Client::reserveTimedTrack()
1290{
1291    const int kMaxTimedTracksPerClient = 4;
1292
1293    Mutex::Autolock _l(mTimedTrackLock);
1294
1295    if (mTimedTrackCount >= kMaxTimedTracksPerClient) {
1296        ALOGW("can not create timed track - pid %d has exceeded the limit",
1297             mPid);
1298        return false;
1299    }
1300
1301    mTimedTrackCount++;
1302    return true;
1303}
1304
1305// Release a slot for a timed audio track
1306void AudioFlinger::Client::releaseTimedTrack()
1307{
1308    Mutex::Autolock _l(mTimedTrackLock);
1309    mTimedTrackCount--;
1310}
1311
1312// ----------------------------------------------------------------------------
1313
1314AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger,
1315                                                     const sp<IAudioFlingerClient>& client,
1316                                                     pid_t pid)
1317    : mAudioFlinger(audioFlinger), mPid(pid), mAudioFlingerClient(client)
1318{
1319}
1320
1321AudioFlinger::NotificationClient::~NotificationClient()
1322{
1323}
1324
1325void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who __unused)
1326{
1327    sp<NotificationClient> keep(this);
1328    mAudioFlinger->removeNotificationClient(mPid);
1329}
1330
1331
1332// ----------------------------------------------------------------------------
1333
1334static bool deviceRequiresCaptureAudioOutputPermission(audio_devices_t inDevice) {
1335    return audio_is_remote_submix_device(inDevice);
1336}
1337
1338sp<IAudioRecord> AudioFlinger::openRecord(
1339        audio_io_handle_t input,
1340        uint32_t sampleRate,
1341        audio_format_t format,
1342        audio_channel_mask_t channelMask,
1343        size_t *frameCount,
1344        IAudioFlinger::track_flags_t *flags,
1345        pid_t tid,
1346        int *sessionId,
1347        sp<IMemory>& cblk,
1348        sp<IMemory>& buffers,
1349        status_t *status)
1350{
1351    sp<RecordThread::RecordTrack> recordTrack;
1352    sp<RecordHandle> recordHandle;
1353    sp<Client> client;
1354    status_t lStatus;
1355    int lSessionId;
1356
1357    cblk.clear();
1358    buffers.clear();
1359
1360    // check calling permissions
1361    if (!recordingAllowed()) {
1362        ALOGE("openRecord() permission denied: recording not allowed");
1363        lStatus = PERMISSION_DENIED;
1364        goto Exit;
1365    }
1366
1367    // further sample rate checks are performed by createRecordTrack_l()
1368    if (sampleRate == 0) {
1369        ALOGE("openRecord() invalid sample rate %u", sampleRate);
1370        lStatus = BAD_VALUE;
1371        goto Exit;
1372    }
1373
1374    // we don't yet support anything other than 16-bit PCM
1375    if (!(audio_is_valid_format(format) &&
1376            audio_is_linear_pcm(format) && format == AUDIO_FORMAT_PCM_16_BIT)) {
1377        ALOGE("openRecord() invalid format %#x", format);
1378        lStatus = BAD_VALUE;
1379        goto Exit;
1380    }
1381
1382    // further channel mask checks are performed by createRecordTrack_l()
1383    if (!audio_is_input_channel(channelMask)) {
1384        ALOGE("openRecord() invalid channel mask %#x", channelMask);
1385        lStatus = BAD_VALUE;
1386        goto Exit;
1387    }
1388
1389    {
1390        Mutex::Autolock _l(mLock);
1391        RecordThread *thread = checkRecordThread_l(input);
1392        if (thread == NULL) {
1393            ALOGE("openRecord() checkRecordThread_l failed");
1394            lStatus = BAD_VALUE;
1395            goto Exit;
1396        }
1397
1398        if (deviceRequiresCaptureAudioOutputPermission(thread->inDevice())
1399                && !captureAudioOutputAllowed()) {
1400            ALOGE("openRecord() permission denied: capture not allowed");
1401            lStatus = PERMISSION_DENIED;
1402            goto Exit;
1403        }
1404
1405        pid_t pid = IPCThreadState::self()->getCallingPid();
1406        client = registerPid(pid);
1407
1408        if (sessionId != NULL && *sessionId != AUDIO_SESSION_ALLOCATE) {
1409            lSessionId = *sessionId;
1410        } else {
1411            // if no audio session id is provided, create one here
1412            lSessionId = nextUniqueId();
1413            if (sessionId != NULL) {
1414                *sessionId = lSessionId;
1415            }
1416        }
1417        ALOGV("openRecord() lSessionId: %d", lSessionId);
1418
1419        // TODO: the uid should be passed in as a parameter to openRecord
1420        recordTrack = thread->createRecordTrack_l(client, sampleRate, format, channelMask,
1421                                                  frameCount, lSessionId,
1422                                                  IPCThreadState::self()->getCallingUid(),
1423                                                  flags, tid, &lStatus);
1424        LOG_ALWAYS_FATAL_IF((lStatus == NO_ERROR) && (recordTrack == 0));
1425    }
1426
1427    if (lStatus != NO_ERROR) {
1428        // remove local strong reference to Client before deleting the RecordTrack so that the
1429        // Client destructor is called by the TrackBase destructor with mClientLock held
1430        // Don't hold mClientLock when releasing the reference on the track as the
1431        // destructor will acquire it.
1432        {
1433            Mutex::Autolock _cl(mClientLock);
1434            client.clear();
1435        }
1436        recordTrack.clear();
1437        goto Exit;
1438    }
1439
1440    cblk = recordTrack->getCblk();
1441    buffers = recordTrack->getBuffers();
1442
1443    // return handle to client
1444    recordHandle = new RecordHandle(recordTrack);
1445
1446Exit:
1447    *status = lStatus;
1448    return recordHandle;
1449}
1450
1451
1452
1453// ----------------------------------------------------------------------------
1454
1455audio_module_handle_t AudioFlinger::loadHwModule(const char *name)
1456{
1457    if (!settingsAllowed()) {
1458        return 0;
1459    }
1460    Mutex::Autolock _l(mLock);
1461    return loadHwModule_l(name);
1462}
1463
1464// loadHwModule_l() must be called with AudioFlinger::mLock held
1465audio_module_handle_t AudioFlinger::loadHwModule_l(const char *name)
1466{
1467    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
1468        if (strncmp(mAudioHwDevs.valueAt(i)->moduleName(), name, strlen(name)) == 0) {
1469            ALOGW("loadHwModule() module %s already loaded", name);
1470            return mAudioHwDevs.keyAt(i);
1471        }
1472    }
1473
1474    audio_hw_device_t *dev;
1475
1476    int rc = load_audio_interface(name, &dev);
1477    if (rc) {
1478        ALOGI("loadHwModule() error %d loading module %s ", rc, name);
1479        return 0;
1480    }
1481
1482    mHardwareStatus = AUDIO_HW_INIT;
1483    rc = dev->init_check(dev);
1484    mHardwareStatus = AUDIO_HW_IDLE;
1485    if (rc) {
1486        ALOGI("loadHwModule() init check error %d for module %s ", rc, name);
1487        return 0;
1488    }
1489
1490    // Check and cache this HAL's level of support for master mute and master
1491    // volume.  If this is the first HAL opened, and it supports the get
1492    // methods, use the initial values provided by the HAL as the current
1493    // master mute and volume settings.
1494
1495    AudioHwDevice::Flags flags = static_cast<AudioHwDevice::Flags>(0);
1496    {  // scope for auto-lock pattern
1497        AutoMutex lock(mHardwareLock);
1498
1499        if (0 == mAudioHwDevs.size()) {
1500            mHardwareStatus = AUDIO_HW_GET_MASTER_VOLUME;
1501            if (NULL != dev->get_master_volume) {
1502                float mv;
1503                if (OK == dev->get_master_volume(dev, &mv)) {
1504                    mMasterVolume = mv;
1505                }
1506            }
1507
1508            mHardwareStatus = AUDIO_HW_GET_MASTER_MUTE;
1509            if (NULL != dev->get_master_mute) {
1510                bool mm;
1511                if (OK == dev->get_master_mute(dev, &mm)) {
1512                    mMasterMute = mm;
1513                }
1514            }
1515        }
1516
1517        mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
1518        if ((NULL != dev->set_master_volume) &&
1519            (OK == dev->set_master_volume(dev, mMasterVolume))) {
1520            flags = static_cast<AudioHwDevice::Flags>(flags |
1521                    AudioHwDevice::AHWD_CAN_SET_MASTER_VOLUME);
1522        }
1523
1524        mHardwareStatus = AUDIO_HW_SET_MASTER_MUTE;
1525        if ((NULL != dev->set_master_mute) &&
1526            (OK == dev->set_master_mute(dev, mMasterMute))) {
1527            flags = static_cast<AudioHwDevice::Flags>(flags |
1528                    AudioHwDevice::AHWD_CAN_SET_MASTER_MUTE);
1529        }
1530
1531        mHardwareStatus = AUDIO_HW_IDLE;
1532    }
1533
1534    audio_module_handle_t handle = nextUniqueId();
1535    mAudioHwDevs.add(handle, new AudioHwDevice(name, dev, flags));
1536
1537    ALOGI("loadHwModule() Loaded %s audio interface from %s (%s) handle %d",
1538          name, dev->common.module->name, dev->common.module->id, handle);
1539
1540    return handle;
1541
1542}
1543
1544// ----------------------------------------------------------------------------
1545
1546uint32_t AudioFlinger::getPrimaryOutputSamplingRate()
1547{
1548    Mutex::Autolock _l(mLock);
1549    PlaybackThread *thread = primaryPlaybackThread_l();
1550    return thread != NULL ? thread->sampleRate() : 0;
1551}
1552
1553size_t AudioFlinger::getPrimaryOutputFrameCount()
1554{
1555    Mutex::Autolock _l(mLock);
1556    PlaybackThread *thread = primaryPlaybackThread_l();
1557    return thread != NULL ? thread->frameCountHAL() : 0;
1558}
1559
1560// ----------------------------------------------------------------------------
1561
1562status_t AudioFlinger::setLowRamDevice(bool isLowRamDevice)
1563{
1564    uid_t uid = IPCThreadState::self()->getCallingUid();
1565    if (uid != AID_SYSTEM) {
1566        return PERMISSION_DENIED;
1567    }
1568    Mutex::Autolock _l(mLock);
1569    if (mIsDeviceTypeKnown) {
1570        return INVALID_OPERATION;
1571    }
1572    mIsLowRamDevice = isLowRamDevice;
1573    mIsDeviceTypeKnown = true;
1574    return NO_ERROR;
1575}
1576
1577// ----------------------------------------------------------------------------
1578
1579audio_io_handle_t AudioFlinger::openOutput(audio_module_handle_t module,
1580                                           audio_devices_t *pDevices,
1581                                           uint32_t *pSamplingRate,
1582                                           audio_format_t *pFormat,
1583                                           audio_channel_mask_t *pChannelMask,
1584                                           uint32_t *pLatencyMs,
1585                                           audio_output_flags_t flags,
1586                                           const audio_offload_info_t *offloadInfo)
1587{
1588    struct audio_config config;
1589    memset(&config, 0, sizeof(config));
1590    config.sample_rate = (pSamplingRate != NULL) ? *pSamplingRate : 0;
1591    config.channel_mask = (pChannelMask != NULL) ? *pChannelMask : 0;
1592    config.format = (pFormat != NULL) ? *pFormat : AUDIO_FORMAT_DEFAULT;
1593    if (offloadInfo != NULL) {
1594        config.offload_info = *offloadInfo;
1595    }
1596
1597    ALOGV("openOutput(), module %d Device %x, SamplingRate %d, Format %#08x, Channels %x, flags %x",
1598              module,
1599              (pDevices != NULL) ? *pDevices : 0,
1600              config.sample_rate,
1601              config.format,
1602              config.channel_mask,
1603              flags);
1604    ALOGV("openOutput(), offloadInfo %p version 0x%04x",
1605          offloadInfo, offloadInfo == NULL ? -1 : offloadInfo->version);
1606
1607    if (pDevices == NULL || *pDevices == AUDIO_DEVICE_NONE) {
1608        return AUDIO_IO_HANDLE_NONE;
1609    }
1610
1611    Mutex::Autolock _l(mLock);
1612
1613    AudioHwDevice *outHwDev = findSuitableHwDev_l(module, *pDevices);
1614    if (outHwDev == NULL) {
1615        return AUDIO_IO_HANDLE_NONE;
1616    }
1617
1618    audio_hw_device_t *hwDevHal = outHwDev->hwDevice();
1619    audio_io_handle_t id = nextUniqueId();
1620
1621    mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
1622
1623    audio_stream_out_t *outStream = NULL;
1624
1625    // FOR TESTING ONLY:
1626    // Enable increased sink precision for mixing mode if kEnableExtendedPrecision is true.
1627    if (kEnableExtendedPrecision &&  // Check only for Normal Mixing mode
1628            !(flags & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT))) {
1629        // Update format
1630        //config.format = AUDIO_FORMAT_PCM_FLOAT;
1631        //config.format = AUDIO_FORMAT_PCM_24_BIT_PACKED;
1632        //config.format = AUDIO_FORMAT_PCM_32_BIT;
1633        //config.format = AUDIO_FORMAT_PCM_8_24_BIT;
1634        // ALOGV("openOutput() upgrading format to %#08x", config.format);
1635    }
1636
1637    status_t status = hwDevHal->open_output_stream(hwDevHal,
1638                                          id,
1639                                          *pDevices,
1640                                          (audio_output_flags_t)flags,
1641                                          &config,
1642                                          &outStream);
1643
1644    mHardwareStatus = AUDIO_HW_IDLE;
1645    ALOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %#08x, "
1646            "Channels %x, status %d",
1647            outStream,
1648            config.sample_rate,
1649            config.format,
1650            config.channel_mask,
1651            status);
1652
1653    if (status == NO_ERROR && outStream != NULL) {
1654        AudioStreamOut *output = new AudioStreamOut(outHwDev, outStream, flags);
1655
1656        PlaybackThread *thread;
1657        if (flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) {
1658            thread = new OffloadThread(this, output, id, *pDevices);
1659            ALOGV("openOutput() created offload output: ID %d thread %p", id, thread);
1660        } else if ((flags & AUDIO_OUTPUT_FLAG_DIRECT)
1661                || !isValidPcmSinkFormat(config.format)
1662                || (config.channel_mask != AUDIO_CHANNEL_OUT_STEREO)) {
1663            thread = new DirectOutputThread(this, output, id, *pDevices);
1664            ALOGV("openOutput() created direct output: ID %d thread %p", id, thread);
1665        } else {
1666            thread = new MixerThread(this, output, id, *pDevices);
1667            ALOGV("openOutput() created mixer output: ID %d thread %p", id, thread);
1668        }
1669        mPlaybackThreads.add(id, thread);
1670
1671        if (pSamplingRate != NULL) {
1672            *pSamplingRate = config.sample_rate;
1673        }
1674        if (pFormat != NULL) {
1675            *pFormat = config.format;
1676        }
1677        if (pChannelMask != NULL) {
1678            *pChannelMask = config.channel_mask;
1679        }
1680        if (pLatencyMs != NULL) {
1681            *pLatencyMs = thread->latency();
1682        }
1683
1684        // notify client processes of the new output creation
1685        thread->audioConfigChanged(AudioSystem::OUTPUT_OPENED);
1686
1687        // the first primary output opened designates the primary hw device
1688        if ((mPrimaryHardwareDev == NULL) && (flags & AUDIO_OUTPUT_FLAG_PRIMARY)) {
1689            ALOGI("Using module %d has the primary audio interface", module);
1690            mPrimaryHardwareDev = outHwDev;
1691
1692            AutoMutex lock(mHardwareLock);
1693            mHardwareStatus = AUDIO_HW_SET_MODE;
1694            hwDevHal->set_mode(hwDevHal, mMode);
1695            mHardwareStatus = AUDIO_HW_IDLE;
1696
1697            mPrimaryOutputSampleRate = config.sample_rate;
1698        }
1699        return id;
1700    }
1701
1702    return AUDIO_IO_HANDLE_NONE;
1703}
1704
1705audio_io_handle_t AudioFlinger::openDuplicateOutput(audio_io_handle_t output1,
1706        audio_io_handle_t output2)
1707{
1708    Mutex::Autolock _l(mLock);
1709    MixerThread *thread1 = checkMixerThread_l(output1);
1710    MixerThread *thread2 = checkMixerThread_l(output2);
1711
1712    if (thread1 == NULL || thread2 == NULL) {
1713        ALOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1,
1714                output2);
1715        return AUDIO_IO_HANDLE_NONE;
1716    }
1717
1718    audio_io_handle_t id = nextUniqueId();
1719    DuplicatingThread *thread = new DuplicatingThread(this, thread1, id);
1720    thread->addOutputTrack(thread2);
1721    mPlaybackThreads.add(id, thread);
1722    // notify client processes of the new output creation
1723    thread->audioConfigChanged(AudioSystem::OUTPUT_OPENED);
1724    return id;
1725}
1726
1727status_t AudioFlinger::closeOutput(audio_io_handle_t output)
1728{
1729    return closeOutput_nonvirtual(output);
1730}
1731
1732status_t AudioFlinger::closeOutput_nonvirtual(audio_io_handle_t output)
1733{
1734    // keep strong reference on the playback thread so that
1735    // it is not destroyed while exit() is executed
1736    sp<PlaybackThread> thread;
1737    {
1738        Mutex::Autolock _l(mLock);
1739        thread = checkPlaybackThread_l(output);
1740        if (thread == NULL) {
1741            return BAD_VALUE;
1742        }
1743
1744        ALOGV("closeOutput() %d", output);
1745
1746        if (thread->type() == ThreadBase::MIXER) {
1747            for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
1748                if (mPlaybackThreads.valueAt(i)->type() == ThreadBase::DUPLICATING) {
1749                    DuplicatingThread *dupThread =
1750                            (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
1751                    dupThread->removeOutputTrack((MixerThread *)thread.get());
1752
1753                }
1754            }
1755        }
1756
1757
1758        mPlaybackThreads.removeItem(output);
1759        // save all effects to the default thread
1760        if (mPlaybackThreads.size()) {
1761            PlaybackThread *dstThread = checkPlaybackThread_l(mPlaybackThreads.keyAt(0));
1762            if (dstThread != NULL) {
1763                // audioflinger lock is held here so the acquisition order of thread locks does not
1764                // matter
1765                Mutex::Autolock _dl(dstThread->mLock);
1766                Mutex::Autolock _sl(thread->mLock);
1767                Vector< sp<EffectChain> > effectChains = thread->getEffectChains_l();
1768                for (size_t i = 0; i < effectChains.size(); i ++) {
1769                    moveEffectChain_l(effectChains[i]->sessionId(), thread.get(), dstThread, true);
1770                }
1771            }
1772        }
1773        audioConfigChanged(AudioSystem::OUTPUT_CLOSED, output, NULL);
1774    }
1775    thread->exit();
1776    // The thread entity (active unit of execution) is no longer running here,
1777    // but the ThreadBase container still exists.
1778
1779    if (thread->type() != ThreadBase::DUPLICATING) {
1780        AudioStreamOut *out = thread->clearOutput();
1781        ALOG_ASSERT(out != NULL, "out shouldn't be NULL");
1782        // from now on thread->mOutput is NULL
1783        out->hwDev()->close_output_stream(out->hwDev(), out->stream);
1784        delete out;
1785    }
1786    return NO_ERROR;
1787}
1788
1789status_t AudioFlinger::suspendOutput(audio_io_handle_t output)
1790{
1791    Mutex::Autolock _l(mLock);
1792    PlaybackThread *thread = checkPlaybackThread_l(output);
1793
1794    if (thread == NULL) {
1795        return BAD_VALUE;
1796    }
1797
1798    ALOGV("suspendOutput() %d", output);
1799    thread->suspend();
1800
1801    return NO_ERROR;
1802}
1803
1804status_t AudioFlinger::restoreOutput(audio_io_handle_t output)
1805{
1806    Mutex::Autolock _l(mLock);
1807    PlaybackThread *thread = checkPlaybackThread_l(output);
1808
1809    if (thread == NULL) {
1810        return BAD_VALUE;
1811    }
1812
1813    ALOGV("restoreOutput() %d", output);
1814
1815    thread->restore();
1816
1817    return NO_ERROR;
1818}
1819
1820audio_io_handle_t AudioFlinger::openInput(audio_module_handle_t module,
1821                                          audio_devices_t *pDevices,
1822                                          uint32_t *pSamplingRate,
1823                                          audio_format_t *pFormat,
1824                                          audio_channel_mask_t *pChannelMask)
1825{
1826    struct audio_config config;
1827    memset(&config, 0, sizeof(config));
1828    config.sample_rate = (pSamplingRate != NULL) ? *pSamplingRate : 0;
1829    config.channel_mask = (pChannelMask != NULL) ? *pChannelMask : 0;
1830    config.format = (pFormat != NULL) ? *pFormat : AUDIO_FORMAT_DEFAULT;
1831
1832    uint32_t reqSamplingRate = config.sample_rate;
1833    audio_format_t reqFormat = config.format;
1834    audio_channel_mask_t reqChannelMask = config.channel_mask;
1835
1836    if (pDevices == NULL || *pDevices == AUDIO_DEVICE_NONE) {
1837        return 0;
1838    }
1839
1840    Mutex::Autolock _l(mLock);
1841
1842    AudioHwDevice *inHwDev = findSuitableHwDev_l(module, *pDevices);
1843    if (inHwDev == NULL) {
1844        return 0;
1845    }
1846
1847    audio_hw_device_t *inHwHal = inHwDev->hwDevice();
1848    audio_io_handle_t id = nextUniqueId();
1849
1850    audio_stream_in_t *inStream = NULL;
1851    status_t status = inHwHal->open_input_stream(inHwHal, id, *pDevices, &config,
1852                                        &inStream);
1853    ALOGV("openInput() openInputStream returned input %p, SamplingRate %d, Format %#x, Channels %x, "
1854            "status %d",
1855            inStream,
1856            config.sample_rate,
1857            config.format,
1858            config.channel_mask,
1859            status);
1860
1861    // If the input could not be opened with the requested parameters and we can handle the
1862    // conversion internally, try to open again with the proposed parameters. The AudioFlinger can
1863    // resample the input and do mono to stereo or stereo to mono conversions on 16 bit PCM inputs.
1864    if (status == BAD_VALUE &&
1865        reqFormat == config.format && config.format == AUDIO_FORMAT_PCM_16_BIT &&
1866        (config.sample_rate <= 2 * reqSamplingRate) &&
1867        (audio_channel_count_from_in_mask(config.channel_mask) <= FCC_2) &&
1868        (audio_channel_count_from_in_mask(reqChannelMask) <= FCC_2)) {
1869        // FIXME describe the change proposed by HAL (save old values so we can log them here)
1870        ALOGV("openInput() reopening with proposed sampling rate and channel mask");
1871        inStream = NULL;
1872        status = inHwHal->open_input_stream(inHwHal, id, *pDevices, &config, &inStream);
1873        // FIXME log this new status; HAL should not propose any further changes
1874    }
1875
1876    if (status == NO_ERROR && inStream != NULL) {
1877
1878#ifdef TEE_SINK
1879        // Try to re-use most recently used Pipe to archive a copy of input for dumpsys,
1880        // or (re-)create if current Pipe is idle and does not match the new format
1881        sp<NBAIO_Sink> teeSink;
1882        enum {
1883            TEE_SINK_NO,    // don't copy input
1884            TEE_SINK_NEW,   // copy input using a new pipe
1885            TEE_SINK_OLD,   // copy input using an existing pipe
1886        } kind;
1887        NBAIO_Format format = Format_from_SR_C(inStream->common.get_sample_rate(&inStream->common),
1888                audio_channel_count_from_in_mask(
1889                        inStream->common.get_channels(&inStream->common)));
1890        if (!mTeeSinkInputEnabled) {
1891            kind = TEE_SINK_NO;
1892        } else if (!Format_isValid(format)) {
1893            kind = TEE_SINK_NO;
1894        } else if (mRecordTeeSink == 0) {
1895            kind = TEE_SINK_NEW;
1896        } else if (mRecordTeeSink->getStrongCount() != 1) {
1897            kind = TEE_SINK_NO;
1898        } else if (Format_isEqual(format, mRecordTeeSink->format())) {
1899            kind = TEE_SINK_OLD;
1900        } else {
1901            kind = TEE_SINK_NEW;
1902        }
1903        switch (kind) {
1904        case TEE_SINK_NEW: {
1905            Pipe *pipe = new Pipe(mTeeSinkInputFrames, format);
1906            size_t numCounterOffers = 0;
1907            const NBAIO_Format offers[1] = {format};
1908            ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers);
1909            ALOG_ASSERT(index == 0);
1910            PipeReader *pipeReader = new PipeReader(*pipe);
1911            numCounterOffers = 0;
1912            index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers);
1913            ALOG_ASSERT(index == 0);
1914            mRecordTeeSink = pipe;
1915            mRecordTeeSource = pipeReader;
1916            teeSink = pipe;
1917            }
1918            break;
1919        case TEE_SINK_OLD:
1920            teeSink = mRecordTeeSink;
1921            break;
1922        case TEE_SINK_NO:
1923        default:
1924            break;
1925        }
1926#endif
1927
1928        AudioStreamIn *input = new AudioStreamIn(inHwDev, inStream);
1929
1930        // Start record thread
1931        // RecordThread requires both input and output device indication to forward to audio
1932        // pre processing modules
1933        RecordThread *thread = new RecordThread(this,
1934                                  input,
1935                                  id,
1936                                  primaryOutputDevice_l(),
1937                                  *pDevices
1938#ifdef TEE_SINK
1939                                  , teeSink
1940#endif
1941                                  );
1942        mRecordThreads.add(id, thread);
1943        ALOGV("openInput() created record thread: ID %d thread %p", id, thread);
1944        if (pSamplingRate != NULL) {
1945            *pSamplingRate = reqSamplingRate;
1946        }
1947        if (pFormat != NULL) {
1948            *pFormat = config.format;
1949        }
1950        if (pChannelMask != NULL) {
1951            *pChannelMask = reqChannelMask;
1952        }
1953
1954        // notify client processes of the new input creation
1955        thread->audioConfigChanged(AudioSystem::INPUT_OPENED);
1956        return id;
1957    }
1958
1959    return 0;
1960}
1961
1962status_t AudioFlinger::closeInput(audio_io_handle_t input)
1963{
1964    return closeInput_nonvirtual(input);
1965}
1966
1967status_t AudioFlinger::closeInput_nonvirtual(audio_io_handle_t input)
1968{
1969    // keep strong reference on the record thread so that
1970    // it is not destroyed while exit() is executed
1971    sp<RecordThread> thread;
1972    {
1973        Mutex::Autolock _l(mLock);
1974        thread = checkRecordThread_l(input);
1975        if (thread == 0) {
1976            return BAD_VALUE;
1977        }
1978
1979        ALOGV("closeInput() %d", input);
1980        audioConfigChanged(AudioSystem::INPUT_CLOSED, input, NULL);
1981        mRecordThreads.removeItem(input);
1982    }
1983    thread->exit();
1984    // The thread entity (active unit of execution) is no longer running here,
1985    // but the ThreadBase container still exists.
1986
1987    AudioStreamIn *in = thread->clearInput();
1988    ALOG_ASSERT(in != NULL, "in shouldn't be NULL");
1989    // from now on thread->mInput is NULL
1990    in->hwDev()->close_input_stream(in->hwDev(), in->stream);
1991    delete in;
1992
1993    return NO_ERROR;
1994}
1995
1996status_t AudioFlinger::invalidateStream(audio_stream_type_t stream)
1997{
1998    Mutex::Autolock _l(mLock);
1999    ALOGV("invalidateStream() stream %d", stream);
2000
2001    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2002        PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
2003        thread->invalidateTracks(stream);
2004    }
2005
2006    return NO_ERROR;
2007}
2008
2009
2010int AudioFlinger::newAudioSessionId()
2011{
2012    return nextUniqueId();
2013}
2014
2015void AudioFlinger::acquireAudioSessionId(int audioSession, pid_t pid)
2016{
2017    Mutex::Autolock _l(mLock);
2018    pid_t caller = IPCThreadState::self()->getCallingPid();
2019    ALOGV("acquiring %d from %d, for %d", audioSession, caller, pid);
2020    if (pid != -1 && (caller == getpid_cached)) {
2021        caller = pid;
2022    }
2023
2024    {
2025        Mutex::Autolock _cl(mClientLock);
2026        // Ignore requests received from processes not known as notification client. The request
2027        // is likely proxied by mediaserver (e.g CameraService) and releaseAudioSessionId() can be
2028        // called from a different pid leaving a stale session reference.  Also we don't know how
2029        // to clear this reference if the client process dies.
2030        if (mNotificationClients.indexOfKey(caller) < 0) {
2031            ALOGW("acquireAudioSessionId() unknown client %d for session %d", caller, audioSession);
2032            return;
2033        }
2034    }
2035
2036    size_t num = mAudioSessionRefs.size();
2037    for (size_t i = 0; i< num; i++) {
2038        AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i);
2039        if (ref->mSessionid == audioSession && ref->mPid == caller) {
2040            ref->mCnt++;
2041            ALOGV(" incremented refcount to %d", ref->mCnt);
2042            return;
2043        }
2044    }
2045    mAudioSessionRefs.push(new AudioSessionRef(audioSession, caller));
2046    ALOGV(" added new entry for %d", audioSession);
2047}
2048
2049void AudioFlinger::releaseAudioSessionId(int audioSession, pid_t pid)
2050{
2051    Mutex::Autolock _l(mLock);
2052    pid_t caller = IPCThreadState::self()->getCallingPid();
2053    ALOGV("releasing %d from %d for %d", audioSession, caller, pid);
2054    if (pid != -1 && (caller == getpid_cached)) {
2055        caller = pid;
2056    }
2057    size_t num = mAudioSessionRefs.size();
2058    for (size_t i = 0; i< num; i++) {
2059        AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
2060        if (ref->mSessionid == audioSession && ref->mPid == caller) {
2061            ref->mCnt--;
2062            ALOGV(" decremented refcount to %d", ref->mCnt);
2063            if (ref->mCnt == 0) {
2064                mAudioSessionRefs.removeAt(i);
2065                delete ref;
2066                purgeStaleEffects_l();
2067            }
2068            return;
2069        }
2070    }
2071    // If the caller is mediaserver it is likely that the session being released was acquired
2072    // on behalf of a process not in notification clients and we ignore the warning.
2073    ALOGW_IF(caller != getpid_cached, "session id %d not found for pid %d", audioSession, caller);
2074}
2075
2076void AudioFlinger::purgeStaleEffects_l() {
2077
2078    ALOGV("purging stale effects");
2079
2080    Vector< sp<EffectChain> > chains;
2081
2082    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2083        sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
2084        for (size_t j = 0; j < t->mEffectChains.size(); j++) {
2085            sp<EffectChain> ec = t->mEffectChains[j];
2086            if (ec->sessionId() > AUDIO_SESSION_OUTPUT_MIX) {
2087                chains.push(ec);
2088            }
2089        }
2090    }
2091    for (size_t i = 0; i < mRecordThreads.size(); i++) {
2092        sp<RecordThread> t = mRecordThreads.valueAt(i);
2093        for (size_t j = 0; j < t->mEffectChains.size(); j++) {
2094            sp<EffectChain> ec = t->mEffectChains[j];
2095            chains.push(ec);
2096        }
2097    }
2098
2099    for (size_t i = 0; i < chains.size(); i++) {
2100        sp<EffectChain> ec = chains[i];
2101        int sessionid = ec->sessionId();
2102        sp<ThreadBase> t = ec->mThread.promote();
2103        if (t == 0) {
2104            continue;
2105        }
2106        size_t numsessionrefs = mAudioSessionRefs.size();
2107        bool found = false;
2108        for (size_t k = 0; k < numsessionrefs; k++) {
2109            AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
2110            if (ref->mSessionid == sessionid) {
2111                ALOGV(" session %d still exists for %d with %d refs",
2112                    sessionid, ref->mPid, ref->mCnt);
2113                found = true;
2114                break;
2115            }
2116        }
2117        if (!found) {
2118            Mutex::Autolock _l(t->mLock);
2119            // remove all effects from the chain
2120            while (ec->mEffects.size()) {
2121                sp<EffectModule> effect = ec->mEffects[0];
2122                effect->unPin();
2123                t->removeEffect_l(effect);
2124                if (effect->purgeHandles()) {
2125                    t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId());
2126                }
2127                AudioSystem::unregisterEffect(effect->id());
2128            }
2129        }
2130    }
2131    return;
2132}
2133
2134// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
2135AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(audio_io_handle_t output) const
2136{
2137    return mPlaybackThreads.valueFor(output).get();
2138}
2139
2140// checkMixerThread_l() must be called with AudioFlinger::mLock held
2141AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(audio_io_handle_t output) const
2142{
2143    PlaybackThread *thread = checkPlaybackThread_l(output);
2144    return thread != NULL && thread->type() != ThreadBase::DIRECT ? (MixerThread *) thread : NULL;
2145}
2146
2147// checkRecordThread_l() must be called with AudioFlinger::mLock held
2148AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(audio_io_handle_t input) const
2149{
2150    return mRecordThreads.valueFor(input).get();
2151}
2152
2153uint32_t AudioFlinger::nextUniqueId()
2154{
2155    return (uint32_t) android_atomic_inc(&mNextUniqueId);
2156}
2157
2158AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l() const
2159{
2160    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2161        PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
2162        AudioStreamOut *output = thread->getOutput();
2163        if (output != NULL && output->audioHwDev == mPrimaryHardwareDev) {
2164            return thread;
2165        }
2166    }
2167    return NULL;
2168}
2169
2170audio_devices_t AudioFlinger::primaryOutputDevice_l() const
2171{
2172    PlaybackThread *thread = primaryPlaybackThread_l();
2173
2174    if (thread == NULL) {
2175        return 0;
2176    }
2177
2178    return thread->outDevice();
2179}
2180
2181sp<AudioFlinger::SyncEvent> AudioFlinger::createSyncEvent(AudioSystem::sync_event_t type,
2182                                    int triggerSession,
2183                                    int listenerSession,
2184                                    sync_event_callback_t callBack,
2185                                    wp<RefBase> cookie)
2186{
2187    Mutex::Autolock _l(mLock);
2188
2189    sp<SyncEvent> event = new SyncEvent(type, triggerSession, listenerSession, callBack, cookie);
2190    status_t playStatus = NAME_NOT_FOUND;
2191    status_t recStatus = NAME_NOT_FOUND;
2192    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2193        playStatus = mPlaybackThreads.valueAt(i)->setSyncEvent(event);
2194        if (playStatus == NO_ERROR) {
2195            return event;
2196        }
2197    }
2198    for (size_t i = 0; i < mRecordThreads.size(); i++) {
2199        recStatus = mRecordThreads.valueAt(i)->setSyncEvent(event);
2200        if (recStatus == NO_ERROR) {
2201            return event;
2202        }
2203    }
2204    if (playStatus == NAME_NOT_FOUND || recStatus == NAME_NOT_FOUND) {
2205        mPendingSyncEvents.add(event);
2206    } else {
2207        ALOGV("createSyncEvent() invalid event %d", event->type());
2208        event.clear();
2209    }
2210    return event;
2211}
2212
2213// ----------------------------------------------------------------------------
2214//  Effect management
2215// ----------------------------------------------------------------------------
2216
2217
2218status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects) const
2219{
2220    Mutex::Autolock _l(mLock);
2221    return EffectQueryNumberEffects(numEffects);
2222}
2223
2224status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor) const
2225{
2226    Mutex::Autolock _l(mLock);
2227    return EffectQueryEffect(index, descriptor);
2228}
2229
2230status_t AudioFlinger::getEffectDescriptor(const effect_uuid_t *pUuid,
2231        effect_descriptor_t *descriptor) const
2232{
2233    Mutex::Autolock _l(mLock);
2234    return EffectGetDescriptor(pUuid, descriptor);
2235}
2236
2237
2238sp<IEffect> AudioFlinger::createEffect(
2239        effect_descriptor_t *pDesc,
2240        const sp<IEffectClient>& effectClient,
2241        int32_t priority,
2242        audio_io_handle_t io,
2243        int sessionId,
2244        status_t *status,
2245        int *id,
2246        int *enabled)
2247{
2248    status_t lStatus = NO_ERROR;
2249    sp<EffectHandle> handle;
2250    effect_descriptor_t desc;
2251
2252    pid_t pid = IPCThreadState::self()->getCallingPid();
2253    ALOGV("createEffect pid %d, effectClient %p, priority %d, sessionId %d, io %d",
2254            pid, effectClient.get(), priority, sessionId, io);
2255
2256    if (pDesc == NULL) {
2257        lStatus = BAD_VALUE;
2258        goto Exit;
2259    }
2260
2261    // check audio settings permission for global effects
2262    if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) {
2263        lStatus = PERMISSION_DENIED;
2264        goto Exit;
2265    }
2266
2267    // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects
2268    // that can only be created by audio policy manager (running in same process)
2269    if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid_cached != pid) {
2270        lStatus = PERMISSION_DENIED;
2271        goto Exit;
2272    }
2273
2274    {
2275        if (!EffectIsNullUuid(&pDesc->uuid)) {
2276            // if uuid is specified, request effect descriptor
2277            lStatus = EffectGetDescriptor(&pDesc->uuid, &desc);
2278            if (lStatus < 0) {
2279                ALOGW("createEffect() error %d from EffectGetDescriptor", lStatus);
2280                goto Exit;
2281            }
2282        } else {
2283            // if uuid is not specified, look for an available implementation
2284            // of the required type in effect factory
2285            if (EffectIsNullUuid(&pDesc->type)) {
2286                ALOGW("createEffect() no effect type");
2287                lStatus = BAD_VALUE;
2288                goto Exit;
2289            }
2290            uint32_t numEffects = 0;
2291            effect_descriptor_t d;
2292            d.flags = 0; // prevent compiler warning
2293            bool found = false;
2294
2295            lStatus = EffectQueryNumberEffects(&numEffects);
2296            if (lStatus < 0) {
2297                ALOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus);
2298                goto Exit;
2299            }
2300            for (uint32_t i = 0; i < numEffects; i++) {
2301                lStatus = EffectQueryEffect(i, &desc);
2302                if (lStatus < 0) {
2303                    ALOGW("createEffect() error %d from EffectQueryEffect", lStatus);
2304                    continue;
2305                }
2306                if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) {
2307                    // If matching type found save effect descriptor. If the session is
2308                    // 0 and the effect is not auxiliary, continue enumeration in case
2309                    // an auxiliary version of this effect type is available
2310                    found = true;
2311                    d = desc;
2312                    if (sessionId != AUDIO_SESSION_OUTPUT_MIX ||
2313                            (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2314                        break;
2315                    }
2316                }
2317            }
2318            if (!found) {
2319                lStatus = BAD_VALUE;
2320                ALOGW("createEffect() effect not found");
2321                goto Exit;
2322            }
2323            // For same effect type, chose auxiliary version over insert version if
2324            // connect to output mix (Compliance to OpenSL ES)
2325            if (sessionId == AUDIO_SESSION_OUTPUT_MIX &&
2326                    (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
2327                desc = d;
2328            }
2329        }
2330
2331        // Do not allow auxiliary effects on a session different from 0 (output mix)
2332        if (sessionId != AUDIO_SESSION_OUTPUT_MIX &&
2333             (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2334            lStatus = INVALID_OPERATION;
2335            goto Exit;
2336        }
2337
2338        // check recording permission for visualizer
2339        if ((memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
2340            !recordingAllowed()) {
2341            lStatus = PERMISSION_DENIED;
2342            goto Exit;
2343        }
2344
2345        // return effect descriptor
2346        *pDesc = desc;
2347        if (io == AUDIO_IO_HANDLE_NONE && sessionId == AUDIO_SESSION_OUTPUT_MIX) {
2348            // if the output returned by getOutputForEffect() is removed before we lock the
2349            // mutex below, the call to checkPlaybackThread_l(io) below will detect it
2350            // and we will exit safely
2351            io = AudioSystem::getOutputForEffect(&desc);
2352            ALOGV("createEffect got output %d", io);
2353        }
2354
2355        Mutex::Autolock _l(mLock);
2356
2357        // If output is not specified try to find a matching audio session ID in one of the
2358        // output threads.
2359        // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
2360        // because of code checking output when entering the function.
2361        // Note: io is never 0 when creating an effect on an input
2362        if (io == AUDIO_IO_HANDLE_NONE) {
2363            if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
2364                // output must be specified by AudioPolicyManager when using session
2365                // AUDIO_SESSION_OUTPUT_STAGE
2366                lStatus = BAD_VALUE;
2367                goto Exit;
2368            }
2369            // look for the thread where the specified audio session is present
2370            for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2371                if (mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
2372                    io = mPlaybackThreads.keyAt(i);
2373                    break;
2374                }
2375            }
2376            if (io == 0) {
2377                for (size_t i = 0; i < mRecordThreads.size(); i++) {
2378                    if (mRecordThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
2379                        io = mRecordThreads.keyAt(i);
2380                        break;
2381                    }
2382                }
2383            }
2384            // If no output thread contains the requested session ID, default to
2385            // first output. The effect chain will be moved to the correct output
2386            // thread when a track with the same session ID is created
2387            if (io == AUDIO_IO_HANDLE_NONE && mPlaybackThreads.size() > 0) {
2388                io = mPlaybackThreads.keyAt(0);
2389            }
2390            ALOGV("createEffect() got io %d for effect %s", io, desc.name);
2391        }
2392        ThreadBase *thread = checkRecordThread_l(io);
2393        if (thread == NULL) {
2394            thread = checkPlaybackThread_l(io);
2395            if (thread == NULL) {
2396                ALOGE("createEffect() unknown output thread");
2397                lStatus = BAD_VALUE;
2398                goto Exit;
2399            }
2400        }
2401
2402        sp<Client> client = registerPid(pid);
2403
2404        // create effect on selected output thread
2405        handle = thread->createEffect_l(client, effectClient, priority, sessionId,
2406                &desc, enabled, &lStatus);
2407        if (handle != 0 && id != NULL) {
2408            *id = handle->id();
2409        }
2410        if (handle == 0) {
2411            // remove local strong reference to Client with mClientLock held
2412            Mutex::Autolock _cl(mClientLock);
2413            client.clear();
2414        }
2415    }
2416
2417Exit:
2418    *status = lStatus;
2419    return handle;
2420}
2421
2422status_t AudioFlinger::moveEffects(int sessionId, audio_io_handle_t srcOutput,
2423        audio_io_handle_t dstOutput)
2424{
2425    ALOGV("moveEffects() session %d, srcOutput %d, dstOutput %d",
2426            sessionId, srcOutput, dstOutput);
2427    Mutex::Autolock _l(mLock);
2428    if (srcOutput == dstOutput) {
2429        ALOGW("moveEffects() same dst and src outputs %d", dstOutput);
2430        return NO_ERROR;
2431    }
2432    PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput);
2433    if (srcThread == NULL) {
2434        ALOGW("moveEffects() bad srcOutput %d", srcOutput);
2435        return BAD_VALUE;
2436    }
2437    PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput);
2438    if (dstThread == NULL) {
2439        ALOGW("moveEffects() bad dstOutput %d", dstOutput);
2440        return BAD_VALUE;
2441    }
2442
2443    Mutex::Autolock _dl(dstThread->mLock);
2444    Mutex::Autolock _sl(srcThread->mLock);
2445    return moveEffectChain_l(sessionId, srcThread, dstThread, false);
2446}
2447
2448// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
2449status_t AudioFlinger::moveEffectChain_l(int sessionId,
2450                                   AudioFlinger::PlaybackThread *srcThread,
2451                                   AudioFlinger::PlaybackThread *dstThread,
2452                                   bool reRegister)
2453{
2454    ALOGV("moveEffectChain_l() session %d from thread %p to thread %p",
2455            sessionId, srcThread, dstThread);
2456
2457    sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId);
2458    if (chain == 0) {
2459        ALOGW("moveEffectChain_l() effect chain for session %d not on source thread %p",
2460                sessionId, srcThread);
2461        return INVALID_OPERATION;
2462    }
2463
2464    // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
2465    // so that a new chain is created with correct parameters when first effect is added. This is
2466    // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is
2467    // removed.
2468    srcThread->removeEffectChain_l(chain);
2469
2470    // transfer all effects one by one so that new effect chain is created on new thread with
2471    // correct buffer sizes and audio parameters and effect engines reconfigured accordingly
2472    sp<EffectChain> dstChain;
2473    uint32_t strategy = 0; // prevent compiler warning
2474    sp<EffectModule> effect = chain->getEffectFromId_l(0);
2475    Vector< sp<EffectModule> > removed;
2476    status_t status = NO_ERROR;
2477    while (effect != 0) {
2478        srcThread->removeEffect_l(effect);
2479        removed.add(effect);
2480        status = dstThread->addEffect_l(effect);
2481        if (status != NO_ERROR) {
2482            break;
2483        }
2484        // removeEffect_l() has stopped the effect if it was active so it must be restarted
2485        if (effect->state() == EffectModule::ACTIVE ||
2486                effect->state() == EffectModule::STOPPING) {
2487            effect->start();
2488        }
2489        // if the move request is not received from audio policy manager, the effect must be
2490        // re-registered with the new strategy and output
2491        if (dstChain == 0) {
2492            dstChain = effect->chain().promote();
2493            if (dstChain == 0) {
2494                ALOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get());
2495                status = NO_INIT;
2496                break;
2497            }
2498            strategy = dstChain->strategy();
2499        }
2500        if (reRegister) {
2501            AudioSystem::unregisterEffect(effect->id());
2502            AudioSystem::registerEffect(&effect->desc(),
2503                                        dstThread->id(),
2504                                        strategy,
2505                                        sessionId,
2506                                        effect->id());
2507            AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled());
2508        }
2509        effect = chain->getEffectFromId_l(0);
2510    }
2511
2512    if (status != NO_ERROR) {
2513        for (size_t i = 0; i < removed.size(); i++) {
2514            srcThread->addEffect_l(removed[i]);
2515            if (dstChain != 0 && reRegister) {
2516                AudioSystem::unregisterEffect(removed[i]->id());
2517                AudioSystem::registerEffect(&removed[i]->desc(),
2518                                            srcThread->id(),
2519                                            strategy,
2520                                            sessionId,
2521                                            removed[i]->id());
2522                AudioSystem::setEffectEnabled(effect->id(), effect->isEnabled());
2523            }
2524        }
2525    }
2526
2527    return status;
2528}
2529
2530bool AudioFlinger::isNonOffloadableGlobalEffectEnabled_l()
2531{
2532    if (mGlobalEffectEnableTime != 0 &&
2533            ((systemTime() - mGlobalEffectEnableTime) < kMinGlobalEffectEnabletimeNs)) {
2534        return true;
2535    }
2536
2537    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2538        sp<EffectChain> ec =
2539                mPlaybackThreads.valueAt(i)->getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
2540        if (ec != 0 && ec->isNonOffloadableEnabled()) {
2541            return true;
2542        }
2543    }
2544    return false;
2545}
2546
2547void AudioFlinger::onNonOffloadableGlobalEffectEnable()
2548{
2549    Mutex::Autolock _l(mLock);
2550
2551    mGlobalEffectEnableTime = systemTime();
2552
2553    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
2554        sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
2555        if (t->mType == ThreadBase::OFFLOAD) {
2556            t->invalidateTracks(AUDIO_STREAM_MUSIC);
2557        }
2558    }
2559
2560}
2561
2562struct Entry {
2563#define MAX_NAME 32     // %Y%m%d%H%M%S_%d.wav
2564    char mName[MAX_NAME];
2565};
2566
2567int comparEntry(const void *p1, const void *p2)
2568{
2569    return strcmp(((const Entry *) p1)->mName, ((const Entry *) p2)->mName);
2570}
2571
2572#ifdef TEE_SINK
2573void AudioFlinger::dumpTee(int fd, const sp<NBAIO_Source>& source, audio_io_handle_t id)
2574{
2575    NBAIO_Source *teeSource = source.get();
2576    if (teeSource != NULL) {
2577        // .wav rotation
2578        // There is a benign race condition if 2 threads call this simultaneously.
2579        // They would both traverse the directory, but the result would simply be
2580        // failures at unlink() which are ignored.  It's also unlikely since
2581        // normally dumpsys is only done by bugreport or from the command line.
2582        char teePath[32+256];
2583        strcpy(teePath, "/data/misc/media");
2584        size_t teePathLen = strlen(teePath);
2585        DIR *dir = opendir(teePath);
2586        teePath[teePathLen++] = '/';
2587        if (dir != NULL) {
2588#define MAX_SORT 20 // number of entries to sort
2589#define MAX_KEEP 10 // number of entries to keep
2590            struct Entry entries[MAX_SORT];
2591            size_t entryCount = 0;
2592            while (entryCount < MAX_SORT) {
2593                struct dirent de;
2594                struct dirent *result = NULL;
2595                int rc = readdir_r(dir, &de, &result);
2596                if (rc != 0) {
2597                    ALOGW("readdir_r failed %d", rc);
2598                    break;
2599                }
2600                if (result == NULL) {
2601                    break;
2602                }
2603                if (result != &de) {
2604                    ALOGW("readdir_r returned unexpected result %p != %p", result, &de);
2605                    break;
2606                }
2607                // ignore non .wav file entries
2608                size_t nameLen = strlen(de.d_name);
2609                if (nameLen <= 4 || nameLen >= MAX_NAME ||
2610                        strcmp(&de.d_name[nameLen - 4], ".wav")) {
2611                    continue;
2612                }
2613                strcpy(entries[entryCount++].mName, de.d_name);
2614            }
2615            (void) closedir(dir);
2616            if (entryCount > MAX_KEEP) {
2617                qsort(entries, entryCount, sizeof(Entry), comparEntry);
2618                for (size_t i = 0; i < entryCount - MAX_KEEP; ++i) {
2619                    strcpy(&teePath[teePathLen], entries[i].mName);
2620                    (void) unlink(teePath);
2621                }
2622            }
2623        } else {
2624            if (fd >= 0) {
2625                dprintf(fd, "unable to rotate tees in %s: %s\n", teePath, strerror(errno));
2626            }
2627        }
2628        char teeTime[16];
2629        struct timeval tv;
2630        gettimeofday(&tv, NULL);
2631        struct tm tm;
2632        localtime_r(&tv.tv_sec, &tm);
2633        strftime(teeTime, sizeof(teeTime), "%Y%m%d%H%M%S", &tm);
2634        snprintf(&teePath[teePathLen], sizeof(teePath) - teePathLen, "%s_%d.wav", teeTime, id);
2635        // if 2 dumpsys are done within 1 second, and rotation didn't work, then discard 2nd
2636        int teeFd = open(teePath, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, S_IRUSR | S_IWUSR);
2637        if (teeFd >= 0) {
2638            char wavHeader[44];
2639            memcpy(wavHeader,
2640                "RIFF\0\0\0\0WAVEfmt \20\0\0\0\1\0\2\0\104\254\0\0\0\0\0\0\4\0\20\0data\0\0\0\0",
2641                sizeof(wavHeader));
2642            NBAIO_Format format = teeSource->format();
2643            unsigned channelCount = Format_channelCount(format);
2644            ALOG_ASSERT(channelCount <= FCC_2);
2645            uint32_t sampleRate = Format_sampleRate(format);
2646            wavHeader[22] = channelCount;       // number of channels
2647            wavHeader[24] = sampleRate;         // sample rate
2648            wavHeader[25] = sampleRate >> 8;
2649            wavHeader[32] = channelCount * 2;   // block alignment
2650            write(teeFd, wavHeader, sizeof(wavHeader));
2651            size_t total = 0;
2652            bool firstRead = true;
2653            for (;;) {
2654#define TEE_SINK_READ 1024
2655                short buffer[TEE_SINK_READ * FCC_2];
2656                size_t count = TEE_SINK_READ;
2657                ssize_t actual = teeSource->read(buffer, count,
2658                        AudioBufferProvider::kInvalidPTS);
2659                bool wasFirstRead = firstRead;
2660                firstRead = false;
2661                if (actual <= 0) {
2662                    if (actual == (ssize_t) OVERRUN && wasFirstRead) {
2663                        continue;
2664                    }
2665                    break;
2666                }
2667                ALOG_ASSERT(actual <= (ssize_t)count);
2668                write(teeFd, buffer, actual * channelCount * sizeof(short));
2669                total += actual;
2670            }
2671            lseek(teeFd, (off_t) 4, SEEK_SET);
2672            uint32_t temp = 44 + total * channelCount * sizeof(short) - 8;
2673            write(teeFd, &temp, sizeof(temp));
2674            lseek(teeFd, (off_t) 40, SEEK_SET);
2675            temp =  total * channelCount * sizeof(short);
2676            write(teeFd, &temp, sizeof(temp));
2677            close(teeFd);
2678            if (fd >= 0) {
2679                dprintf(fd, "tee copied to %s\n", teePath);
2680            }
2681        } else {
2682            if (fd >= 0) {
2683                dprintf(fd, "unable to create tee %s: %s\n", teePath, strerror(errno));
2684            }
2685        }
2686    }
2687}
2688#endif
2689
2690// ----------------------------------------------------------------------------
2691
2692status_t AudioFlinger::onTransact(
2693        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
2694{
2695    return BnAudioFlinger::onTransact(code, data, reply, flags);
2696}
2697
2698}; // namespace android
2699