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