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