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