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