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