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