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