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