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