1/* //device/include/server/AudioFlinger/AudioFlinger.cpp
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 <binder/Parcel.h>
31#include <binder/IPCThreadState.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
39#include <media/AudioTrack.h>
40#include <media/AudioRecord.h>
41#include <media/IMediaPlayerService.h>
42
43#include <private/media/AudioTrackShared.h>
44#include <private/media/AudioEffectShared.h>
45
46#include <system/audio.h>
47#include <hardware/audio.h>
48
49#include "AudioMixer.h"
50#include "AudioFlinger.h"
51
52#include <media/EffectsFactoryApi.h>
53#include <audio_effects/effect_visualizer.h>
54#include <audio_effects/effect_ns.h>
55#include <audio_effects/effect_aec.h>
56
57#include <cpustats/ThreadCpuUsage.h>
58#include <powermanager/PowerManager.h>
59// #define DEBUG_CPU_USAGE 10  // log statistics every n wall clock seconds
60
61// ----------------------------------------------------------------------------
62
63
64namespace android {
65
66static const char* kDeadlockedString = "AudioFlinger may be deadlocked\n";
67static const char* kHardwareLockedString = "Hardware lock is taken\n";
68
69//static const nsecs_t kStandbyTimeInNsecs = seconds(3);
70static const float MAX_GAIN = 4096.0f;
71static const float MAX_GAIN_INT = 0x1000;
72
73// retry counts for buffer fill timeout
74// 50 * ~20msecs = 1 second
75static const int8_t kMaxTrackRetries = 50;
76static const int8_t kMaxTrackStartupRetries = 50;
77// allow less retry attempts on direct output thread.
78// direct outputs can be a scarce resource in audio hardware and should
79// be released as quickly as possible.
80static const int8_t kMaxTrackRetriesDirect = 2;
81
82static const int kDumpLockRetries = 50;
83static const int kDumpLockSleep = 20000;
84
85static const nsecs_t kWarningThrottle = seconds(5);
86
87// RecordThread loop sleep time upon application overrun or audio HAL read error
88static const int kRecordThreadSleepUs = 5000;
89
90static const nsecs_t kSetParametersTimeout = seconds(2);
91
92// minimum sleep time for the mixer thread loop when tracks are active but in underrun
93static const uint32_t kMinThreadSleepTimeUs = 5000;
94// maximum divider applied to the active sleep time in the mixer thread loop
95static const uint32_t kMaxThreadSleepTimeShift = 2;
96
97
98// ----------------------------------------------------------------------------
99
100static bool recordingAllowed() {
101    if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
102    bool ok = checkCallingPermission(String16("android.permission.RECORD_AUDIO"));
103    if (!ok) LOGE("Request requires android.permission.RECORD_AUDIO");
104    return ok;
105}
106
107static bool settingsAllowed() {
108    if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
109    bool ok = checkCallingPermission(String16("android.permission.MODIFY_AUDIO_SETTINGS"));
110    if (!ok) LOGE("Request requires android.permission.MODIFY_AUDIO_SETTINGS");
111    return ok;
112}
113
114// To collect the amplifier usage
115static void addBatteryData(uint32_t params) {
116    sp<IBinder> binder =
117        defaultServiceManager()->getService(String16("media.player"));
118    sp<IMediaPlayerService> service = interface_cast<IMediaPlayerService>(binder);
119    if (service.get() == NULL) {
120        LOGW("Cannot connect to the MediaPlayerService for battery tracking");
121        return;
122    }
123
124    service->addBatteryData(params);
125}
126
127static int load_audio_interface(const char *if_name, const hw_module_t **mod,
128                                audio_hw_device_t **dev)
129{
130    int rc;
131
132    rc = hw_get_module_by_class(AUDIO_HARDWARE_MODULE_ID, if_name, mod);
133    if (rc)
134        goto out;
135
136    rc = audio_hw_device_open(*mod, dev);
137    LOGE_IF(rc, "couldn't open audio hw device in %s.%s (%s)",
138            AUDIO_HARDWARE_MODULE_ID, if_name, strerror(-rc));
139    if (rc)
140        goto out;
141
142    return 0;
143
144out:
145    *mod = NULL;
146    *dev = NULL;
147    return rc;
148}
149
150static const char *audio_interfaces[] = {
151    "primary",
152    "a2dp",
153    "usb",
154};
155#define ARRAY_SIZE(x) (sizeof((x))/sizeof(((x)[0])))
156
157// ----------------------------------------------------------------------------
158
159AudioFlinger::AudioFlinger()
160    : BnAudioFlinger(),
161        mPrimaryHardwareDev(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1),
162        mBtNrecIsOff(false)
163{
164}
165
166void AudioFlinger::onFirstRef()
167{
168    int rc = 0;
169
170    Mutex::Autolock _l(mLock);
171
172    /* TODO: move all this work into an Init() function */
173    mHardwareStatus = AUDIO_HW_IDLE;
174
175    for (size_t i = 0; i < ARRAY_SIZE(audio_interfaces); i++) {
176        const hw_module_t *mod;
177        audio_hw_device_t *dev;
178
179        rc = load_audio_interface(audio_interfaces[i], &mod, &dev);
180        if (rc)
181            continue;
182
183        LOGI("Loaded %s audio interface from %s (%s)", audio_interfaces[i],
184             mod->name, mod->id);
185        mAudioHwDevs.push(dev);
186
187        if (!mPrimaryHardwareDev) {
188            mPrimaryHardwareDev = dev;
189            LOGI("Using '%s' (%s.%s) as the primary audio interface",
190                 mod->name, mod->id, audio_interfaces[i]);
191        }
192    }
193
194    mHardwareStatus = AUDIO_HW_INIT;
195
196    if (!mPrimaryHardwareDev || mAudioHwDevs.size() == 0) {
197        LOGE("Primary audio interface not found");
198        return;
199    }
200
201    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
202        audio_hw_device_t *dev = mAudioHwDevs[i];
203
204        mHardwareStatus = AUDIO_HW_INIT;
205        rc = dev->init_check(dev);
206        if (rc == 0) {
207            AutoMutex lock(mHardwareLock);
208
209            mMode = AUDIO_MODE_NORMAL;
210            mHardwareStatus = AUDIO_HW_SET_MODE;
211            dev->set_mode(dev, mMode);
212            mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
213            dev->set_master_volume(dev, 1.0f);
214            mHardwareStatus = AUDIO_HW_IDLE;
215        }
216    }
217}
218
219status_t AudioFlinger::initCheck() const
220{
221    Mutex::Autolock _l(mLock);
222    if (mPrimaryHardwareDev == NULL || mAudioHwDevs.size() == 0)
223        return NO_INIT;
224    return NO_ERROR;
225}
226
227AudioFlinger::~AudioFlinger()
228{
229    int num_devs = mAudioHwDevs.size();
230
231    while (!mRecordThreads.isEmpty()) {
232        // closeInput() will remove first entry from mRecordThreads
233        closeInput(mRecordThreads.keyAt(0));
234    }
235    while (!mPlaybackThreads.isEmpty()) {
236        // closeOutput() will remove first entry from mPlaybackThreads
237        closeOutput(mPlaybackThreads.keyAt(0));
238    }
239
240    for (int i = 0; i < num_devs; i++) {
241        audio_hw_device_t *dev = mAudioHwDevs[i];
242        audio_hw_device_close(dev);
243    }
244    mAudioHwDevs.clear();
245}
246
247audio_hw_device_t* AudioFlinger::findSuitableHwDev_l(uint32_t devices)
248{
249    /* first matching HW device is returned */
250    for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
251        audio_hw_device_t *dev = mAudioHwDevs[i];
252        if ((dev->get_supported_devices(dev) & devices) == devices)
253            return dev;
254    }
255    return NULL;
256}
257
258status_t AudioFlinger::dumpClients(int fd, const Vector<String16>& args)
259{
260    const size_t SIZE = 256;
261    char buffer[SIZE];
262    String8 result;
263
264    result.append("Clients:\n");
265    for (size_t i = 0; i < mClients.size(); ++i) {
266        wp<Client> wClient = mClients.valueAt(i);
267        if (wClient != 0) {
268            sp<Client> client = wClient.promote();
269            if (client != 0) {
270                snprintf(buffer, SIZE, "  pid: %d\n", client->pid());
271                result.append(buffer);
272            }
273        }
274    }
275
276    result.append("Global session refs:\n");
277    result.append(" session pid cnt\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->sessionid, r->pid, r->cnt);
281        result.append(buffer);
282    }
283    write(fd, result.string(), result.size());
284    return NO_ERROR;
285}
286
287
288status_t AudioFlinger::dumpInternals(int fd, const Vector<String16>& args)
289{
290    const size_t SIZE = 256;
291    char buffer[SIZE];
292    String8 result;
293    int hardwareStatus = mHardwareStatus;
294
295    snprintf(buffer, SIZE, "Hardware status: %d\n", hardwareStatus);
296    result.append(buffer);
297    write(fd, result.string(), result.size());
298    return NO_ERROR;
299}
300
301status_t AudioFlinger::dumpPermissionDenial(int fd, const Vector<String16>& args)
302{
303    const size_t SIZE = 256;
304    char buffer[SIZE];
305    String8 result;
306    snprintf(buffer, SIZE, "Permission Denial: "
307            "can't dump AudioFlinger from pid=%d, uid=%d\n",
308            IPCThreadState::self()->getCallingPid(),
309            IPCThreadState::self()->getCallingUid());
310    result.append(buffer);
311    write(fd, result.string(), result.size());
312    return NO_ERROR;
313}
314
315static bool tryLock(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(kDumpLockSleep);
324    }
325    return locked;
326}
327
328status_t AudioFlinger::dump(int fd, const Vector<String16>& args)
329{
330    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
331        dumpPermissionDenial(fd, args);
332    } else {
333        // get state of hardware lock
334        bool hardwareLocked = tryLock(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 = tryLock(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[i];
366            dev->dump(dev, fd);
367        }
368        if (locked) mLock.unlock();
369    }
370    return NO_ERROR;
371}
372
373
374// IAudioFlinger interface
375
376
377sp<IAudioTrack> AudioFlinger::createTrack(
378        pid_t pid,
379        int streamType,
380        uint32_t sampleRate,
381        uint32_t format,
382        uint32_t channelMask,
383        int frameCount,
384        uint32_t flags,
385        const sp<IMemory>& sharedBuffer,
386        int output,
387        int *sessionId,
388        status_t *status)
389{
390    sp<PlaybackThread::Track> track;
391    sp<TrackHandle> trackHandle;
392    sp<Client> client;
393    wp<Client> wclient;
394    status_t lStatus;
395    int lSessionId;
396
397    if (streamType >= AUDIO_STREAM_CNT) {
398        LOGE("invalid stream type");
399        lStatus = BAD_VALUE;
400        goto Exit;
401    }
402
403    {
404        Mutex::Autolock _l(mLock);
405        PlaybackThread *thread = checkPlaybackThread_l(output);
406        PlaybackThread *effectThread = NULL;
407        if (thread == NULL) {
408            LOGE("unknown output thread");
409            lStatus = BAD_VALUE;
410            goto Exit;
411        }
412
413        wclient = mClients.valueFor(pid);
414
415        if (wclient != NULL) {
416            client = wclient.promote();
417        } else {
418            client = new Client(this, pid);
419            mClients.add(pid, client);
420        }
421
422        LOGV("createTrack() sessionId: %d", (sessionId == NULL) ? -2 : *sessionId);
423        if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) {
424            for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
425                sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
426                if (mPlaybackThreads.keyAt(i) != output) {
427                    // prevent same audio session on different output threads
428                    uint32_t sessions = t->hasAudioSession(*sessionId);
429                    if (sessions & PlaybackThread::TRACK_SESSION) {
430                        lStatus = BAD_VALUE;
431                        goto Exit;
432                    }
433                    // check if an effect with same session ID is waiting for a track to be created
434                    if (sessions & PlaybackThread::EFFECT_SESSION) {
435                        effectThread = t.get();
436                    }
437                }
438            }
439            lSessionId = *sessionId;
440        } else {
441            // if no audio session id is provided, create one here
442            lSessionId = nextUniqueId();
443            if (sessionId != NULL) {
444                *sessionId = lSessionId;
445            }
446        }
447        LOGV("createTrack() lSessionId: %d", lSessionId);
448
449        track = thread->createTrack_l(client, streamType, sampleRate, format,
450                channelMask, frameCount, sharedBuffer, lSessionId, &lStatus);
451
452        // move effect chain to this output thread if an effect on same session was waiting
453        // for a track to be created
454        if (lStatus == NO_ERROR && effectThread != NULL) {
455            Mutex::Autolock _dl(thread->mLock);
456            Mutex::Autolock _sl(effectThread->mLock);
457            moveEffectChain_l(lSessionId, effectThread, thread, true);
458        }
459    }
460    if (lStatus == NO_ERROR) {
461        trackHandle = new TrackHandle(track);
462    } else {
463        // remove local strong reference to Client before deleting the Track so that the Client
464        // destructor is called by the TrackBase destructor with mLock held
465        client.clear();
466        track.clear();
467    }
468
469Exit:
470    if(status) {
471        *status = lStatus;
472    }
473    return trackHandle;
474}
475
476uint32_t AudioFlinger::sampleRate(int output) const
477{
478    Mutex::Autolock _l(mLock);
479    PlaybackThread *thread = checkPlaybackThread_l(output);
480    if (thread == NULL) {
481        LOGW("sampleRate() unknown thread %d", output);
482        return 0;
483    }
484    return thread->sampleRate();
485}
486
487int AudioFlinger::channelCount(int output) const
488{
489    Mutex::Autolock _l(mLock);
490    PlaybackThread *thread = checkPlaybackThread_l(output);
491    if (thread == NULL) {
492        LOGW("channelCount() unknown thread %d", output);
493        return 0;
494    }
495    return thread->channelCount();
496}
497
498uint32_t AudioFlinger::format(int output) const
499{
500    Mutex::Autolock _l(mLock);
501    PlaybackThread *thread = checkPlaybackThread_l(output);
502    if (thread == NULL) {
503        LOGW("format() unknown thread %d", output);
504        return 0;
505    }
506    return thread->format();
507}
508
509size_t AudioFlinger::frameCount(int output) const
510{
511    Mutex::Autolock _l(mLock);
512    PlaybackThread *thread = checkPlaybackThread_l(output);
513    if (thread == NULL) {
514        LOGW("frameCount() unknown thread %d", output);
515        return 0;
516    }
517    return thread->frameCount();
518}
519
520uint32_t AudioFlinger::latency(int output) const
521{
522    Mutex::Autolock _l(mLock);
523    PlaybackThread *thread = checkPlaybackThread_l(output);
524    if (thread == NULL) {
525        LOGW("latency() unknown thread %d", output);
526        return 0;
527    }
528    return thread->latency();
529}
530
531status_t AudioFlinger::setMasterVolume(float value)
532{
533    status_t ret = initCheck();
534    if (ret != NO_ERROR) {
535        return ret;
536    }
537
538    // check calling permissions
539    if (!settingsAllowed()) {
540        return PERMISSION_DENIED;
541    }
542
543    // when hw supports master volume, don't scale in sw mixer
544    { // scope for the lock
545        AutoMutex lock(mHardwareLock);
546        mHardwareStatus = AUDIO_HW_SET_MASTER_VOLUME;
547        if (mPrimaryHardwareDev->set_master_volume(mPrimaryHardwareDev, value) == NO_ERROR) {
548            value = 1.0f;
549        }
550        mHardwareStatus = AUDIO_HW_IDLE;
551    }
552
553    Mutex::Autolock _l(mLock);
554    mMasterVolume = value;
555    for (uint32_t i = 0; i < mPlaybackThreads.size(); i++)
556       mPlaybackThreads.valueAt(i)->setMasterVolume(value);
557
558    return NO_ERROR;
559}
560
561status_t AudioFlinger::setMode(int mode)
562{
563    status_t ret = initCheck();
564    if (ret != NO_ERROR) {
565        return ret;
566    }
567
568    // check calling permissions
569    if (!settingsAllowed()) {
570        return PERMISSION_DENIED;
571    }
572    if ((mode < 0) || (mode >= AUDIO_MODE_CNT)) {
573        LOGW("Illegal value: setMode(%d)", mode);
574        return BAD_VALUE;
575    }
576
577    { // scope for the lock
578        AutoMutex lock(mHardwareLock);
579        mHardwareStatus = AUDIO_HW_SET_MODE;
580        ret = mPrimaryHardwareDev->set_mode(mPrimaryHardwareDev, mode);
581        mHardwareStatus = AUDIO_HW_IDLE;
582    }
583
584    if (NO_ERROR == ret) {
585        Mutex::Autolock _l(mLock);
586        mMode = mode;
587        for (uint32_t i = 0; i < mPlaybackThreads.size(); i++)
588           mPlaybackThreads.valueAt(i)->setMode(mode);
589    }
590
591    return ret;
592}
593
594status_t AudioFlinger::setMicMute(bool state)
595{
596    status_t ret = initCheck();
597    if (ret != NO_ERROR) {
598        return ret;
599    }
600
601    // check calling permissions
602    if (!settingsAllowed()) {
603        return PERMISSION_DENIED;
604    }
605
606    AutoMutex lock(mHardwareLock);
607    mHardwareStatus = AUDIO_HW_SET_MIC_MUTE;
608    ret = mPrimaryHardwareDev->set_mic_mute(mPrimaryHardwareDev, state);
609    mHardwareStatus = AUDIO_HW_IDLE;
610    return ret;
611}
612
613bool AudioFlinger::getMicMute() const
614{
615    status_t ret = initCheck();
616    if (ret != NO_ERROR) {
617        return false;
618    }
619
620    bool state = AUDIO_MODE_INVALID;
621    mHardwareStatus = AUDIO_HW_GET_MIC_MUTE;
622    mPrimaryHardwareDev->get_mic_mute(mPrimaryHardwareDev, &state);
623    mHardwareStatus = AUDIO_HW_IDLE;
624    return state;
625}
626
627status_t AudioFlinger::setMasterMute(bool muted)
628{
629    // check calling permissions
630    if (!settingsAllowed()) {
631        return PERMISSION_DENIED;
632    }
633
634    Mutex::Autolock _l(mLock);
635    mMasterMute = muted;
636    for (uint32_t i = 0; i < mPlaybackThreads.size(); i++)
637       mPlaybackThreads.valueAt(i)->setMasterMute(muted);
638
639    return NO_ERROR;
640}
641
642float AudioFlinger::masterVolume() const
643{
644    return mMasterVolume;
645}
646
647bool AudioFlinger::masterMute() const
648{
649    return mMasterMute;
650}
651
652status_t AudioFlinger::setStreamVolume(int stream, float value, int output)
653{
654    // check calling permissions
655    if (!settingsAllowed()) {
656        return PERMISSION_DENIED;
657    }
658
659    if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT) {
660        return BAD_VALUE;
661    }
662
663    AutoMutex lock(mLock);
664    PlaybackThread *thread = NULL;
665    if (output) {
666        thread = checkPlaybackThread_l(output);
667        if (thread == NULL) {
668            return BAD_VALUE;
669        }
670    }
671
672    mStreamTypes[stream].volume = value;
673
674    if (thread == NULL) {
675        for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) {
676           mPlaybackThreads.valueAt(i)->setStreamVolume(stream, value);
677        }
678    } else {
679        thread->setStreamVolume(stream, value);
680    }
681
682    return NO_ERROR;
683}
684
685status_t AudioFlinger::setStreamMute(int stream, bool muted)
686{
687    // check calling permissions
688    if (!settingsAllowed()) {
689        return PERMISSION_DENIED;
690    }
691
692    if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT ||
693        uint32_t(stream) == AUDIO_STREAM_ENFORCED_AUDIBLE) {
694        return BAD_VALUE;
695    }
696
697    AutoMutex lock(mLock);
698    mStreamTypes[stream].mute = muted;
699    for (uint32_t i = 0; i < mPlaybackThreads.size(); i++)
700       mPlaybackThreads.valueAt(i)->setStreamMute(stream, muted);
701
702    return NO_ERROR;
703}
704
705float AudioFlinger::streamVolume(int stream, int output) const
706{
707    if (stream < 0 || uint32_t(stream) >= AUDIO_STREAM_CNT) {
708        return 0.0f;
709    }
710
711    AutoMutex lock(mLock);
712    float volume;
713    if (output) {
714        PlaybackThread *thread = checkPlaybackThread_l(output);
715        if (thread == NULL) {
716            return 0.0f;
717        }
718        volume = thread->streamVolume(stream);
719    } else {
720        volume = mStreamTypes[stream].volume;
721    }
722
723    return volume;
724}
725
726bool AudioFlinger::streamMute(int stream) const
727{
728    if (stream < 0 || stream >= (int)AUDIO_STREAM_CNT) {
729        return true;
730    }
731
732    return mStreamTypes[stream].mute;
733}
734
735status_t AudioFlinger::setParameters(int ioHandle, const String8& keyValuePairs)
736{
737    status_t result;
738
739    LOGV("setParameters(): io %d, keyvalue %s, tid %d, calling tid %d",
740            ioHandle, keyValuePairs.string(), gettid(), IPCThreadState::self()->getCallingPid());
741    // check calling permissions
742    if (!settingsAllowed()) {
743        return PERMISSION_DENIED;
744    }
745
746    // ioHandle == 0 means the parameters are global to the audio hardware interface
747    if (ioHandle == 0) {
748        AutoMutex lock(mHardwareLock);
749        mHardwareStatus = AUDIO_SET_PARAMETER;
750        status_t final_result = NO_ERROR;
751        for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
752            audio_hw_device_t *dev = mAudioHwDevs[i];
753            result = dev->set_parameters(dev, keyValuePairs.string());
754            final_result = result ?: final_result;
755        }
756        mHardwareStatus = AUDIO_HW_IDLE;
757        // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
758        AudioParameter param = AudioParameter(keyValuePairs);
759        String8 value;
760        if (param.get(String8(AUDIO_PARAMETER_KEY_BT_NREC), value) == NO_ERROR) {
761            Mutex::Autolock _l(mLock);
762            bool btNrecIsOff = (value == AUDIO_PARAMETER_VALUE_OFF);
763            if (mBtNrecIsOff != btNrecIsOff) {
764                for (size_t i = 0; i < mRecordThreads.size(); i++) {
765                    sp<RecordThread> thread = mRecordThreads.valueAt(i);
766                    RecordThread::RecordTrack *track = thread->track();
767                    if (track != NULL) {
768                        audio_devices_t device = (audio_devices_t)(
769                                thread->device() & AUDIO_DEVICE_IN_ALL);
770                        bool suspend = audio_is_bluetooth_sco_device(device) && btNrecIsOff;
771                        thread->setEffectSuspended(FX_IID_AEC,
772                                                   suspend,
773                                                   track->sessionId());
774                        thread->setEffectSuspended(FX_IID_NS,
775                                                   suspend,
776                                                   track->sessionId());
777                    }
778                }
779                mBtNrecIsOff = btNrecIsOff;
780            }
781        }
782        return final_result;
783    }
784
785    // hold a strong ref on thread in case closeOutput() or closeInput() is called
786    // and the thread is exited once the lock is released
787    sp<ThreadBase> thread;
788    {
789        Mutex::Autolock _l(mLock);
790        thread = checkPlaybackThread_l(ioHandle);
791        if (thread == NULL) {
792            thread = checkRecordThread_l(ioHandle);
793        } else if (thread.get() == primaryPlaybackThread_l()) {
794            // indicate output device change to all input threads for pre processing
795            AudioParameter param = AudioParameter(keyValuePairs);
796            int value;
797            if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
798                for (size_t i = 0; i < mRecordThreads.size(); i++) {
799                    mRecordThreads.valueAt(i)->setParameters(keyValuePairs);
800                }
801            }
802        }
803    }
804    if (thread != NULL) {
805        result = thread->setParameters(keyValuePairs);
806        return result;
807    }
808    return BAD_VALUE;
809}
810
811String8 AudioFlinger::getParameters(int ioHandle, const String8& keys)
812{
813//    LOGV("getParameters() io %d, keys %s, tid %d, calling tid %d",
814//            ioHandle, keys.string(), gettid(), IPCThreadState::self()->getCallingPid());
815
816    if (ioHandle == 0) {
817        String8 out_s8;
818
819        for (size_t i = 0; i < mAudioHwDevs.size(); i++) {
820            audio_hw_device_t *dev = mAudioHwDevs[i];
821            char *s = dev->get_parameters(dev, keys.string());
822            out_s8 += String8(s);
823            free(s);
824        }
825        return out_s8;
826    }
827
828    Mutex::Autolock _l(mLock);
829
830    PlaybackThread *playbackThread = checkPlaybackThread_l(ioHandle);
831    if (playbackThread != NULL) {
832        return playbackThread->getParameters(keys);
833    }
834    RecordThread *recordThread = checkRecordThread_l(ioHandle);
835    if (recordThread != NULL) {
836        return recordThread->getParameters(keys);
837    }
838    return String8("");
839}
840
841size_t AudioFlinger::getInputBufferSize(uint32_t sampleRate, int format, int channelCount)
842{
843    status_t ret = initCheck();
844    if (ret != NO_ERROR) {
845        return 0;
846    }
847
848    return mPrimaryHardwareDev->get_input_buffer_size(mPrimaryHardwareDev, sampleRate, format, channelCount);
849}
850
851unsigned int AudioFlinger::getInputFramesLost(int ioHandle)
852{
853    if (ioHandle == 0) {
854        return 0;
855    }
856
857    Mutex::Autolock _l(mLock);
858
859    RecordThread *recordThread = checkRecordThread_l(ioHandle);
860    if (recordThread != NULL) {
861        return recordThread->getInputFramesLost();
862    }
863    return 0;
864}
865
866status_t AudioFlinger::setVoiceVolume(float value)
867{
868    status_t ret = initCheck();
869    if (ret != NO_ERROR) {
870        return ret;
871    }
872
873    // check calling permissions
874    if (!settingsAllowed()) {
875        return PERMISSION_DENIED;
876    }
877
878    AutoMutex lock(mHardwareLock);
879    mHardwareStatus = AUDIO_SET_VOICE_VOLUME;
880    ret = mPrimaryHardwareDev->set_voice_volume(mPrimaryHardwareDev, value);
881    mHardwareStatus = AUDIO_HW_IDLE;
882
883    return ret;
884}
885
886status_t AudioFlinger::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames, int output)
887{
888    status_t status;
889
890    Mutex::Autolock _l(mLock);
891
892    PlaybackThread *playbackThread = checkPlaybackThread_l(output);
893    if (playbackThread != NULL) {
894        return playbackThread->getRenderPosition(halFrames, dspFrames);
895    }
896
897    return BAD_VALUE;
898}
899
900void AudioFlinger::registerClient(const sp<IAudioFlingerClient>& client)
901{
902
903    Mutex::Autolock _l(mLock);
904
905    int pid = IPCThreadState::self()->getCallingPid();
906    if (mNotificationClients.indexOfKey(pid) < 0) {
907        sp<NotificationClient> notificationClient = new NotificationClient(this,
908                                                                            client,
909                                                                            pid);
910        LOGV("registerClient() client %p, pid %d", notificationClient.get(), pid);
911
912        mNotificationClients.add(pid, notificationClient);
913
914        sp<IBinder> binder = client->asBinder();
915        binder->linkToDeath(notificationClient);
916
917        // the config change is always sent from playback or record threads to avoid deadlock
918        // with AudioSystem::gLock
919        for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
920            mPlaybackThreads.valueAt(i)->sendConfigEvent(AudioSystem::OUTPUT_OPENED);
921        }
922
923        for (size_t i = 0; i < mRecordThreads.size(); i++) {
924            mRecordThreads.valueAt(i)->sendConfigEvent(AudioSystem::INPUT_OPENED);
925        }
926    }
927}
928
929void AudioFlinger::removeNotificationClient(pid_t pid)
930{
931    Mutex::Autolock _l(mLock);
932
933    int index = mNotificationClients.indexOfKey(pid);
934    if (index >= 0) {
935        sp <NotificationClient> client = mNotificationClients.valueFor(pid);
936        LOGV("removeNotificationClient() %p, pid %d", client.get(), pid);
937        mNotificationClients.removeItem(pid);
938    }
939
940    LOGV("%d died, releasing its sessions", pid);
941    int num = mAudioSessionRefs.size();
942    bool removed = false;
943    for (int i = 0; i< num; i++) {
944        AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
945        LOGV(" pid %d @ %d", ref->pid, i);
946        if (ref->pid == pid) {
947            LOGV(" removing entry for pid %d session %d", pid, ref->sessionid);
948            mAudioSessionRefs.removeAt(i);
949            delete ref;
950            removed = true;
951            i--;
952            num--;
953        }
954    }
955    if (removed) {
956        purgeStaleEffects_l();
957    }
958}
959
960// audioConfigChanged_l() must be called with AudioFlinger::mLock held
961void AudioFlinger::audioConfigChanged_l(int event, int ioHandle, void *param2)
962{
963    size_t size = mNotificationClients.size();
964    for (size_t i = 0; i < size; i++) {
965        mNotificationClients.valueAt(i)->client()->ioConfigChanged(event, ioHandle, param2);
966    }
967}
968
969// removeClient_l() must be called with AudioFlinger::mLock held
970void AudioFlinger::removeClient_l(pid_t pid)
971{
972    LOGV("removeClient_l() pid %d, tid %d, calling tid %d", pid, gettid(), IPCThreadState::self()->getCallingPid());
973    mClients.removeItem(pid);
974}
975
976
977// ----------------------------------------------------------------------------
978
979AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, int id, uint32_t device)
980    :   Thread(false),
981        mAudioFlinger(audioFlinger), mSampleRate(0), mFrameCount(0), mChannelCount(0),
982        mFrameSize(1), mFormat(0), mStandby(false), mId(id), mExiting(false),
983        mDevice(device)
984{
985    mDeathRecipient = new PMDeathRecipient(this);
986}
987
988AudioFlinger::ThreadBase::~ThreadBase()
989{
990    mParamCond.broadcast();
991    mNewParameters.clear();
992    // do not lock the mutex in destructor
993    releaseWakeLock_l();
994    if (mPowerManager != 0) {
995        sp<IBinder> binder = mPowerManager->asBinder();
996        binder->unlinkToDeath(mDeathRecipient);
997    }
998}
999
1000void AudioFlinger::ThreadBase::exit()
1001{
1002    // keep a strong ref on ourself so that we wont get
1003    // destroyed in the middle of requestExitAndWait()
1004    sp <ThreadBase> strongMe = this;
1005
1006    LOGV("ThreadBase::exit");
1007    {
1008        AutoMutex lock(&mLock);
1009        mExiting = true;
1010        requestExit();
1011        mWaitWorkCV.signal();
1012    }
1013    requestExitAndWait();
1014}
1015
1016uint32_t AudioFlinger::ThreadBase::sampleRate() const
1017{
1018    return mSampleRate;
1019}
1020
1021int AudioFlinger::ThreadBase::channelCount() const
1022{
1023    return (int)mChannelCount;
1024}
1025
1026uint32_t AudioFlinger::ThreadBase::format() const
1027{
1028    return mFormat;
1029}
1030
1031size_t AudioFlinger::ThreadBase::frameCount() const
1032{
1033    return mFrameCount;
1034}
1035
1036status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
1037{
1038    status_t status;
1039
1040    LOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
1041    Mutex::Autolock _l(mLock);
1042
1043    mNewParameters.add(keyValuePairs);
1044    mWaitWorkCV.signal();
1045    // wait condition with timeout in case the thread loop has exited
1046    // before the request could be processed
1047    if (mParamCond.waitRelative(mLock, kSetParametersTimeout) == NO_ERROR) {
1048        status = mParamStatus;
1049        mWaitWorkCV.signal();
1050    } else {
1051        status = TIMED_OUT;
1052    }
1053    return status;
1054}
1055
1056void AudioFlinger::ThreadBase::sendConfigEvent(int event, int param)
1057{
1058    Mutex::Autolock _l(mLock);
1059    sendConfigEvent_l(event, param);
1060}
1061
1062// sendConfigEvent_l() must be called with ThreadBase::mLock held
1063void AudioFlinger::ThreadBase::sendConfigEvent_l(int event, int param)
1064{
1065    ConfigEvent *configEvent = new ConfigEvent();
1066    configEvent->mEvent = event;
1067    configEvent->mParam = param;
1068    mConfigEvents.add(configEvent);
1069    LOGV("sendConfigEvent() num events %d event %d, param %d", mConfigEvents.size(), event, param);
1070    mWaitWorkCV.signal();
1071}
1072
1073void AudioFlinger::ThreadBase::processConfigEvents()
1074{
1075    mLock.lock();
1076    while(!mConfigEvents.isEmpty()) {
1077        LOGV("processConfigEvents() remaining events %d", mConfigEvents.size());
1078        ConfigEvent *configEvent = mConfigEvents[0];
1079        mConfigEvents.removeAt(0);
1080        // release mLock before locking AudioFlinger mLock: lock order is always
1081        // AudioFlinger then ThreadBase to avoid cross deadlock
1082        mLock.unlock();
1083        mAudioFlinger->mLock.lock();
1084        audioConfigChanged_l(configEvent->mEvent, configEvent->mParam);
1085        mAudioFlinger->mLock.unlock();
1086        delete configEvent;
1087        mLock.lock();
1088    }
1089    mLock.unlock();
1090}
1091
1092status_t AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args)
1093{
1094    const size_t SIZE = 256;
1095    char buffer[SIZE];
1096    String8 result;
1097
1098    bool locked = tryLock(mLock);
1099    if (!locked) {
1100        snprintf(buffer, SIZE, "thread %p maybe dead locked\n", this);
1101        write(fd, buffer, strlen(buffer));
1102    }
1103
1104    snprintf(buffer, SIZE, "standby: %d\n", mStandby);
1105    result.append(buffer);
1106    snprintf(buffer, SIZE, "Sample rate: %d\n", mSampleRate);
1107    result.append(buffer);
1108    snprintf(buffer, SIZE, "Frame count: %d\n", mFrameCount);
1109    result.append(buffer);
1110    snprintf(buffer, SIZE, "Channel Count: %d\n", mChannelCount);
1111    result.append(buffer);
1112    snprintf(buffer, SIZE, "Channel Mask: 0x%08x\n", mChannelMask);
1113    result.append(buffer);
1114    snprintf(buffer, SIZE, "Format: %d\n", mFormat);
1115    result.append(buffer);
1116    snprintf(buffer, SIZE, "Frame size: %d\n", mFrameSize);
1117    result.append(buffer);
1118
1119    snprintf(buffer, SIZE, "\nPending setParameters commands: \n");
1120    result.append(buffer);
1121    result.append(" Index Command");
1122    for (size_t i = 0; i < mNewParameters.size(); ++i) {
1123        snprintf(buffer, SIZE, "\n %02d    ", i);
1124        result.append(buffer);
1125        result.append(mNewParameters[i]);
1126    }
1127
1128    snprintf(buffer, SIZE, "\n\nPending config events: \n");
1129    result.append(buffer);
1130    snprintf(buffer, SIZE, " Index event param\n");
1131    result.append(buffer);
1132    for (size_t i = 0; i < mConfigEvents.size(); i++) {
1133        snprintf(buffer, SIZE, " %02d    %02d    %d\n", i, mConfigEvents[i]->mEvent, mConfigEvents[i]->mParam);
1134        result.append(buffer);
1135    }
1136    result.append("\n");
1137
1138    write(fd, result.string(), result.size());
1139
1140    if (locked) {
1141        mLock.unlock();
1142    }
1143    return NO_ERROR;
1144}
1145
1146status_t AudioFlinger::ThreadBase::dumpEffectChains(int fd, const Vector<String16>& args)
1147{
1148    const size_t SIZE = 256;
1149    char buffer[SIZE];
1150    String8 result;
1151
1152    snprintf(buffer, SIZE, "\n- %d Effect Chains:\n", mEffectChains.size());
1153    write(fd, buffer, strlen(buffer));
1154
1155    for (size_t i = 0; i < mEffectChains.size(); ++i) {
1156        sp<EffectChain> chain = mEffectChains[i];
1157        if (chain != 0) {
1158            chain->dump(fd, args);
1159        }
1160    }
1161    return NO_ERROR;
1162}
1163
1164void AudioFlinger::ThreadBase::acquireWakeLock()
1165{
1166    Mutex::Autolock _l(mLock);
1167    acquireWakeLock_l();
1168}
1169
1170void AudioFlinger::ThreadBase::acquireWakeLock_l()
1171{
1172    if (mPowerManager == 0) {
1173        // use checkService() to avoid blocking if power service is not up yet
1174        sp<IBinder> binder =
1175            defaultServiceManager()->checkService(String16("power"));
1176        if (binder == 0) {
1177            LOGW("Thread %s cannot connect to the power manager service", mName);
1178        } else {
1179            mPowerManager = interface_cast<IPowerManager>(binder);
1180            binder->linkToDeath(mDeathRecipient);
1181        }
1182    }
1183    if (mPowerManager != 0) {
1184        sp<IBinder> binder = new BBinder();
1185        status_t status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK,
1186                                                         binder,
1187                                                         String16(mName));
1188        if (status == NO_ERROR) {
1189            mWakeLockToken = binder;
1190        }
1191        LOGV("acquireWakeLock_l() %s status %d", mName, status);
1192    }
1193}
1194
1195void AudioFlinger::ThreadBase::releaseWakeLock()
1196{
1197    Mutex::Autolock _l(mLock);
1198    releaseWakeLock_l();
1199}
1200
1201void AudioFlinger::ThreadBase::releaseWakeLock_l()
1202{
1203    if (mWakeLockToken != 0) {
1204        LOGV("releaseWakeLock_l() %s", mName);
1205        if (mPowerManager != 0) {
1206            mPowerManager->releaseWakeLock(mWakeLockToken, 0);
1207        }
1208        mWakeLockToken.clear();
1209    }
1210}
1211
1212void AudioFlinger::ThreadBase::clearPowerManager()
1213{
1214    Mutex::Autolock _l(mLock);
1215    releaseWakeLock_l();
1216    mPowerManager.clear();
1217}
1218
1219void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who)
1220{
1221    sp<ThreadBase> thread = mThread.promote();
1222    if (thread != 0) {
1223        thread->clearPowerManager();
1224    }
1225    LOGW("power manager service died !!!");
1226}
1227
1228void AudioFlinger::ThreadBase::setEffectSuspended(
1229        const effect_uuid_t *type, bool suspend, int sessionId)
1230{
1231    Mutex::Autolock _l(mLock);
1232    setEffectSuspended_l(type, suspend, sessionId);
1233}
1234
1235void AudioFlinger::ThreadBase::setEffectSuspended_l(
1236        const effect_uuid_t *type, bool suspend, int sessionId)
1237{
1238    sp<EffectChain> chain;
1239    chain = getEffectChain_l(sessionId);
1240    if (chain != 0) {
1241        if (type != NULL) {
1242            chain->setEffectSuspended_l(type, suspend);
1243        } else {
1244            chain->setEffectSuspendedAll_l(suspend);
1245        }
1246    }
1247
1248    updateSuspendedSessions_l(type, suspend, sessionId);
1249}
1250
1251void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
1252{
1253    int index = mSuspendedSessions.indexOfKey(chain->sessionId());
1254    if (index < 0) {
1255        return;
1256    }
1257
1258    KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects =
1259            mSuspendedSessions.editValueAt(index);
1260
1261    for (size_t i = 0; i < sessionEffects.size(); i++) {
1262        sp <SuspendedSessionDesc> desc = sessionEffects.valueAt(i);
1263        for (int j = 0; j < desc->mRefCount; j++) {
1264            if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
1265                chain->setEffectSuspendedAll_l(true);
1266            } else {
1267                LOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
1268                     desc->mType.timeLow);
1269                chain->setEffectSuspended_l(&desc->mType, true);
1270            }
1271        }
1272    }
1273}
1274
1275void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
1276                                                         bool suspend,
1277                                                         int sessionId)
1278{
1279    int index = mSuspendedSessions.indexOfKey(sessionId);
1280
1281    KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
1282
1283    if (suspend) {
1284        if (index >= 0) {
1285            sessionEffects = mSuspendedSessions.editValueAt(index);
1286        } else {
1287            mSuspendedSessions.add(sessionId, sessionEffects);
1288        }
1289    } else {
1290        if (index < 0) {
1291            return;
1292        }
1293        sessionEffects = mSuspendedSessions.editValueAt(index);
1294    }
1295
1296
1297    int key = EffectChain::kKeyForSuspendAll;
1298    if (type != NULL) {
1299        key = type->timeLow;
1300    }
1301    index = sessionEffects.indexOfKey(key);
1302
1303    sp <SuspendedSessionDesc> desc;
1304    if (suspend) {
1305        if (index >= 0) {
1306            desc = sessionEffects.valueAt(index);
1307        } else {
1308            desc = new SuspendedSessionDesc();
1309            if (type != NULL) {
1310                memcpy(&desc->mType, type, sizeof(effect_uuid_t));
1311            }
1312            sessionEffects.add(key, desc);
1313            LOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
1314        }
1315        desc->mRefCount++;
1316    } else {
1317        if (index < 0) {
1318            return;
1319        }
1320        desc = sessionEffects.valueAt(index);
1321        if (--desc->mRefCount == 0) {
1322            LOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
1323            sessionEffects.removeItemsAt(index);
1324            if (sessionEffects.isEmpty()) {
1325                LOGV("updateSuspendedSessions_l() restore removing session %d",
1326                                 sessionId);
1327                mSuspendedSessions.removeItem(sessionId);
1328            }
1329        }
1330    }
1331    if (!sessionEffects.isEmpty()) {
1332        mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
1333    }
1334}
1335
1336void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
1337                                                            bool enabled,
1338                                                            int sessionId)
1339{
1340    Mutex::Autolock _l(mLock);
1341    checkSuspendOnEffectEnabled_l(effect, enabled, sessionId);
1342}
1343
1344void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
1345                                                            bool enabled,
1346                                                            int sessionId)
1347{
1348    if (mType != RECORD) {
1349        // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
1350        // another session. This gives the priority to well behaved effect control panels
1351        // and applications not using global effects.
1352        if (sessionId != AUDIO_SESSION_OUTPUT_MIX) {
1353            setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
1354        }
1355    }
1356
1357    sp<EffectChain> chain = getEffectChain_l(sessionId);
1358    if (chain != 0) {
1359        chain->checkSuspendOnEffectEnabled(effect, enabled);
1360    }
1361}
1362
1363// ----------------------------------------------------------------------------
1364
1365AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
1366                                             AudioStreamOut* output,
1367                                             int id,
1368                                             uint32_t device)
1369    :   ThreadBase(audioFlinger, id, device),
1370        mMixBuffer(0), mSuspended(0), mBytesWritten(0), mOutput(output),
1371        mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false)
1372{
1373    snprintf(mName, kNameLength, "AudioOut_%d", id);
1374
1375    readOutputParameters();
1376
1377    mMasterVolume = mAudioFlinger->masterVolume();
1378    mMasterMute = mAudioFlinger->masterMute();
1379
1380    for (int stream = 0; stream < AUDIO_STREAM_CNT; stream++) {
1381        mStreamTypes[stream].volume = mAudioFlinger->streamVolumeInternal(stream);
1382        mStreamTypes[stream].mute = mAudioFlinger->streamMute(stream);
1383        mStreamTypes[stream].valid = true;
1384    }
1385}
1386
1387AudioFlinger::PlaybackThread::~PlaybackThread()
1388{
1389    delete [] mMixBuffer;
1390}
1391
1392status_t AudioFlinger::PlaybackThread::dump(int fd, const Vector<String16>& args)
1393{
1394    dumpInternals(fd, args);
1395    dumpTracks(fd, args);
1396    dumpEffectChains(fd, args);
1397    return NO_ERROR;
1398}
1399
1400status_t AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args)
1401{
1402    const size_t SIZE = 256;
1403    char buffer[SIZE];
1404    String8 result;
1405
1406    snprintf(buffer, SIZE, "Output thread %p tracks\n", this);
1407    result.append(buffer);
1408    result.append("   Name  Clien Typ Fmt Chn mask   Session Buf  S M F SRate LeftV RighV  Serv       User       Main buf   Aux Buf\n");
1409    for (size_t i = 0; i < mTracks.size(); ++i) {
1410        sp<Track> track = mTracks[i];
1411        if (track != 0) {
1412            track->dump(buffer, SIZE);
1413            result.append(buffer);
1414        }
1415    }
1416
1417    snprintf(buffer, SIZE, "Output thread %p active tracks\n", this);
1418    result.append(buffer);
1419    result.append("   Name  Clien Typ Fmt Chn mask   Session Buf  S M F SRate LeftV RighV  Serv       User       Main buf   Aux Buf\n");
1420    for (size_t i = 0; i < mActiveTracks.size(); ++i) {
1421        wp<Track> wTrack = mActiveTracks[i];
1422        if (wTrack != 0) {
1423            sp<Track> track = wTrack.promote();
1424            if (track != 0) {
1425                track->dump(buffer, SIZE);
1426                result.append(buffer);
1427            }
1428        }
1429    }
1430    write(fd, result.string(), result.size());
1431    return NO_ERROR;
1432}
1433
1434status_t AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String16>& args)
1435{
1436    const size_t SIZE = 256;
1437    char buffer[SIZE];
1438    String8 result;
1439
1440    snprintf(buffer, SIZE, "\nOutput thread %p internals\n", this);
1441    result.append(buffer);
1442    snprintf(buffer, SIZE, "last write occurred (msecs): %llu\n", ns2ms(systemTime() - mLastWriteTime));
1443    result.append(buffer);
1444    snprintf(buffer, SIZE, "total writes: %d\n", mNumWrites);
1445    result.append(buffer);
1446    snprintf(buffer, SIZE, "delayed writes: %d\n", mNumDelayedWrites);
1447    result.append(buffer);
1448    snprintf(buffer, SIZE, "blocked in write: %d\n", mInWrite);
1449    result.append(buffer);
1450    snprintf(buffer, SIZE, "suspend count: %d\n", mSuspended);
1451    result.append(buffer);
1452    snprintf(buffer, SIZE, "mix buffer : %p\n", mMixBuffer);
1453    result.append(buffer);
1454    write(fd, result.string(), result.size());
1455
1456    dumpBase(fd, args);
1457
1458    return NO_ERROR;
1459}
1460
1461// Thread virtuals
1462status_t AudioFlinger::PlaybackThread::readyToRun()
1463{
1464    status_t status = initCheck();
1465    if (status == NO_ERROR) {
1466        LOGI("AudioFlinger's thread %p ready to run", this);
1467    } else {
1468        LOGE("No working audio driver found.");
1469    }
1470    return status;
1471}
1472
1473void AudioFlinger::PlaybackThread::onFirstRef()
1474{
1475    run(mName, ANDROID_PRIORITY_URGENT_AUDIO);
1476}
1477
1478// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
1479sp<AudioFlinger::PlaybackThread::Track>  AudioFlinger::PlaybackThread::createTrack_l(
1480        const sp<AudioFlinger::Client>& client,
1481        int streamType,
1482        uint32_t sampleRate,
1483        uint32_t format,
1484        uint32_t channelMask,
1485        int frameCount,
1486        const sp<IMemory>& sharedBuffer,
1487        int sessionId,
1488        status_t *status)
1489{
1490    sp<Track> track;
1491    status_t lStatus;
1492
1493    if (mType == DIRECT) {
1494        if ((format & AUDIO_FORMAT_MAIN_MASK) == AUDIO_FORMAT_PCM) {
1495            if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
1496                LOGE("createTrack_l() Bad parameter: sampleRate %d format %d, channelMask 0x%08x \""
1497                        "for output %p with format %d",
1498                        sampleRate, format, channelMask, mOutput, mFormat);
1499                lStatus = BAD_VALUE;
1500                goto Exit;
1501            }
1502        }
1503    } else {
1504        // Resampler implementation limits input sampling rate to 2 x output sampling rate.
1505        if (sampleRate > mSampleRate*2) {
1506            LOGE("Sample rate out of range: %d mSampleRate %d", sampleRate, mSampleRate);
1507            lStatus = BAD_VALUE;
1508            goto Exit;
1509        }
1510    }
1511
1512    lStatus = initCheck();
1513    if (lStatus != NO_ERROR) {
1514        LOGE("Audio driver not initialized.");
1515        goto Exit;
1516    }
1517
1518    { // scope for mLock
1519        Mutex::Autolock _l(mLock);
1520
1521        // all tracks in same audio session must share the same routing strategy otherwise
1522        // conflicts will happen when tracks are moved from one output to another by audio policy
1523        // manager
1524        uint32_t strategy =
1525                AudioSystem::getStrategyForStream((audio_stream_type_t)streamType);
1526        for (size_t i = 0; i < mTracks.size(); ++i) {
1527            sp<Track> t = mTracks[i];
1528            if (t != 0) {
1529                if (sessionId == t->sessionId() &&
1530                        strategy != AudioSystem::getStrategyForStream((audio_stream_type_t)t->type())) {
1531                    lStatus = BAD_VALUE;
1532                    goto Exit;
1533                }
1534            }
1535        }
1536
1537        track = new Track(this, client, streamType, sampleRate, format,
1538                channelMask, frameCount, sharedBuffer, sessionId);
1539        if (track->getCblk() == NULL || track->name() < 0) {
1540            lStatus = NO_MEMORY;
1541            goto Exit;
1542        }
1543        mTracks.add(track);
1544
1545        sp<EffectChain> chain = getEffectChain_l(sessionId);
1546        if (chain != 0) {
1547            LOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
1548            track->setMainBuffer(chain->inBuffer());
1549            chain->setStrategy(AudioSystem::getStrategyForStream((audio_stream_type_t)track->type()));
1550            chain->incTrackCnt();
1551        }
1552
1553        // invalidate track immediately if the stream type was moved to another thread since
1554        // createTrack() was called by the client process.
1555        if (!mStreamTypes[streamType].valid) {
1556            LOGW("createTrack_l() on thread %p: invalidating track on stream %d",
1557                 this, streamType);
1558            android_atomic_or(CBLK_INVALID_ON, &track->mCblk->flags);
1559        }
1560    }
1561    lStatus = NO_ERROR;
1562
1563Exit:
1564    if(status) {
1565        *status = lStatus;
1566    }
1567    return track;
1568}
1569
1570uint32_t AudioFlinger::PlaybackThread::latency() const
1571{
1572    Mutex::Autolock _l(mLock);
1573    if (initCheck() == NO_ERROR) {
1574        return mOutput->stream->get_latency(mOutput->stream);
1575    } else {
1576        return 0;
1577    }
1578}
1579
1580status_t AudioFlinger::PlaybackThread::setMasterVolume(float value)
1581{
1582    mMasterVolume = value;
1583    return NO_ERROR;
1584}
1585
1586status_t AudioFlinger::PlaybackThread::setMasterMute(bool muted)
1587{
1588    mMasterMute = muted;
1589    return NO_ERROR;
1590}
1591
1592float AudioFlinger::PlaybackThread::masterVolume() const
1593{
1594    return mMasterVolume;
1595}
1596
1597bool AudioFlinger::PlaybackThread::masterMute() const
1598{
1599    return mMasterMute;
1600}
1601
1602status_t AudioFlinger::PlaybackThread::setStreamVolume(int stream, float value)
1603{
1604    mStreamTypes[stream].volume = value;
1605    return NO_ERROR;
1606}
1607
1608status_t AudioFlinger::PlaybackThread::setStreamMute(int stream, bool muted)
1609{
1610    mStreamTypes[stream].mute = muted;
1611    return NO_ERROR;
1612}
1613
1614float AudioFlinger::PlaybackThread::streamVolume(int stream) const
1615{
1616    return mStreamTypes[stream].volume;
1617}
1618
1619bool AudioFlinger::PlaybackThread::streamMute(int stream) const
1620{
1621    return mStreamTypes[stream].mute;
1622}
1623
1624// addTrack_l() must be called with ThreadBase::mLock held
1625status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
1626{
1627    status_t status = ALREADY_EXISTS;
1628
1629    // set retry count for buffer fill
1630    track->mRetryCount = kMaxTrackStartupRetries;
1631    if (mActiveTracks.indexOf(track) < 0) {
1632        // the track is newly added, make sure it fills up all its
1633        // buffers before playing. This is to ensure the client will
1634        // effectively get the latency it requested.
1635        track->mFillingUpStatus = Track::FS_FILLING;
1636        track->mResetDone = false;
1637        mActiveTracks.add(track);
1638        if (track->mainBuffer() != mMixBuffer) {
1639            sp<EffectChain> chain = getEffectChain_l(track->sessionId());
1640            if (chain != 0) {
1641                LOGV("addTrack_l() starting track on chain %p for session %d", chain.get(), track->sessionId());
1642                chain->incActiveTrackCnt();
1643            }
1644        }
1645
1646        status = NO_ERROR;
1647    }
1648
1649    LOGV("mWaitWorkCV.broadcast");
1650    mWaitWorkCV.broadcast();
1651
1652    return status;
1653}
1654
1655// destroyTrack_l() must be called with ThreadBase::mLock held
1656void AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
1657{
1658    track->mState = TrackBase::TERMINATED;
1659    if (mActiveTracks.indexOf(track) < 0) {
1660        removeTrack_l(track);
1661    }
1662}
1663
1664void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
1665{
1666    mTracks.remove(track);
1667    deleteTrackName_l(track->name());
1668    sp<EffectChain> chain = getEffectChain_l(track->sessionId());
1669    if (chain != 0) {
1670        chain->decTrackCnt();
1671    }
1672}
1673
1674String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
1675{
1676    String8 out_s8 = String8("");
1677    char *s;
1678
1679    Mutex::Autolock _l(mLock);
1680    if (initCheck() != NO_ERROR) {
1681        return out_s8;
1682    }
1683
1684    s = mOutput->stream->common.get_parameters(&mOutput->stream->common, keys.string());
1685    out_s8 = String8(s);
1686    free(s);
1687    return out_s8;
1688}
1689
1690// audioConfigChanged_l() must be called with AudioFlinger::mLock held
1691void AudioFlinger::PlaybackThread::audioConfigChanged_l(int event, int param) {
1692    AudioSystem::OutputDescriptor desc;
1693    void *param2 = 0;
1694
1695    LOGV("PlaybackThread::audioConfigChanged_l, thread %p, event %d, param %d", this, event, param);
1696
1697    switch (event) {
1698    case AudioSystem::OUTPUT_OPENED:
1699    case AudioSystem::OUTPUT_CONFIG_CHANGED:
1700        desc.channels = mChannelMask;
1701        desc.samplingRate = mSampleRate;
1702        desc.format = mFormat;
1703        desc.frameCount = mFrameCount;
1704        desc.latency = latency();
1705        param2 = &desc;
1706        break;
1707
1708    case AudioSystem::STREAM_CONFIG_CHANGED:
1709        param2 = &param;
1710    case AudioSystem::OUTPUT_CLOSED:
1711    default:
1712        break;
1713    }
1714    mAudioFlinger->audioConfigChanged_l(event, mId, param2);
1715}
1716
1717void AudioFlinger::PlaybackThread::readOutputParameters()
1718{
1719    mSampleRate = mOutput->stream->common.get_sample_rate(&mOutput->stream->common);
1720    mChannelMask = mOutput->stream->common.get_channels(&mOutput->stream->common);
1721    mChannelCount = (uint16_t)popcount(mChannelMask);
1722    mFormat = mOutput->stream->common.get_format(&mOutput->stream->common);
1723    mFrameSize = (uint16_t)audio_stream_frame_size(&mOutput->stream->common);
1724    mFrameCount = mOutput->stream->common.get_buffer_size(&mOutput->stream->common) / mFrameSize;
1725
1726    // FIXME - Current mixer implementation only supports stereo output: Always
1727    // Allocate a stereo buffer even if HW output is mono.
1728    if (mMixBuffer != NULL) delete[] mMixBuffer;
1729    mMixBuffer = new int16_t[mFrameCount * 2];
1730    memset(mMixBuffer, 0, mFrameCount * 2 * sizeof(int16_t));
1731
1732    // force reconfiguration of effect chains and engines to take new buffer size and audio
1733    // parameters into account
1734    // Note that mLock is not held when readOutputParameters() is called from the constructor
1735    // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
1736    // matter.
1737    // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
1738    Vector< sp<EffectChain> > effectChains = mEffectChains;
1739    for (size_t i = 0; i < effectChains.size(); i ++) {
1740        mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(), this, this, false);
1741    }
1742}
1743
1744status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
1745{
1746    if (halFrames == 0 || dspFrames == 0) {
1747        return BAD_VALUE;
1748    }
1749    Mutex::Autolock _l(mLock);
1750    if (initCheck() != NO_ERROR) {
1751        return INVALID_OPERATION;
1752    }
1753    *halFrames = mBytesWritten / audio_stream_frame_size(&mOutput->stream->common);
1754
1755    return mOutput->stream->get_render_position(mOutput->stream, dspFrames);
1756}
1757
1758uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId)
1759{
1760    Mutex::Autolock _l(mLock);
1761    uint32_t result = 0;
1762    if (getEffectChain_l(sessionId) != 0) {
1763        result = EFFECT_SESSION;
1764    }
1765
1766    for (size_t i = 0; i < mTracks.size(); ++i) {
1767        sp<Track> track = mTracks[i];
1768        if (sessionId == track->sessionId() &&
1769                !(track->mCblk->flags & CBLK_INVALID_MSK)) {
1770            result |= TRACK_SESSION;
1771            break;
1772        }
1773    }
1774
1775    return result;
1776}
1777
1778uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(int sessionId)
1779{
1780    // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
1781    // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
1782    if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1783        return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
1784    }
1785    for (size_t i = 0; i < mTracks.size(); i++) {
1786        sp<Track> track = mTracks[i];
1787        if (sessionId == track->sessionId() &&
1788                !(track->mCblk->flags & CBLK_INVALID_MSK)) {
1789            return AudioSystem::getStrategyForStream((audio_stream_type_t) track->type());
1790        }
1791    }
1792    return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
1793}
1794
1795
1796AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::getOutput()
1797{
1798    Mutex::Autolock _l(mLock);
1799    return mOutput;
1800}
1801
1802AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
1803{
1804    Mutex::Autolock _l(mLock);
1805    AudioStreamOut *output = mOutput;
1806    mOutput = NULL;
1807    return output;
1808}
1809
1810// this method must always be called either with ThreadBase mLock held or inside the thread loop
1811audio_stream_t* AudioFlinger::PlaybackThread::stream()
1812{
1813    if (mOutput == NULL) {
1814        return NULL;
1815    }
1816    return &mOutput->stream->common;
1817}
1818
1819uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs()
1820{
1821    // A2DP output latency is not due only to buffering capacity. It also reflects encoding,
1822    // decoding and transfer time. So sleeping for half of the latency would likely cause
1823    // underruns
1824    if (audio_is_a2dp_device((audio_devices_t)mDevice)) {
1825        return (uint32_t)((uint32_t)((mFrameCount * 1000) / mSampleRate) * 1000);
1826    } else {
1827        return (uint32_t)(mOutput->stream->get_latency(mOutput->stream) * 1000) / 2;
1828    }
1829}
1830
1831// ----------------------------------------------------------------------------
1832
1833AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device)
1834    :   PlaybackThread(audioFlinger, output, id, device),
1835        mAudioMixer(0), mPrevMixerStatus(MIXER_IDLE)
1836{
1837    mType = ThreadBase::MIXER;
1838    mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);
1839
1840    // FIXME - Current mixer implementation only supports stereo output
1841    if (mChannelCount == 1) {
1842        LOGE("Invalid audio hardware channel count");
1843    }
1844}
1845
1846AudioFlinger::MixerThread::~MixerThread()
1847{
1848    delete mAudioMixer;
1849}
1850
1851bool AudioFlinger::MixerThread::threadLoop()
1852{
1853    Vector< sp<Track> > tracksToRemove;
1854    uint32_t mixerStatus = MIXER_IDLE;
1855    nsecs_t standbyTime = systemTime();
1856    size_t mixBufferSize = mFrameCount * mFrameSize;
1857    // FIXME: Relaxed timing because of a certain device that can't meet latency
1858    // Should be reduced to 2x after the vendor fixes the driver issue
1859    // increase threshold again due to low power audio mode. The way this warning threshold is
1860    // calculated and its usefulness should be reconsidered anyway.
1861    nsecs_t maxPeriod = seconds(mFrameCount) / mSampleRate * 15;
1862    nsecs_t lastWarning = 0;
1863    bool longStandbyExit = false;
1864    uint32_t activeSleepTime = activeSleepTimeUs();
1865    uint32_t idleSleepTime = idleSleepTimeUs();
1866    uint32_t sleepTime = idleSleepTime;
1867    uint32_t sleepTimeShift = 0;
1868    Vector< sp<EffectChain> > effectChains;
1869#ifdef DEBUG_CPU_USAGE
1870    ThreadCpuUsage cpu;
1871    const CentralTendencyStatistics& stats = cpu.statistics();
1872#endif
1873
1874    acquireWakeLock();
1875
1876    while (!exitPending())
1877    {
1878#ifdef DEBUG_CPU_USAGE
1879        cpu.sampleAndEnable();
1880        unsigned n = stats.n();
1881        // cpu.elapsed() is expensive, so don't call it every loop
1882        if ((n & 127) == 1) {
1883            long long elapsed = cpu.elapsed();
1884            if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
1885                double perLoop = elapsed / (double) n;
1886                double perLoop100 = perLoop * 0.01;
1887                double mean = stats.mean();
1888                double stddev = stats.stddev();
1889                double minimum = stats.minimum();
1890                double maximum = stats.maximum();
1891                cpu.resetStatistics();
1892                LOGI("CPU usage over past %.1f secs (%u mixer loops at %.1f mean ms per loop):\n  us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n  %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f",
1893                        elapsed * .000000001, n, perLoop * .000001,
1894                        mean * .001,
1895                        stddev * .001,
1896                        minimum * .001,
1897                        maximum * .001,
1898                        mean / perLoop100,
1899                        stddev / perLoop100,
1900                        minimum / perLoop100,
1901                        maximum / perLoop100);
1902            }
1903        }
1904#endif
1905        processConfigEvents();
1906
1907        mixerStatus = MIXER_IDLE;
1908        { // scope for mLock
1909
1910            Mutex::Autolock _l(mLock);
1911
1912            if (checkForNewParameters_l()) {
1913                mixBufferSize = mFrameCount * mFrameSize;
1914                // FIXME: Relaxed timing because of a certain device that can't meet latency
1915                // Should be reduced to 2x after the vendor fixes the driver issue
1916                // increase threshold again due to low power audio mode. The way this warning
1917                // threshold is calculated and its usefulness should be reconsidered anyway.
1918                maxPeriod = seconds(mFrameCount) / mSampleRate * 15;
1919                activeSleepTime = activeSleepTimeUs();
1920                idleSleepTime = idleSleepTimeUs();
1921            }
1922
1923            const SortedVector< wp<Track> >& activeTracks = mActiveTracks;
1924
1925            // put audio hardware into standby after short delay
1926            if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) ||
1927                        mSuspended) {
1928                if (!mStandby) {
1929                    LOGV("Audio hardware entering standby, mixer %p, mSuspended %d\n", this, mSuspended);
1930                    mOutput->stream->common.standby(&mOutput->stream->common);
1931                    mStandby = true;
1932                    mBytesWritten = 0;
1933                }
1934
1935                if (!activeTracks.size() && mConfigEvents.isEmpty()) {
1936                    // we're about to wait, flush the binder command buffer
1937                    IPCThreadState::self()->flushCommands();
1938
1939                    if (exitPending()) break;
1940
1941                    releaseWakeLock_l();
1942                    // wait until we have something to do...
1943                    LOGV("MixerThread %p TID %d going to sleep\n", this, gettid());
1944                    mWaitWorkCV.wait(mLock);
1945                    LOGV("MixerThread %p TID %d waking up\n", this, gettid());
1946                    acquireWakeLock_l();
1947
1948                    mPrevMixerStatus = MIXER_IDLE;
1949                    if (mMasterMute == false) {
1950                        char value[PROPERTY_VALUE_MAX];
1951                        property_get("ro.audio.silent", value, "0");
1952                        if (atoi(value)) {
1953                            LOGD("Silence is golden");
1954                            setMasterMute(true);
1955                        }
1956                    }
1957
1958                    standbyTime = systemTime() + kStandbyTimeInNsecs;
1959                    sleepTime = idleSleepTime;
1960                    sleepTimeShift = 0;
1961                    continue;
1962                }
1963            }
1964
1965            mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);
1966
1967            // prevent any changes in effect chain list and in each effect chain
1968            // during mixing and effect process as the audio buffers could be deleted
1969            // or modified if an effect is created or deleted
1970            lockEffectChains_l(effectChains);
1971       }
1972
1973        if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
1974            // mix buffers...
1975            mAudioMixer->process();
1976            // increase sleep time progressively when application underrun condition clears.
1977            // Only increase sleep time if the mixer is ready for two consecutive times to avoid
1978            // that a steady state of alternating ready/not ready conditions keeps the sleep time
1979            // such that we would underrun the audio HAL.
1980            if ((sleepTime == 0) && (sleepTimeShift > 0)) {
1981                sleepTimeShift--;
1982            }
1983            sleepTime = 0;
1984            standbyTime = systemTime() + kStandbyTimeInNsecs;
1985            //TODO: delay standby when effects have a tail
1986        } else {
1987            // If no tracks are ready, sleep once for the duration of an output
1988            // buffer size, then write 0s to the output
1989            if (sleepTime == 0) {
1990                if (mixerStatus == MIXER_TRACKS_ENABLED) {
1991                    sleepTime = activeSleepTime >> sleepTimeShift;
1992                    if (sleepTime < kMinThreadSleepTimeUs) {
1993                        sleepTime = kMinThreadSleepTimeUs;
1994                    }
1995                    // reduce sleep time in case of consecutive application underruns to avoid
1996                    // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
1997                    // duration we would end up writing less data than needed by the audio HAL if
1998                    // the condition persists.
1999                    if (sleepTimeShift < kMaxThreadSleepTimeShift) {
2000                        sleepTimeShift++;
2001                    }
2002                } else {
2003                    sleepTime = idleSleepTime;
2004                }
2005            } else if (mBytesWritten != 0 ||
2006                       (mixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)) {
2007                memset (mMixBuffer, 0, mixBufferSize);
2008                sleepTime = 0;
2009                LOGV_IF((mBytesWritten == 0 && (mixerStatus == MIXER_TRACKS_ENABLED && longStandbyExit)), "anticipated start");
2010            }
2011            // TODO add standby time extension fct of effect tail
2012        }
2013
2014        if (mSuspended) {
2015            sleepTime = suspendSleepTimeUs();
2016        }
2017        // sleepTime == 0 means we must write to audio hardware
2018        if (sleepTime == 0) {
2019             for (size_t i = 0; i < effectChains.size(); i ++) {
2020                 effectChains[i]->process_l();
2021             }
2022             // enable changes in effect chain
2023             unlockEffectChains(effectChains);
2024            mLastWriteTime = systemTime();
2025            mInWrite = true;
2026            mBytesWritten += mixBufferSize;
2027
2028            int bytesWritten = (int)mOutput->stream->write(mOutput->stream, mMixBuffer, mixBufferSize);
2029            if (bytesWritten < 0) mBytesWritten -= mixBufferSize;
2030            mNumWrites++;
2031            mInWrite = false;
2032            nsecs_t now = systemTime();
2033            nsecs_t delta = now - mLastWriteTime;
2034            if (!mStandby && delta > maxPeriod) {
2035                mNumDelayedWrites++;
2036                if ((now - lastWarning) > kWarningThrottle) {
2037                    LOGW("write blocked for %llu msecs, %d delayed writes, thread %p",
2038                            ns2ms(delta), mNumDelayedWrites, this);
2039                    lastWarning = now;
2040                }
2041                if (mStandby) {
2042                    longStandbyExit = true;
2043                }
2044            }
2045            mStandby = false;
2046        } else {
2047            // enable changes in effect chain
2048            unlockEffectChains(effectChains);
2049            usleep(sleepTime);
2050        }
2051
2052        // finally let go of all our tracks, without the lock held
2053        // since we can't guarantee the destructors won't acquire that
2054        // same lock.
2055        tracksToRemove.clear();
2056
2057        // Effect chains will be actually deleted here if they were removed from
2058        // mEffectChains list during mixing or effects processing
2059        effectChains.clear();
2060    }
2061
2062    if (!mStandby) {
2063        mOutput->stream->common.standby(&mOutput->stream->common);
2064    }
2065
2066    releaseWakeLock();
2067
2068    LOGV("MixerThread %p exiting", this);
2069    return false;
2070}
2071
2072// prepareTracks_l() must be called with ThreadBase::mLock held
2073uint32_t AudioFlinger::MixerThread::prepareTracks_l(const SortedVector< wp<Track> >& activeTracks, Vector< sp<Track> > *tracksToRemove)
2074{
2075
2076    uint32_t mixerStatus = MIXER_IDLE;
2077    // find out which tracks need to be processed
2078    size_t count = activeTracks.size();
2079    size_t mixedTracks = 0;
2080    size_t tracksWithEffect = 0;
2081
2082    float masterVolume = mMasterVolume;
2083    bool  masterMute = mMasterMute;
2084
2085    if (masterMute) {
2086        masterVolume = 0;
2087    }
2088    // Delegate master volume control to effect in output mix effect chain if needed
2089    sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
2090    if (chain != 0) {
2091        uint32_t v = (uint32_t)(masterVolume * (1 << 24));
2092        chain->setVolume_l(&v, &v);
2093        masterVolume = (float)((v + (1 << 23)) >> 24);
2094        chain.clear();
2095    }
2096
2097    for (size_t i=0 ; i<count ; i++) {
2098        sp<Track> t = activeTracks[i].promote();
2099        if (t == 0) continue;
2100
2101        Track* const track = t.get();
2102        audio_track_cblk_t* cblk = track->cblk();
2103
2104        // The first time a track is added we wait
2105        // for all its buffers to be filled before processing it
2106        mAudioMixer->setActiveTrack(track->name());
2107        // make sure that we have enough frames to mix one full buffer.
2108        // enforce this condition only once to enable draining the buffer in case the client
2109        // app does not call stop() and relies on underrun to stop:
2110        // hence the test on (mPrevMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
2111        // during last round
2112        uint32_t minFrames = 1;
2113        if (!track->isStopped() && !track->isPausing() &&
2114                (mPrevMixerStatus == MIXER_TRACKS_READY)) {
2115            if (t->sampleRate() == (int)mSampleRate) {
2116                minFrames = mFrameCount;
2117            } else {
2118                // +1 for rounding and +1 for additional sample needed for interpolation
2119                minFrames = (mFrameCount * t->sampleRate()) / mSampleRate + 1 + 1;
2120                // add frames already consumed but not yet released by the resampler
2121                // because cblk->framesReady() will  include these frames
2122                minFrames += mAudioMixer->getUnreleasedFrames(track->name());
2123                // the minimum track buffer size is normally twice the number of frames necessary
2124                // to fill one buffer and the resampler should not leave more than one buffer worth
2125                // of unreleased frames after each pass, but just in case...
2126                LOG_ASSERT(minFrames <= cblk->frameCount);
2127            }
2128        }
2129        if ((cblk->framesReady() >= minFrames) && track->isReady() &&
2130                !track->isPaused() && !track->isTerminated())
2131        {
2132            //LOGV("track %d u=%08x, s=%08x [OK] on thread %p", track->name(), cblk->user, cblk->server, this);
2133
2134            mixedTracks++;
2135
2136            // track->mainBuffer() != mMixBuffer means there is an effect chain
2137            // connected to the track
2138            chain.clear();
2139            if (track->mainBuffer() != mMixBuffer) {
2140                chain = getEffectChain_l(track->sessionId());
2141                // Delegate volume control to effect in track effect chain if needed
2142                if (chain != 0) {
2143                    tracksWithEffect++;
2144                } else {
2145                    LOGW("prepareTracks_l(): track %08x attached to effect but no chain found on session %d",
2146                            track->name(), track->sessionId());
2147                }
2148            }
2149
2150
2151            int param = AudioMixer::VOLUME;
2152            if (track->mFillingUpStatus == Track::FS_FILLED) {
2153                // no ramp for the first volume setting
2154                track->mFillingUpStatus = Track::FS_ACTIVE;
2155                if (track->mState == TrackBase::RESUMING) {
2156                    track->mState = TrackBase::ACTIVE;
2157                    param = AudioMixer::RAMP_VOLUME;
2158                }
2159                mAudioMixer->setParameter(AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
2160            } else if (cblk->server != 0) {
2161                // If the track is stopped before the first frame was mixed,
2162                // do not apply ramp
2163                param = AudioMixer::RAMP_VOLUME;
2164            }
2165
2166            // compute volume for this track
2167            uint32_t vl, vr, va;
2168            if (track->isMuted() || track->isPausing() ||
2169                mStreamTypes[track->type()].mute) {
2170                vl = vr = va = 0;
2171                if (track->isPausing()) {
2172                    track->setPaused();
2173                }
2174            } else {
2175
2176                // read original volumes with volume control
2177                float typeVolume = mStreamTypes[track->type()].volume;
2178                float v = masterVolume * typeVolume;
2179                vl = (uint32_t)(v * cblk->volume[0]) << 12;
2180                vr = (uint32_t)(v * cblk->volume[1]) << 12;
2181
2182                va = (uint32_t)(v * cblk->sendLevel);
2183            }
2184            // Delegate volume control to effect in track effect chain if needed
2185            if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
2186                // Do not ramp volume if volume is controlled by effect
2187                param = AudioMixer::VOLUME;
2188                track->mHasVolumeController = true;
2189            } else {
2190                // force no volume ramp when volume controller was just disabled or removed
2191                // from effect chain to avoid volume spike
2192                if (track->mHasVolumeController) {
2193                    param = AudioMixer::VOLUME;
2194                }
2195                track->mHasVolumeController = false;
2196            }
2197
2198            // Convert volumes from 8.24 to 4.12 format
2199            int16_t left, right, aux;
2200            uint32_t v_clamped = (vl + (1 << 11)) >> 12;
2201            if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT;
2202            left = int16_t(v_clamped);
2203            v_clamped = (vr + (1 << 11)) >> 12;
2204            if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT;
2205            right = int16_t(v_clamped);
2206
2207            if (va > MAX_GAIN_INT) va = MAX_GAIN_INT;
2208            aux = int16_t(va);
2209
2210            // XXX: these things DON'T need to be done each time
2211            mAudioMixer->setBufferProvider(track);
2212            mAudioMixer->enable(AudioMixer::MIXING);
2213
2214            mAudioMixer->setParameter(param, AudioMixer::VOLUME0, (void *)left);
2215            mAudioMixer->setParameter(param, AudioMixer::VOLUME1, (void *)right);
2216            mAudioMixer->setParameter(param, AudioMixer::AUXLEVEL, (void *)aux);
2217            mAudioMixer->setParameter(
2218                AudioMixer::TRACK,
2219                AudioMixer::FORMAT, (void *)track->format());
2220            mAudioMixer->setParameter(
2221                AudioMixer::TRACK,
2222                AudioMixer::CHANNEL_MASK, (void *)track->channelMask());
2223            mAudioMixer->setParameter(
2224                AudioMixer::RESAMPLE,
2225                AudioMixer::SAMPLE_RATE,
2226                (void *)(cblk->sampleRate));
2227            mAudioMixer->setParameter(
2228                AudioMixer::TRACK,
2229                AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
2230            mAudioMixer->setParameter(
2231                AudioMixer::TRACK,
2232                AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
2233
2234            // reset retry count
2235            track->mRetryCount = kMaxTrackRetries;
2236            // If one track is ready, set the mixer ready if:
2237            //  - the mixer was not ready during previous round OR
2238            //  - no other track is not ready
2239            if (mPrevMixerStatus != MIXER_TRACKS_READY ||
2240                    mixerStatus != MIXER_TRACKS_ENABLED) {
2241                mixerStatus = MIXER_TRACKS_READY;
2242            }
2243        } else {
2244            //LOGV("track %d u=%08x, s=%08x [NOT READY] on thread %p", track->name(), cblk->user, cblk->server, this);
2245            if (track->isStopped()) {
2246                track->reset();
2247            }
2248            if (track->isTerminated() || track->isStopped() || track->isPaused()) {
2249                // We have consumed all the buffers of this track.
2250                // Remove it from the list of active tracks.
2251                tracksToRemove->add(track);
2252            } else {
2253                // No buffers for this track. Give it a few chances to
2254                // fill a buffer, then remove it from active list.
2255                if (--(track->mRetryCount) <= 0) {
2256                    LOGV("BUFFER TIMEOUT: remove(%d) from active list on thread %p", track->name(), this);
2257                    tracksToRemove->add(track);
2258                    // indicate to client process that the track was disabled because of underrun
2259                    android_atomic_or(CBLK_DISABLED_ON, &cblk->flags);
2260                // If one track is not ready, mark the mixer also not ready if:
2261                //  - the mixer was ready during previous round OR
2262                //  - no other track is ready
2263                } else if (mPrevMixerStatus == MIXER_TRACKS_READY ||
2264                                mixerStatus != MIXER_TRACKS_READY) {
2265                    mixerStatus = MIXER_TRACKS_ENABLED;
2266                }
2267            }
2268            mAudioMixer->disable(AudioMixer::MIXING);
2269        }
2270    }
2271
2272    // remove all the tracks that need to be...
2273    count = tracksToRemove->size();
2274    if (UNLIKELY(count)) {
2275        for (size_t i=0 ; i<count ; i++) {
2276            const sp<Track>& track = tracksToRemove->itemAt(i);
2277            mActiveTracks.remove(track);
2278            if (track->mainBuffer() != mMixBuffer) {
2279                chain = getEffectChain_l(track->sessionId());
2280                if (chain != 0) {
2281                    LOGV("stopping track on chain %p for session Id: %d", chain.get(), track->sessionId());
2282                    chain->decActiveTrackCnt();
2283                }
2284            }
2285            if (track->isTerminated()) {
2286                removeTrack_l(track);
2287            }
2288        }
2289    }
2290
2291    // mix buffer must be cleared if all tracks are connected to an
2292    // effect chain as in this case the mixer will not write to
2293    // mix buffer and track effects will accumulate into it
2294    if (mixedTracks != 0 && mixedTracks == tracksWithEffect) {
2295        memset(mMixBuffer, 0, mFrameCount * mChannelCount * sizeof(int16_t));
2296    }
2297
2298    mPrevMixerStatus = mixerStatus;
2299    return mixerStatus;
2300}
2301
2302void AudioFlinger::MixerThread::invalidateTracks(int streamType)
2303{
2304    LOGV ("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %d",
2305            this,  streamType, mTracks.size());
2306    Mutex::Autolock _l(mLock);
2307
2308    size_t size = mTracks.size();
2309    for (size_t i = 0; i < size; i++) {
2310        sp<Track> t = mTracks[i];
2311        if (t->type() == streamType) {
2312            android_atomic_or(CBLK_INVALID_ON, &t->mCblk->flags);
2313            t->mCblk->cv.signal();
2314        }
2315    }
2316}
2317
2318void AudioFlinger::PlaybackThread::setStreamValid(int streamType, bool valid)
2319{
2320    LOGV ("PlaybackThread::setStreamValid() thread %p, streamType %d, valid %d",
2321            this,  streamType, valid);
2322    Mutex::Autolock _l(mLock);
2323
2324    mStreamTypes[streamType].valid = valid;
2325}
2326
2327// getTrackName_l() must be called with ThreadBase::mLock held
2328int AudioFlinger::MixerThread::getTrackName_l()
2329{
2330    return mAudioMixer->getTrackName();
2331}
2332
2333// deleteTrackName_l() must be called with ThreadBase::mLock held
2334void AudioFlinger::MixerThread::deleteTrackName_l(int name)
2335{
2336    LOGV("remove track (%d) and delete from mixer", name);
2337    mAudioMixer->deleteTrackName(name);
2338}
2339
2340// checkForNewParameters_l() must be called with ThreadBase::mLock held
2341bool AudioFlinger::MixerThread::checkForNewParameters_l()
2342{
2343    bool reconfig = false;
2344
2345    while (!mNewParameters.isEmpty()) {
2346        status_t status = NO_ERROR;
2347        String8 keyValuePair = mNewParameters[0];
2348        AudioParameter param = AudioParameter(keyValuePair);
2349        int value;
2350
2351        if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
2352            reconfig = true;
2353        }
2354        if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
2355            if (value != AUDIO_FORMAT_PCM_16_BIT) {
2356                status = BAD_VALUE;
2357            } else {
2358                reconfig = true;
2359            }
2360        }
2361        if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
2362            if (value != AUDIO_CHANNEL_OUT_STEREO) {
2363                status = BAD_VALUE;
2364            } else {
2365                reconfig = true;
2366            }
2367        }
2368        if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
2369            // do not accept frame count changes if tracks are open as the track buffer
2370            // size depends on frame count and correct behavior would not be garantied
2371            // if frame count is changed after track creation
2372            if (!mTracks.isEmpty()) {
2373                status = INVALID_OPERATION;
2374            } else {
2375                reconfig = true;
2376            }
2377        }
2378        if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
2379            // when changing the audio output device, call addBatteryData to notify
2380            // the change
2381            if ((int)mDevice != value) {
2382                uint32_t params = 0;
2383                // check whether speaker is on
2384                if (value & AUDIO_DEVICE_OUT_SPEAKER) {
2385                    params |= IMediaPlayerService::kBatteryDataSpeakerOn;
2386                }
2387
2388                int deviceWithoutSpeaker
2389                    = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER;
2390                // check if any other device (except speaker) is on
2391                if (value & deviceWithoutSpeaker ) {
2392                    params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
2393                }
2394
2395                if (params != 0) {
2396                    addBatteryData(params);
2397                }
2398            }
2399
2400            // forward device change to effects that have requested to be
2401            // aware of attached audio device.
2402            mDevice = (uint32_t)value;
2403            for (size_t i = 0; i < mEffectChains.size(); i++) {
2404                mEffectChains[i]->setDevice_l(mDevice);
2405            }
2406        }
2407
2408        if (status == NO_ERROR) {
2409            status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
2410                                                    keyValuePair.string());
2411            if (!mStandby && status == INVALID_OPERATION) {
2412               mOutput->stream->common.standby(&mOutput->stream->common);
2413               mStandby = true;
2414               mBytesWritten = 0;
2415               status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
2416                                                       keyValuePair.string());
2417            }
2418            if (status == NO_ERROR && reconfig) {
2419                delete mAudioMixer;
2420                readOutputParameters();
2421                mAudioMixer = new AudioMixer(mFrameCount, mSampleRate);
2422                for (size_t i = 0; i < mTracks.size() ; i++) {
2423                    int name = getTrackName_l();
2424                    if (name < 0) break;
2425                    mTracks[i]->mName = name;
2426                    // limit track sample rate to 2 x new output sample rate
2427                    if (mTracks[i]->mCblk->sampleRate > 2 * sampleRate()) {
2428                        mTracks[i]->mCblk->sampleRate = 2 * sampleRate();
2429                    }
2430                }
2431                sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
2432            }
2433        }
2434
2435        mNewParameters.removeAt(0);
2436
2437        mParamStatus = status;
2438        mParamCond.signal();
2439        // wait for condition with time out in case the thread calling ThreadBase::setParameters()
2440        // already timed out waiting for the status and will never signal the condition.
2441        mWaitWorkCV.waitRelative(mLock, kSetParametersTimeout);
2442    }
2443    return reconfig;
2444}
2445
2446status_t AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16>& args)
2447{
2448    const size_t SIZE = 256;
2449    char buffer[SIZE];
2450    String8 result;
2451
2452    PlaybackThread::dumpInternals(fd, args);
2453
2454    snprintf(buffer, SIZE, "AudioMixer tracks: %08x\n", mAudioMixer->trackNames());
2455    result.append(buffer);
2456    write(fd, result.string(), result.size());
2457    return NO_ERROR;
2458}
2459
2460uint32_t AudioFlinger::MixerThread::idleSleepTimeUs()
2461{
2462    return (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
2463}
2464
2465uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs()
2466{
2467    return (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
2468}
2469
2470// ----------------------------------------------------------------------------
2471AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device)
2472    :   PlaybackThread(audioFlinger, output, id, device)
2473{
2474    mType = ThreadBase::DIRECT;
2475}
2476
2477AudioFlinger::DirectOutputThread::~DirectOutputThread()
2478{
2479}
2480
2481
2482static inline int16_t clamp16(int32_t sample)
2483{
2484    if ((sample>>15) ^ (sample>>31))
2485        sample = 0x7FFF ^ (sample>>31);
2486    return sample;
2487}
2488
2489static inline
2490int32_t mul(int16_t in, int16_t v)
2491{
2492#if defined(__arm__) && !defined(__thumb__)
2493    int32_t out;
2494    asm( "smulbb %[out], %[in], %[v] \n"
2495         : [out]"=r"(out)
2496         : [in]"%r"(in), [v]"r"(v)
2497         : );
2498    return out;
2499#else
2500    return in * int32_t(v);
2501#endif
2502}
2503
2504void AudioFlinger::DirectOutputThread::applyVolume(uint16_t leftVol, uint16_t rightVol, bool ramp)
2505{
2506    // Do not apply volume on compressed audio
2507    if (!audio_is_linear_pcm(mFormat)) {
2508        return;
2509    }
2510
2511    // convert to signed 16 bit before volume calculation
2512    if (mFormat == AUDIO_FORMAT_PCM_8_BIT) {
2513        size_t count = mFrameCount * mChannelCount;
2514        uint8_t *src = (uint8_t *)mMixBuffer + count-1;
2515        int16_t *dst = mMixBuffer + count-1;
2516        while(count--) {
2517            *dst-- = (int16_t)(*src--^0x80) << 8;
2518        }
2519    }
2520
2521    size_t frameCount = mFrameCount;
2522    int16_t *out = mMixBuffer;
2523    if (ramp) {
2524        if (mChannelCount == 1) {
2525            int32_t d = ((int32_t)leftVol - (int32_t)mLeftVolShort) << 16;
2526            int32_t vlInc = d / (int32_t)frameCount;
2527            int32_t vl = ((int32_t)mLeftVolShort << 16);
2528            do {
2529                out[0] = clamp16(mul(out[0], vl >> 16) >> 12);
2530                out++;
2531                vl += vlInc;
2532            } while (--frameCount);
2533
2534        } else {
2535            int32_t d = ((int32_t)leftVol - (int32_t)mLeftVolShort) << 16;
2536            int32_t vlInc = d / (int32_t)frameCount;
2537            d = ((int32_t)rightVol - (int32_t)mRightVolShort) << 16;
2538            int32_t vrInc = d / (int32_t)frameCount;
2539            int32_t vl = ((int32_t)mLeftVolShort << 16);
2540            int32_t vr = ((int32_t)mRightVolShort << 16);
2541            do {
2542                out[0] = clamp16(mul(out[0], vl >> 16) >> 12);
2543                out[1] = clamp16(mul(out[1], vr >> 16) >> 12);
2544                out += 2;
2545                vl += vlInc;
2546                vr += vrInc;
2547            } while (--frameCount);
2548        }
2549    } else {
2550        if (mChannelCount == 1) {
2551            do {
2552                out[0] = clamp16(mul(out[0], leftVol) >> 12);
2553                out++;
2554            } while (--frameCount);
2555        } else {
2556            do {
2557                out[0] = clamp16(mul(out[0], leftVol) >> 12);
2558                out[1] = clamp16(mul(out[1], rightVol) >> 12);
2559                out += 2;
2560            } while (--frameCount);
2561        }
2562    }
2563
2564    // convert back to unsigned 8 bit after volume calculation
2565    if (mFormat == AUDIO_FORMAT_PCM_8_BIT) {
2566        size_t count = mFrameCount * mChannelCount;
2567        int16_t *src = mMixBuffer;
2568        uint8_t *dst = (uint8_t *)mMixBuffer;
2569        while(count--) {
2570            *dst++ = (uint8_t)(((int32_t)*src++ + (1<<7)) >> 8)^0x80;
2571        }
2572    }
2573
2574    mLeftVolShort = leftVol;
2575    mRightVolShort = rightVol;
2576}
2577
2578bool AudioFlinger::DirectOutputThread::threadLoop()
2579{
2580    uint32_t mixerStatus = MIXER_IDLE;
2581    sp<Track> trackToRemove;
2582    sp<Track> activeTrack;
2583    nsecs_t standbyTime = systemTime();
2584    int8_t *curBuf;
2585    size_t mixBufferSize = mFrameCount*mFrameSize;
2586    uint32_t activeSleepTime = activeSleepTimeUs();
2587    uint32_t idleSleepTime = idleSleepTimeUs();
2588    uint32_t sleepTime = idleSleepTime;
2589    // use shorter standby delay as on normal output to release
2590    // hardware resources as soon as possible
2591    nsecs_t standbyDelay = microseconds(activeSleepTime*2);
2592
2593    acquireWakeLock();
2594
2595    while (!exitPending())
2596    {
2597        bool rampVolume;
2598        uint16_t leftVol;
2599        uint16_t rightVol;
2600        Vector< sp<EffectChain> > effectChains;
2601
2602        processConfigEvents();
2603
2604        mixerStatus = MIXER_IDLE;
2605
2606        { // scope for the mLock
2607
2608            Mutex::Autolock _l(mLock);
2609
2610            if (checkForNewParameters_l()) {
2611                mixBufferSize = mFrameCount*mFrameSize;
2612                activeSleepTime = activeSleepTimeUs();
2613                idleSleepTime = idleSleepTimeUs();
2614                standbyDelay = microseconds(activeSleepTime*2);
2615            }
2616
2617            // put audio hardware into standby after short delay
2618            if UNLIKELY((!mActiveTracks.size() && systemTime() > standbyTime) ||
2619                        mSuspended) {
2620                // wait until we have something to do...
2621                if (!mStandby) {
2622                    LOGV("Audio hardware entering standby, mixer %p\n", this);
2623                    mOutput->stream->common.standby(&mOutput->stream->common);
2624                    mStandby = true;
2625                    mBytesWritten = 0;
2626                }
2627
2628                if (!mActiveTracks.size() && mConfigEvents.isEmpty()) {
2629                    // we're about to wait, flush the binder command buffer
2630                    IPCThreadState::self()->flushCommands();
2631
2632                    if (exitPending()) break;
2633
2634                    releaseWakeLock_l();
2635                    LOGV("DirectOutputThread %p TID %d going to sleep\n", this, gettid());
2636                    mWaitWorkCV.wait(mLock);
2637                    LOGV("DirectOutputThread %p TID %d waking up in active mode\n", this, gettid());
2638                    acquireWakeLock_l();
2639
2640                    if (mMasterMute == false) {
2641                        char value[PROPERTY_VALUE_MAX];
2642                        property_get("ro.audio.silent", value, "0");
2643                        if (atoi(value)) {
2644                            LOGD("Silence is golden");
2645                            setMasterMute(true);
2646                        }
2647                    }
2648
2649                    standbyTime = systemTime() + standbyDelay;
2650                    sleepTime = idleSleepTime;
2651                    continue;
2652                }
2653            }
2654
2655            effectChains = mEffectChains;
2656
2657            // find out which tracks need to be processed
2658            if (mActiveTracks.size() != 0) {
2659                sp<Track> t = mActiveTracks[0].promote();
2660                if (t == 0) continue;
2661
2662                Track* const track = t.get();
2663                audio_track_cblk_t* cblk = track->cblk();
2664
2665                // The first time a track is added we wait
2666                // for all its buffers to be filled before processing it
2667                if (cblk->framesReady() && track->isReady() &&
2668                        !track->isPaused() && !track->isTerminated())
2669                {
2670                    //LOGV("track %d u=%08x, s=%08x [OK]", track->name(), cblk->user, cblk->server);
2671
2672                    if (track->mFillingUpStatus == Track::FS_FILLED) {
2673                        track->mFillingUpStatus = Track::FS_ACTIVE;
2674                        mLeftVolFloat = mRightVolFloat = 0;
2675                        mLeftVolShort = mRightVolShort = 0;
2676                        if (track->mState == TrackBase::RESUMING) {
2677                            track->mState = TrackBase::ACTIVE;
2678                            rampVolume = true;
2679                        }
2680                    } else if (cblk->server != 0) {
2681                        // If the track is stopped before the first frame was mixed,
2682                        // do not apply ramp
2683                        rampVolume = true;
2684                    }
2685                    // compute volume for this track
2686                    float left, right;
2687                    if (track->isMuted() || mMasterMute || track->isPausing() ||
2688                        mStreamTypes[track->type()].mute) {
2689                        left = right = 0;
2690                        if (track->isPausing()) {
2691                            track->setPaused();
2692                        }
2693                    } else {
2694                        float typeVolume = mStreamTypes[track->type()].volume;
2695                        float v = mMasterVolume * typeVolume;
2696                        float v_clamped = v * cblk->volume[0];
2697                        if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
2698                        left = v_clamped/MAX_GAIN;
2699                        v_clamped = v * cblk->volume[1];
2700                        if (v_clamped > MAX_GAIN) v_clamped = MAX_GAIN;
2701                        right = v_clamped/MAX_GAIN;
2702                    }
2703
2704                    if (left != mLeftVolFloat || right != mRightVolFloat) {
2705                        mLeftVolFloat = left;
2706                        mRightVolFloat = right;
2707
2708                        // If audio HAL implements volume control,
2709                        // force software volume to nominal value
2710                        if (mOutput->stream->set_volume(mOutput->stream, left, right) == NO_ERROR) {
2711                            left = 1.0f;
2712                            right = 1.0f;
2713                        }
2714
2715                        // Convert volumes from float to 8.24
2716                        uint32_t vl = (uint32_t)(left * (1 << 24));
2717                        uint32_t vr = (uint32_t)(right * (1 << 24));
2718
2719                        // Delegate volume control to effect in track effect chain if needed
2720                        // only one effect chain can be present on DirectOutputThread, so if
2721                        // there is one, the track is connected to it
2722                        if (!effectChains.isEmpty()) {
2723                            // Do not ramp volume if volume is controlled by effect
2724                            if(effectChains[0]->setVolume_l(&vl, &vr)) {
2725                                rampVolume = false;
2726                            }
2727                        }
2728
2729                        // Convert volumes from 8.24 to 4.12 format
2730                        uint32_t v_clamped = (vl + (1 << 11)) >> 12;
2731                        if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT;
2732                        leftVol = (uint16_t)v_clamped;
2733                        v_clamped = (vr + (1 << 11)) >> 12;
2734                        if (v_clamped > MAX_GAIN_INT) v_clamped = MAX_GAIN_INT;
2735                        rightVol = (uint16_t)v_clamped;
2736                    } else {
2737                        leftVol = mLeftVolShort;
2738                        rightVol = mRightVolShort;
2739                        rampVolume = false;
2740                    }
2741
2742                    // reset retry count
2743                    track->mRetryCount = kMaxTrackRetriesDirect;
2744                    activeTrack = t;
2745                    mixerStatus = MIXER_TRACKS_READY;
2746                } else {
2747                    //LOGV("track %d u=%08x, s=%08x [NOT READY]", track->name(), cblk->user, cblk->server);
2748                    if (track->isStopped()) {
2749                        track->reset();
2750                    }
2751                    if (track->isTerminated() || track->isStopped() || track->isPaused()) {
2752                        // We have consumed all the buffers of this track.
2753                        // Remove it from the list of active tracks.
2754                        trackToRemove = track;
2755                    } else {
2756                        // No buffers for this track. Give it a few chances to
2757                        // fill a buffer, then remove it from active list.
2758                        if (--(track->mRetryCount) <= 0) {
2759                            LOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name());
2760                            trackToRemove = track;
2761                        } else {
2762                            mixerStatus = MIXER_TRACKS_ENABLED;
2763                        }
2764                    }
2765                }
2766            }
2767
2768            // remove all the tracks that need to be...
2769            if (UNLIKELY(trackToRemove != 0)) {
2770                mActiveTracks.remove(trackToRemove);
2771                if (!effectChains.isEmpty()) {
2772                    LOGV("stopping track on chain %p for session Id: %d", effectChains[0].get(),
2773                            trackToRemove->sessionId());
2774                    effectChains[0]->decActiveTrackCnt();
2775                }
2776                if (trackToRemove->isTerminated()) {
2777                    removeTrack_l(trackToRemove);
2778                }
2779            }
2780
2781            lockEffectChains_l(effectChains);
2782       }
2783
2784        if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
2785            AudioBufferProvider::Buffer buffer;
2786            size_t frameCount = mFrameCount;
2787            curBuf = (int8_t *)mMixBuffer;
2788            // output audio to hardware
2789            while (frameCount) {
2790                buffer.frameCount = frameCount;
2791                activeTrack->getNextBuffer(&buffer);
2792                if (UNLIKELY(buffer.raw == 0)) {
2793                    memset(curBuf, 0, frameCount * mFrameSize);
2794                    break;
2795                }
2796                memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
2797                frameCount -= buffer.frameCount;
2798                curBuf += buffer.frameCount * mFrameSize;
2799                activeTrack->releaseBuffer(&buffer);
2800            }
2801            sleepTime = 0;
2802            standbyTime = systemTime() + standbyDelay;
2803        } else {
2804            if (sleepTime == 0) {
2805                if (mixerStatus == MIXER_TRACKS_ENABLED) {
2806                    sleepTime = activeSleepTime;
2807                } else {
2808                    sleepTime = idleSleepTime;
2809                }
2810            } else if (mBytesWritten != 0 && audio_is_linear_pcm(mFormat)) {
2811                memset (mMixBuffer, 0, mFrameCount * mFrameSize);
2812                sleepTime = 0;
2813            }
2814        }
2815
2816        if (mSuspended) {
2817            sleepTime = suspendSleepTimeUs();
2818        }
2819        // sleepTime == 0 means we must write to audio hardware
2820        if (sleepTime == 0) {
2821            if (mixerStatus == MIXER_TRACKS_READY) {
2822                applyVolume(leftVol, rightVol, rampVolume);
2823            }
2824            for (size_t i = 0; i < effectChains.size(); i ++) {
2825                effectChains[i]->process_l();
2826            }
2827            unlockEffectChains(effectChains);
2828
2829            mLastWriteTime = systemTime();
2830            mInWrite = true;
2831            mBytesWritten += mixBufferSize;
2832            int bytesWritten = (int)mOutput->stream->write(mOutput->stream, mMixBuffer, mixBufferSize);
2833            if (bytesWritten < 0) mBytesWritten -= mixBufferSize;
2834            mNumWrites++;
2835            mInWrite = false;
2836            mStandby = false;
2837        } else {
2838            unlockEffectChains(effectChains);
2839            usleep(sleepTime);
2840        }
2841
2842        // finally let go of removed track, without the lock held
2843        // since we can't guarantee the destructors won't acquire that
2844        // same lock.
2845        trackToRemove.clear();
2846        activeTrack.clear();
2847
2848        // Effect chains will be actually deleted here if they were removed from
2849        // mEffectChains list during mixing or effects processing
2850        effectChains.clear();
2851    }
2852
2853    if (!mStandby) {
2854        mOutput->stream->common.standby(&mOutput->stream->common);
2855    }
2856
2857    releaseWakeLock();
2858
2859    LOGV("DirectOutputThread %p exiting", this);
2860    return false;
2861}
2862
2863// getTrackName_l() must be called with ThreadBase::mLock held
2864int AudioFlinger::DirectOutputThread::getTrackName_l()
2865{
2866    return 0;
2867}
2868
2869// deleteTrackName_l() must be called with ThreadBase::mLock held
2870void AudioFlinger::DirectOutputThread::deleteTrackName_l(int name)
2871{
2872}
2873
2874// checkForNewParameters_l() must be called with ThreadBase::mLock held
2875bool AudioFlinger::DirectOutputThread::checkForNewParameters_l()
2876{
2877    bool reconfig = false;
2878
2879    while (!mNewParameters.isEmpty()) {
2880        status_t status = NO_ERROR;
2881        String8 keyValuePair = mNewParameters[0];
2882        AudioParameter param = AudioParameter(keyValuePair);
2883        int value;
2884
2885        if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
2886            // do not accept frame count changes if tracks are open as the track buffer
2887            // size depends on frame count and correct behavior would not be garantied
2888            // if frame count is changed after track creation
2889            if (!mTracks.isEmpty()) {
2890                status = INVALID_OPERATION;
2891            } else {
2892                reconfig = true;
2893            }
2894        }
2895        if (status == NO_ERROR) {
2896            status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
2897                                                    keyValuePair.string());
2898            if (!mStandby && status == INVALID_OPERATION) {
2899               mOutput->stream->common.standby(&mOutput->stream->common);
2900               mStandby = true;
2901               mBytesWritten = 0;
2902               status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
2903                                                       keyValuePair.string());
2904            }
2905            if (status == NO_ERROR && reconfig) {
2906                readOutputParameters();
2907                sendConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
2908            }
2909        }
2910
2911        mNewParameters.removeAt(0);
2912
2913        mParamStatus = status;
2914        mParamCond.signal();
2915        // wait for condition with time out in case the thread calling ThreadBase::setParameters()
2916        // already timed out waiting for the status and will never signal the condition.
2917        mWaitWorkCV.waitRelative(mLock, kSetParametersTimeout);
2918    }
2919    return reconfig;
2920}
2921
2922uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs()
2923{
2924    uint32_t time;
2925    if (audio_is_linear_pcm(mFormat)) {
2926        time = PlaybackThread::activeSleepTimeUs();
2927    } else {
2928        time = 10000;
2929    }
2930    return time;
2931}
2932
2933uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs()
2934{
2935    uint32_t time;
2936    if (audio_is_linear_pcm(mFormat)) {
2937        time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
2938    } else {
2939        time = 10000;
2940    }
2941    return time;
2942}
2943
2944uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs()
2945{
2946    uint32_t time;
2947    if (audio_is_linear_pcm(mFormat)) {
2948        time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
2949    } else {
2950        time = 10000;
2951    }
2952    return time;
2953}
2954
2955
2956// ----------------------------------------------------------------------------
2957
2958AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger, AudioFlinger::MixerThread* mainThread, int id)
2959    :   MixerThread(audioFlinger, mainThread->getOutput(), id, mainThread->device()), mWaitTimeMs(UINT_MAX)
2960{
2961    mType = ThreadBase::DUPLICATING;
2962    addOutputTrack(mainThread);
2963}
2964
2965AudioFlinger::DuplicatingThread::~DuplicatingThread()
2966{
2967    for (size_t i = 0; i < mOutputTracks.size(); i++) {
2968        mOutputTracks[i]->destroy();
2969    }
2970    mOutputTracks.clear();
2971}
2972
2973bool AudioFlinger::DuplicatingThread::threadLoop()
2974{
2975    Vector< sp<Track> > tracksToRemove;
2976    uint32_t mixerStatus = MIXER_IDLE;
2977    nsecs_t standbyTime = systemTime();
2978    size_t mixBufferSize = mFrameCount*mFrameSize;
2979    SortedVector< sp<OutputTrack> > outputTracks;
2980    uint32_t writeFrames = 0;
2981    uint32_t activeSleepTime = activeSleepTimeUs();
2982    uint32_t idleSleepTime = idleSleepTimeUs();
2983    uint32_t sleepTime = idleSleepTime;
2984    Vector< sp<EffectChain> > effectChains;
2985
2986    acquireWakeLock();
2987
2988    while (!exitPending())
2989    {
2990        processConfigEvents();
2991
2992        mixerStatus = MIXER_IDLE;
2993        { // scope for the mLock
2994
2995            Mutex::Autolock _l(mLock);
2996
2997            if (checkForNewParameters_l()) {
2998                mixBufferSize = mFrameCount*mFrameSize;
2999                updateWaitTime();
3000                activeSleepTime = activeSleepTimeUs();
3001                idleSleepTime = idleSleepTimeUs();
3002            }
3003
3004            const SortedVector< wp<Track> >& activeTracks = mActiveTracks;
3005
3006            for (size_t i = 0; i < mOutputTracks.size(); i++) {
3007                outputTracks.add(mOutputTracks[i]);
3008            }
3009
3010            // put audio hardware into standby after short delay
3011            if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) ||
3012                         mSuspended) {
3013                if (!mStandby) {
3014                    for (size_t i = 0; i < outputTracks.size(); i++) {
3015                        outputTracks[i]->stop();
3016                    }
3017                    mStandby = true;
3018                    mBytesWritten = 0;
3019                }
3020
3021                if (!activeTracks.size() && mConfigEvents.isEmpty()) {
3022                    // we're about to wait, flush the binder command buffer
3023                    IPCThreadState::self()->flushCommands();
3024                    outputTracks.clear();
3025
3026                    if (exitPending()) break;
3027
3028                    releaseWakeLock_l();
3029                    LOGV("DuplicatingThread %p TID %d going to sleep\n", this, gettid());
3030                    mWaitWorkCV.wait(mLock);
3031                    LOGV("DuplicatingThread %p TID %d waking up\n", this, gettid());
3032                    acquireWakeLock_l();
3033
3034                    mPrevMixerStatus = MIXER_IDLE;
3035                    if (mMasterMute == false) {
3036                        char value[PROPERTY_VALUE_MAX];
3037                        property_get("ro.audio.silent", value, "0");
3038                        if (atoi(value)) {
3039                            LOGD("Silence is golden");
3040                            setMasterMute(true);
3041                        }
3042                    }
3043
3044                    standbyTime = systemTime() + kStandbyTimeInNsecs;
3045                    sleepTime = idleSleepTime;
3046                    continue;
3047                }
3048            }
3049
3050            mixerStatus = prepareTracks_l(activeTracks, &tracksToRemove);
3051
3052            // prevent any changes in effect chain list and in each effect chain
3053            // during mixing and effect process as the audio buffers could be deleted
3054            // or modified if an effect is created or deleted
3055            lockEffectChains_l(effectChains);
3056        }
3057
3058        if (LIKELY(mixerStatus == MIXER_TRACKS_READY)) {
3059            // mix buffers...
3060            if (outputsReady(outputTracks)) {
3061                mAudioMixer->process();
3062            } else {
3063                memset(mMixBuffer, 0, mixBufferSize);
3064            }
3065            sleepTime = 0;
3066            writeFrames = mFrameCount;
3067        } else {
3068            if (sleepTime == 0) {
3069                if (mixerStatus == MIXER_TRACKS_ENABLED) {
3070                    sleepTime = activeSleepTime;
3071                } else {
3072                    sleepTime = idleSleepTime;
3073                }
3074            } else if (mBytesWritten != 0) {
3075                // flush remaining overflow buffers in output tracks
3076                for (size_t i = 0; i < outputTracks.size(); i++) {
3077                    if (outputTracks[i]->isActive()) {
3078                        sleepTime = 0;
3079                        writeFrames = 0;
3080                        memset(mMixBuffer, 0, mixBufferSize);
3081                        break;
3082                    }
3083                }
3084            }
3085        }
3086
3087        if (mSuspended) {
3088            sleepTime = suspendSleepTimeUs();
3089        }
3090        // sleepTime == 0 means we must write to audio hardware
3091        if (sleepTime == 0) {
3092            for (size_t i = 0; i < effectChains.size(); i ++) {
3093                effectChains[i]->process_l();
3094            }
3095            // enable changes in effect chain
3096            unlockEffectChains(effectChains);
3097
3098            standbyTime = systemTime() + kStandbyTimeInNsecs;
3099            for (size_t i = 0; i < outputTracks.size(); i++) {
3100                outputTracks[i]->write(mMixBuffer, writeFrames);
3101            }
3102            mStandby = false;
3103            mBytesWritten += mixBufferSize;
3104        } else {
3105            // enable changes in effect chain
3106            unlockEffectChains(effectChains);
3107            usleep(sleepTime);
3108        }
3109
3110        // finally let go of all our tracks, without the lock held
3111        // since we can't guarantee the destructors won't acquire that
3112        // same lock.
3113        tracksToRemove.clear();
3114        outputTracks.clear();
3115
3116        // Effect chains will be actually deleted here if they were removed from
3117        // mEffectChains list during mixing or effects processing
3118        effectChains.clear();
3119    }
3120
3121    releaseWakeLock();
3122
3123    return false;
3124}
3125
3126void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
3127{
3128    int frameCount = (3 * mFrameCount * mSampleRate) / thread->sampleRate();
3129    OutputTrack *outputTrack = new OutputTrack((ThreadBase *)thread,
3130                                            this,
3131                                            mSampleRate,
3132                                            mFormat,
3133                                            mChannelMask,
3134                                            frameCount);
3135    if (outputTrack->cblk() != NULL) {
3136        thread->setStreamVolume(AUDIO_STREAM_CNT, 1.0f);
3137        mOutputTracks.add(outputTrack);
3138        LOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread);
3139        updateWaitTime();
3140    }
3141}
3142
3143void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
3144{
3145    Mutex::Autolock _l(mLock);
3146    for (size_t i = 0; i < mOutputTracks.size(); i++) {
3147        if (mOutputTracks[i]->thread() == (ThreadBase *)thread) {
3148            mOutputTracks[i]->destroy();
3149            mOutputTracks.removeAt(i);
3150            updateWaitTime();
3151            return;
3152        }
3153    }
3154    LOGV("removeOutputTrack(): unkonwn thread: %p", thread);
3155}
3156
3157void AudioFlinger::DuplicatingThread::updateWaitTime()
3158{
3159    mWaitTimeMs = UINT_MAX;
3160    for (size_t i = 0; i < mOutputTracks.size(); i++) {
3161        sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
3162        if (strong != NULL) {
3163            uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
3164            if (waitTimeMs < mWaitTimeMs) {
3165                mWaitTimeMs = waitTimeMs;
3166            }
3167        }
3168    }
3169}
3170
3171
3172bool AudioFlinger::DuplicatingThread::outputsReady(SortedVector< sp<OutputTrack> > &outputTracks)
3173{
3174    for (size_t i = 0; i < outputTracks.size(); i++) {
3175        sp <ThreadBase> thread = outputTracks[i]->thread().promote();
3176        if (thread == 0) {
3177            LOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p", outputTracks[i].get());
3178            return false;
3179        }
3180        PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
3181        if (playbackThread->standby() && !playbackThread->isSuspended()) {
3182            LOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(), thread.get());
3183            return false;
3184        }
3185    }
3186    return true;
3187}
3188
3189uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs()
3190{
3191    return (mWaitTimeMs * 1000) / 2;
3192}
3193
3194// ----------------------------------------------------------------------------
3195
3196// TrackBase constructor must be called with AudioFlinger::mLock held
3197AudioFlinger::ThreadBase::TrackBase::TrackBase(
3198            const wp<ThreadBase>& thread,
3199            const sp<Client>& client,
3200            uint32_t sampleRate,
3201            uint32_t format,
3202            uint32_t channelMask,
3203            int frameCount,
3204            uint32_t flags,
3205            const sp<IMemory>& sharedBuffer,
3206            int sessionId)
3207    :   RefBase(),
3208        mThread(thread),
3209        mClient(client),
3210        mCblk(0),
3211        mFrameCount(0),
3212        mState(IDLE),
3213        mClientTid(-1),
3214        mFormat(format),
3215        mFlags(flags & ~SYSTEM_FLAGS_MASK),
3216        mSessionId(sessionId)
3217{
3218    LOGV_IF(sharedBuffer != 0, "sharedBuffer: %p, size: %d", sharedBuffer->pointer(), sharedBuffer->size());
3219
3220    // LOGD("Creating track with %d buffers @ %d bytes", bufferCount, bufferSize);
3221   size_t size = sizeof(audio_track_cblk_t);
3222   uint8_t channelCount = popcount(channelMask);
3223   size_t bufferSize = frameCount*channelCount*sizeof(int16_t);
3224   if (sharedBuffer == 0) {
3225       size += bufferSize;
3226   }
3227
3228   if (client != NULL) {
3229        mCblkMemory = client->heap()->allocate(size);
3230        if (mCblkMemory != 0) {
3231            mCblk = static_cast<audio_track_cblk_t *>(mCblkMemory->pointer());
3232            if (mCblk) { // construct the shared structure in-place.
3233                new(mCblk) audio_track_cblk_t();
3234                // clear all buffers
3235                mCblk->frameCount = frameCount;
3236                mCblk->sampleRate = sampleRate;
3237                mChannelCount = channelCount;
3238                mChannelMask = channelMask;
3239                if (sharedBuffer == 0) {
3240                    mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
3241                    memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));
3242                    // Force underrun condition to avoid false underrun callback until first data is
3243                    // written to buffer (other flags are cleared)
3244                    mCblk->flags = CBLK_UNDERRUN_ON;
3245                } else {
3246                    mBuffer = sharedBuffer->pointer();
3247                }
3248                mBufferEnd = (uint8_t *)mBuffer + bufferSize;
3249            }
3250        } else {
3251            LOGE("not enough memory for AudioTrack size=%u", size);
3252            client->heap()->dump("AudioTrack");
3253            return;
3254        }
3255   } else {
3256       mCblk = (audio_track_cblk_t *)(new uint8_t[size]);
3257       if (mCblk) { // construct the shared structure in-place.
3258           new(mCblk) audio_track_cblk_t();
3259           // clear all buffers
3260           mCblk->frameCount = frameCount;
3261           mCblk->sampleRate = sampleRate;
3262           mChannelCount = channelCount;
3263           mChannelMask = channelMask;
3264           mBuffer = (char*)mCblk + sizeof(audio_track_cblk_t);
3265           memset(mBuffer, 0, frameCount*channelCount*sizeof(int16_t));
3266           // Force underrun condition to avoid false underrun callback until first data is
3267           // written to buffer (other flags are cleared)
3268           mCblk->flags = CBLK_UNDERRUN_ON;
3269           mBufferEnd = (uint8_t *)mBuffer + bufferSize;
3270       }
3271   }
3272}
3273
3274AudioFlinger::ThreadBase::TrackBase::~TrackBase()
3275{
3276    if (mCblk) {
3277        mCblk->~audio_track_cblk_t();   // destroy our shared-structure.
3278        if (mClient == NULL) {
3279            delete mCblk;
3280        }
3281    }
3282    mCblkMemory.clear();            // and free the shared memory
3283    if (mClient != NULL) {
3284        Mutex::Autolock _l(mClient->audioFlinger()->mLock);
3285        mClient.clear();
3286    }
3287}
3288
3289void AudioFlinger::ThreadBase::TrackBase::releaseBuffer(AudioBufferProvider::Buffer* buffer)
3290{
3291    buffer->raw = 0;
3292    mFrameCount = buffer->frameCount;
3293    step();
3294    buffer->frameCount = 0;
3295}
3296
3297bool AudioFlinger::ThreadBase::TrackBase::step() {
3298    bool result;
3299    audio_track_cblk_t* cblk = this->cblk();
3300
3301    result = cblk->stepServer(mFrameCount);
3302    if (!result) {
3303        LOGV("stepServer failed acquiring cblk mutex");
3304        mFlags |= STEPSERVER_FAILED;
3305    }
3306    return result;
3307}
3308
3309void AudioFlinger::ThreadBase::TrackBase::reset() {
3310    audio_track_cblk_t* cblk = this->cblk();
3311
3312    cblk->user = 0;
3313    cblk->server = 0;
3314    cblk->userBase = 0;
3315    cblk->serverBase = 0;
3316    mFlags &= (uint32_t)(~SYSTEM_FLAGS_MASK);
3317    LOGV("TrackBase::reset");
3318}
3319
3320sp<IMemory> AudioFlinger::ThreadBase::TrackBase::getCblk() const
3321{
3322    return mCblkMemory;
3323}
3324
3325int AudioFlinger::ThreadBase::TrackBase::sampleRate() const {
3326    return (int)mCblk->sampleRate;
3327}
3328
3329int AudioFlinger::ThreadBase::TrackBase::channelCount() const {
3330    return (const int)mChannelCount;
3331}
3332
3333uint32_t AudioFlinger::ThreadBase::TrackBase::channelMask() const {
3334    return mChannelMask;
3335}
3336
3337void* AudioFlinger::ThreadBase::TrackBase::getBuffer(uint32_t offset, uint32_t frames) const {
3338    audio_track_cblk_t* cblk = this->cblk();
3339    int8_t *bufferStart = (int8_t *)mBuffer + (offset-cblk->serverBase)*cblk->frameSize;
3340    int8_t *bufferEnd = bufferStart + frames * cblk->frameSize;
3341
3342    // Check validity of returned pointer in case the track control block would have been corrupted.
3343    if (bufferStart < mBuffer || bufferStart > bufferEnd || bufferEnd > mBufferEnd ||
3344        ((unsigned long)bufferStart & (unsigned long)(cblk->frameSize - 1))) {
3345        LOGE("TrackBase::getBuffer buffer out of range:\n    start: %p, end %p , mBuffer %p mBufferEnd %p\n    \
3346                server %d, serverBase %d, user %d, userBase %d",
3347                bufferStart, bufferEnd, mBuffer, mBufferEnd,
3348                cblk->server, cblk->serverBase, cblk->user, cblk->userBase);
3349        return 0;
3350    }
3351
3352    return bufferStart;
3353}
3354
3355// ----------------------------------------------------------------------------
3356
3357// Track constructor must be called with AudioFlinger::mLock and ThreadBase::mLock held
3358AudioFlinger::PlaybackThread::Track::Track(
3359            const wp<ThreadBase>& thread,
3360            const sp<Client>& client,
3361            int streamType,
3362            uint32_t sampleRate,
3363            uint32_t format,
3364            uint32_t channelMask,
3365            int frameCount,
3366            const sp<IMemory>& sharedBuffer,
3367            int sessionId)
3368    :   TrackBase(thread, client, sampleRate, format, channelMask, frameCount, 0, sharedBuffer, sessionId),
3369    mMute(false), mSharedBuffer(sharedBuffer), mName(-1), mMainBuffer(NULL), mAuxBuffer(NULL),
3370    mAuxEffectId(0), mHasVolumeController(false)
3371{
3372    if (mCblk != NULL) {
3373        sp<ThreadBase> baseThread = thread.promote();
3374        if (baseThread != 0) {
3375            PlaybackThread *playbackThread = (PlaybackThread *)baseThread.get();
3376            mName = playbackThread->getTrackName_l();
3377            mMainBuffer = playbackThread->mixBuffer();
3378        }
3379        LOGV("Track constructor name %d, calling thread %d", mName, IPCThreadState::self()->getCallingPid());
3380        if (mName < 0) {
3381            LOGE("no more track names available");
3382        }
3383        mVolume[0] = 1.0f;
3384        mVolume[1] = 1.0f;
3385        mStreamType = streamType;
3386        // NOTE: audio_track_cblk_t::frameSize for 8 bit PCM data is based on a sample size of
3387        // 16 bit because data is converted to 16 bit before being stored in buffer by AudioTrack
3388        mCblk->frameSize = audio_is_linear_pcm(format) ? mChannelCount * sizeof(int16_t) : sizeof(uint8_t);
3389    }
3390}
3391
3392AudioFlinger::PlaybackThread::Track::~Track()
3393{
3394    LOGV("PlaybackThread::Track destructor");
3395    sp<ThreadBase> thread = mThread.promote();
3396    if (thread != 0) {
3397        Mutex::Autolock _l(thread->mLock);
3398        mState = TERMINATED;
3399    }
3400}
3401
3402void AudioFlinger::PlaybackThread::Track::destroy()
3403{
3404    // NOTE: destroyTrack_l() can remove a strong reference to this Track
3405    // by removing it from mTracks vector, so there is a risk that this Tracks's
3406    // desctructor is called. As the destructor needs to lock mLock,
3407    // we must acquire a strong reference on this Track before locking mLock
3408    // here so that the destructor is called only when exiting this function.
3409    // On the other hand, as long as Track::destroy() is only called by
3410    // TrackHandle destructor, the TrackHandle still holds a strong ref on
3411    // this Track with its member mTrack.
3412    sp<Track> keep(this);
3413    { // scope for mLock
3414        sp<ThreadBase> thread = mThread.promote();
3415        if (thread != 0) {
3416            if (!isOutputTrack()) {
3417                if (mState == ACTIVE || mState == RESUMING) {
3418                    AudioSystem::stopOutput(thread->id(),
3419                                            (audio_stream_type_t)mStreamType,
3420                                            mSessionId);
3421
3422                    // to track the speaker usage
3423                    addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
3424                }
3425                AudioSystem::releaseOutput(thread->id());
3426            }
3427            Mutex::Autolock _l(thread->mLock);
3428            PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
3429            playbackThread->destroyTrack_l(this);
3430        }
3431    }
3432}
3433
3434void AudioFlinger::PlaybackThread::Track::dump(char* buffer, size_t size)
3435{
3436    snprintf(buffer, size, "   %05d %05d %03u %03u 0x%08x %05u   %04u %1d %1d %1d %05u %05u %05u  0x%08x 0x%08x 0x%08x 0x%08x\n",
3437            mName - AudioMixer::TRACK0,
3438            (mClient == NULL) ? getpid() : mClient->pid(),
3439            mStreamType,
3440            mFormat,
3441            mChannelMask,
3442            mSessionId,
3443            mFrameCount,
3444            mState,
3445            mMute,
3446            mFillingUpStatus,
3447            mCblk->sampleRate,
3448            mCblk->volume[0],
3449            mCblk->volume[1],
3450            mCblk->server,
3451            mCblk->user,
3452            (int)mMainBuffer,
3453            (int)mAuxBuffer);
3454}
3455
3456status_t AudioFlinger::PlaybackThread::Track::getNextBuffer(AudioBufferProvider::Buffer* buffer)
3457{
3458     audio_track_cblk_t* cblk = this->cblk();
3459     uint32_t framesReady;
3460     uint32_t framesReq = buffer->frameCount;
3461
3462     // Check if last stepServer failed, try to step now
3463     if (mFlags & TrackBase::STEPSERVER_FAILED) {
3464         if (!step())  goto getNextBuffer_exit;
3465         LOGV("stepServer recovered");
3466         mFlags &= ~TrackBase::STEPSERVER_FAILED;
3467     }
3468
3469     framesReady = cblk->framesReady();
3470
3471     if (LIKELY(framesReady)) {
3472        uint32_t s = cblk->server;
3473        uint32_t bufferEnd = cblk->serverBase + cblk->frameCount;
3474
3475        bufferEnd = (cblk->loopEnd < bufferEnd) ? cblk->loopEnd : bufferEnd;
3476        if (framesReq > framesReady) {
3477            framesReq = framesReady;
3478        }
3479        if (s + framesReq > bufferEnd) {
3480            framesReq = bufferEnd - s;
3481        }
3482
3483         buffer->raw = getBuffer(s, framesReq);
3484         if (buffer->raw == 0) goto getNextBuffer_exit;
3485
3486         buffer->frameCount = framesReq;
3487        return NO_ERROR;
3488     }
3489
3490getNextBuffer_exit:
3491     buffer->raw = 0;
3492     buffer->frameCount = 0;
3493     LOGV("getNextBuffer() no more data for track %d on thread %p", mName, mThread.unsafe_get());
3494     return NOT_ENOUGH_DATA;
3495}
3496
3497bool AudioFlinger::PlaybackThread::Track::isReady() const {
3498    if (mFillingUpStatus != FS_FILLING || isStopped() || isPausing()) return true;
3499
3500    if (mCblk->framesReady() >= mCblk->frameCount ||
3501            (mCblk->flags & CBLK_FORCEREADY_MSK)) {
3502        mFillingUpStatus = FS_FILLED;
3503        android_atomic_and(~CBLK_FORCEREADY_MSK, &mCblk->flags);
3504        return true;
3505    }
3506    return false;
3507}
3508
3509status_t AudioFlinger::PlaybackThread::Track::start()
3510{
3511    status_t status = NO_ERROR;
3512    LOGV("start(%d), calling thread %d session %d",
3513            mName, IPCThreadState::self()->getCallingPid(), mSessionId);
3514    sp<ThreadBase> thread = mThread.promote();
3515    if (thread != 0) {
3516        Mutex::Autolock _l(thread->mLock);
3517        int state = mState;
3518        // here the track could be either new, or restarted
3519        // in both cases "unstop" the track
3520        if (mState == PAUSED) {
3521            mState = TrackBase::RESUMING;
3522            LOGV("PAUSED => RESUMING (%d) on thread %p", mName, this);
3523        } else {
3524            mState = TrackBase::ACTIVE;
3525            LOGV("? => ACTIVE (%d) on thread %p", mName, this);
3526        }
3527
3528        if (!isOutputTrack() && state != ACTIVE && state != RESUMING) {
3529            thread->mLock.unlock();
3530            status = AudioSystem::startOutput(thread->id(),
3531                                              (audio_stream_type_t)mStreamType,
3532                                              mSessionId);
3533            thread->mLock.lock();
3534
3535            // to track the speaker usage
3536            if (status == NO_ERROR) {
3537                addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
3538            }
3539        }
3540        if (status == NO_ERROR) {
3541            PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
3542            playbackThread->addTrack_l(this);
3543        } else {
3544            mState = state;
3545        }
3546    } else {
3547        status = BAD_VALUE;
3548    }
3549    return status;
3550}
3551
3552void AudioFlinger::PlaybackThread::Track::stop()
3553{
3554    LOGV("stop(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid());
3555    sp<ThreadBase> thread = mThread.promote();
3556    if (thread != 0) {
3557        Mutex::Autolock _l(thread->mLock);
3558        int state = mState;
3559        if (mState > STOPPED) {
3560            mState = STOPPED;
3561            // If the track is not active (PAUSED and buffers full), flush buffers
3562            PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
3563            if (playbackThread->mActiveTracks.indexOf(this) < 0) {
3564                reset();
3565            }
3566            LOGV("(> STOPPED) => STOPPED (%d) on thread %p", mName, playbackThread);
3567        }
3568        if (!isOutputTrack() && (state == ACTIVE || state == RESUMING)) {
3569            thread->mLock.unlock();
3570            AudioSystem::stopOutput(thread->id(),
3571                                    (audio_stream_type_t)mStreamType,
3572                                    mSessionId);
3573            thread->mLock.lock();
3574
3575            // to track the speaker usage
3576            addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
3577        }
3578    }
3579}
3580
3581void AudioFlinger::PlaybackThread::Track::pause()
3582{
3583    LOGV("pause(%d), calling thread %d", mName, IPCThreadState::self()->getCallingPid());
3584    sp<ThreadBase> thread = mThread.promote();
3585    if (thread != 0) {
3586        Mutex::Autolock _l(thread->mLock);
3587        if (mState == ACTIVE || mState == RESUMING) {
3588            mState = PAUSING;
3589            LOGV("ACTIVE/RESUMING => PAUSING (%d) on thread %p", mName, thread.get());
3590            if (!isOutputTrack()) {
3591                thread->mLock.unlock();
3592                AudioSystem::stopOutput(thread->id(),
3593                                        (audio_stream_type_t)mStreamType,
3594                                        mSessionId);
3595                thread->mLock.lock();
3596
3597                // to track the speaker usage
3598                addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
3599            }
3600        }
3601    }
3602}
3603
3604void AudioFlinger::PlaybackThread::Track::flush()
3605{
3606    LOGV("flush(%d)", mName);
3607    sp<ThreadBase> thread = mThread.promote();
3608    if (thread != 0) {
3609        Mutex::Autolock _l(thread->mLock);
3610        if (mState != STOPPED && mState != PAUSED && mState != PAUSING) {
3611            return;
3612        }
3613        // No point remaining in PAUSED state after a flush => go to
3614        // STOPPED state
3615        mState = STOPPED;
3616
3617        // do not reset the track if it is still in the process of being stopped or paused.
3618        // this will be done by prepareTracks_l() when the track is stopped.
3619        PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
3620        if (playbackThread->mActiveTracks.indexOf(this) < 0) {
3621            reset();
3622        }
3623    }
3624}
3625
3626void AudioFlinger::PlaybackThread::Track::reset()
3627{
3628    // Do not reset twice to avoid discarding data written just after a flush and before
3629    // the audioflinger thread detects the track is stopped.
3630    if (!mResetDone) {
3631        TrackBase::reset();
3632        // Force underrun condition to avoid false underrun callback until first data is
3633        // written to buffer
3634        android_atomic_and(~CBLK_FORCEREADY_MSK, &mCblk->flags);
3635        android_atomic_or(CBLK_UNDERRUN_ON, &mCblk->flags);
3636        mFillingUpStatus = FS_FILLING;
3637        mResetDone = true;
3638    }
3639}
3640
3641void AudioFlinger::PlaybackThread::Track::mute(bool muted)
3642{
3643    mMute = muted;
3644}
3645
3646void AudioFlinger::PlaybackThread::Track::setVolume(float left, float right)
3647{
3648    mVolume[0] = left;
3649    mVolume[1] = right;
3650}
3651
3652status_t AudioFlinger::PlaybackThread::Track::attachAuxEffect(int EffectId)
3653{
3654    status_t status = DEAD_OBJECT;
3655    sp<ThreadBase> thread = mThread.promote();
3656    if (thread != 0) {
3657       PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
3658       status = playbackThread->attachAuxEffect(this, EffectId);
3659    }
3660    return status;
3661}
3662
3663void AudioFlinger::PlaybackThread::Track::setAuxBuffer(int EffectId, int32_t *buffer)
3664{
3665    mAuxEffectId = EffectId;
3666    mAuxBuffer = buffer;
3667}
3668
3669// ----------------------------------------------------------------------------
3670
3671// RecordTrack constructor must be called with AudioFlinger::mLock held
3672AudioFlinger::RecordThread::RecordTrack::RecordTrack(
3673            const wp<ThreadBase>& thread,
3674            const sp<Client>& client,
3675            uint32_t sampleRate,
3676            uint32_t format,
3677            uint32_t channelMask,
3678            int frameCount,
3679            uint32_t flags,
3680            int sessionId)
3681    :   TrackBase(thread, client, sampleRate, format,
3682                  channelMask, frameCount, flags, 0, sessionId),
3683        mOverflow(false)
3684{
3685    if (mCblk != NULL) {
3686       LOGV("RecordTrack constructor, size %d", (int)mBufferEnd - (int)mBuffer);
3687       if (format == AUDIO_FORMAT_PCM_16_BIT) {
3688           mCblk->frameSize = mChannelCount * sizeof(int16_t);
3689       } else if (format == AUDIO_FORMAT_PCM_8_BIT) {
3690           mCblk->frameSize = mChannelCount * sizeof(int8_t);
3691       } else {
3692           mCblk->frameSize = sizeof(int8_t);
3693       }
3694    }
3695}
3696
3697AudioFlinger::RecordThread::RecordTrack::~RecordTrack()
3698{
3699    sp<ThreadBase> thread = mThread.promote();
3700    if (thread != 0) {
3701        AudioSystem::releaseInput(thread->id());
3702    }
3703}
3704
3705status_t AudioFlinger::RecordThread::RecordTrack::getNextBuffer(AudioBufferProvider::Buffer* buffer)
3706{
3707    audio_track_cblk_t* cblk = this->cblk();
3708    uint32_t framesAvail;
3709    uint32_t framesReq = buffer->frameCount;
3710
3711     // Check if last stepServer failed, try to step now
3712    if (mFlags & TrackBase::STEPSERVER_FAILED) {
3713        if (!step()) goto getNextBuffer_exit;
3714        LOGV("stepServer recovered");
3715        mFlags &= ~TrackBase::STEPSERVER_FAILED;
3716    }
3717
3718    framesAvail = cblk->framesAvailable_l();
3719
3720    if (LIKELY(framesAvail)) {
3721        uint32_t s = cblk->server;
3722        uint32_t bufferEnd = cblk->serverBase + cblk->frameCount;
3723
3724        if (framesReq > framesAvail) {
3725            framesReq = framesAvail;
3726        }
3727        if (s + framesReq > bufferEnd) {
3728            framesReq = bufferEnd - s;
3729        }
3730
3731        buffer->raw = getBuffer(s, framesReq);
3732        if (buffer->raw == 0) goto getNextBuffer_exit;
3733
3734        buffer->frameCount = framesReq;
3735        return NO_ERROR;
3736    }
3737
3738getNextBuffer_exit:
3739    buffer->raw = 0;
3740    buffer->frameCount = 0;
3741    return NOT_ENOUGH_DATA;
3742}
3743
3744status_t AudioFlinger::RecordThread::RecordTrack::start()
3745{
3746    sp<ThreadBase> thread = mThread.promote();
3747    if (thread != 0) {
3748        RecordThread *recordThread = (RecordThread *)thread.get();
3749        return recordThread->start(this);
3750    } else {
3751        return BAD_VALUE;
3752    }
3753}
3754
3755void AudioFlinger::RecordThread::RecordTrack::stop()
3756{
3757    sp<ThreadBase> thread = mThread.promote();
3758    if (thread != 0) {
3759        RecordThread *recordThread = (RecordThread *)thread.get();
3760        recordThread->stop(this);
3761        TrackBase::reset();
3762        // Force overerrun condition to avoid false overrun callback until first data is
3763        // read from buffer
3764        android_atomic_or(CBLK_UNDERRUN_ON, &mCblk->flags);
3765    }
3766}
3767
3768void AudioFlinger::RecordThread::RecordTrack::dump(char* buffer, size_t size)
3769{
3770    snprintf(buffer, size, "   %05d %03u 0x%08x %05d   %04u %01d %05u  %08x %08x\n",
3771            (mClient == NULL) ? getpid() : mClient->pid(),
3772            mFormat,
3773            mChannelMask,
3774            mSessionId,
3775            mFrameCount,
3776            mState,
3777            mCblk->sampleRate,
3778            mCblk->server,
3779            mCblk->user);
3780}
3781
3782
3783// ----------------------------------------------------------------------------
3784
3785AudioFlinger::PlaybackThread::OutputTrack::OutputTrack(
3786            const wp<ThreadBase>& thread,
3787            DuplicatingThread *sourceThread,
3788            uint32_t sampleRate,
3789            uint32_t format,
3790            uint32_t channelMask,
3791            int frameCount)
3792    :   Track(thread, NULL, AUDIO_STREAM_CNT, sampleRate, format, channelMask, frameCount, NULL, 0),
3793    mActive(false), mSourceThread(sourceThread)
3794{
3795
3796    PlaybackThread *playbackThread = (PlaybackThread *)thread.unsafe_get();
3797    if (mCblk != NULL) {
3798        mCblk->flags |= CBLK_DIRECTION_OUT;
3799        mCblk->buffers = (char*)mCblk + sizeof(audio_track_cblk_t);
3800        mCblk->volume[0] = mCblk->volume[1] = 0x1000;
3801        mOutBuffer.frameCount = 0;
3802        playbackThread->mTracks.add(this);
3803        LOGV("OutputTrack constructor mCblk %p, mBuffer %p, mCblk->buffers %p, " \
3804                "mCblk->frameCount %d, mCblk->sampleRate %d, mChannelMask 0x%08x mBufferEnd %p",
3805                mCblk, mBuffer, mCblk->buffers,
3806                mCblk->frameCount, mCblk->sampleRate, mChannelMask, mBufferEnd);
3807    } else {
3808        LOGW("Error creating output track on thread %p", playbackThread);
3809    }
3810}
3811
3812AudioFlinger::PlaybackThread::OutputTrack::~OutputTrack()
3813{
3814    clearBufferQueue();
3815}
3816
3817status_t AudioFlinger::PlaybackThread::OutputTrack::start()
3818{
3819    status_t status = Track::start();
3820    if (status != NO_ERROR) {
3821        return status;
3822    }
3823
3824    mActive = true;
3825    mRetryCount = 127;
3826    return status;
3827}
3828
3829void AudioFlinger::PlaybackThread::OutputTrack::stop()
3830{
3831    Track::stop();
3832    clearBufferQueue();
3833    mOutBuffer.frameCount = 0;
3834    mActive = false;
3835}
3836
3837bool AudioFlinger::PlaybackThread::OutputTrack::write(int16_t* data, uint32_t frames)
3838{
3839    Buffer *pInBuffer;
3840    Buffer inBuffer;
3841    uint32_t channelCount = mChannelCount;
3842    bool outputBufferFull = false;
3843    inBuffer.frameCount = frames;
3844    inBuffer.i16 = data;
3845
3846    uint32_t waitTimeLeftMs = mSourceThread->waitTimeMs();
3847
3848    if (!mActive && frames != 0) {
3849        start();
3850        sp<ThreadBase> thread = mThread.promote();
3851        if (thread != 0) {
3852            MixerThread *mixerThread = (MixerThread *)thread.get();
3853            if (mCblk->frameCount > frames){
3854                if (mBufferQueue.size() < kMaxOverFlowBuffers) {
3855                    uint32_t startFrames = (mCblk->frameCount - frames);
3856                    pInBuffer = new Buffer;
3857                    pInBuffer->mBuffer = new int16_t[startFrames * channelCount];
3858                    pInBuffer->frameCount = startFrames;
3859                    pInBuffer->i16 = pInBuffer->mBuffer;
3860                    memset(pInBuffer->raw, 0, startFrames * channelCount * sizeof(int16_t));
3861                    mBufferQueue.add(pInBuffer);
3862                } else {
3863                    LOGW ("OutputTrack::write() %p no more buffers in queue", this);
3864                }
3865            }
3866        }
3867    }
3868
3869    while (waitTimeLeftMs) {
3870        // First write pending buffers, then new data
3871        if (mBufferQueue.size()) {
3872            pInBuffer = mBufferQueue.itemAt(0);
3873        } else {
3874            pInBuffer = &inBuffer;
3875        }
3876
3877        if (pInBuffer->frameCount == 0) {
3878            break;
3879        }
3880
3881        if (mOutBuffer.frameCount == 0) {
3882            mOutBuffer.frameCount = pInBuffer->frameCount;
3883            nsecs_t startTime = systemTime();
3884            if (obtainBuffer(&mOutBuffer, waitTimeLeftMs) == (status_t)AudioTrack::NO_MORE_BUFFERS) {
3885                LOGV ("OutputTrack::write() %p thread %p no more output buffers", this, mThread.unsafe_get());
3886                outputBufferFull = true;
3887                break;
3888            }
3889            uint32_t waitTimeMs = (uint32_t)ns2ms(systemTime() - startTime);
3890            if (waitTimeLeftMs >= waitTimeMs) {
3891                waitTimeLeftMs -= waitTimeMs;
3892            } else {
3893                waitTimeLeftMs = 0;
3894            }
3895        }
3896
3897        uint32_t outFrames = pInBuffer->frameCount > mOutBuffer.frameCount ? mOutBuffer.frameCount : pInBuffer->frameCount;
3898        memcpy(mOutBuffer.raw, pInBuffer->raw, outFrames * channelCount * sizeof(int16_t));
3899        mCblk->stepUser(outFrames);
3900        pInBuffer->frameCount -= outFrames;
3901        pInBuffer->i16 += outFrames * channelCount;
3902        mOutBuffer.frameCount -= outFrames;
3903        mOutBuffer.i16 += outFrames * channelCount;
3904
3905        if (pInBuffer->frameCount == 0) {
3906            if (mBufferQueue.size()) {
3907                mBufferQueue.removeAt(0);
3908                delete [] pInBuffer->mBuffer;
3909                delete pInBuffer;
3910                LOGV("OutputTrack::write() %p thread %p released overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size());
3911            } else {
3912                break;
3913            }
3914        }
3915    }
3916
3917    // If we could not write all frames, allocate a buffer and queue it for next time.
3918    if (inBuffer.frameCount) {
3919        sp<ThreadBase> thread = mThread.promote();
3920        if (thread != 0 && !thread->standby()) {
3921            if (mBufferQueue.size() < kMaxOverFlowBuffers) {
3922                pInBuffer = new Buffer;
3923                pInBuffer->mBuffer = new int16_t[inBuffer.frameCount * channelCount];
3924                pInBuffer->frameCount = inBuffer.frameCount;
3925                pInBuffer->i16 = pInBuffer->mBuffer;
3926                memcpy(pInBuffer->raw, inBuffer.raw, inBuffer.frameCount * channelCount * sizeof(int16_t));
3927                mBufferQueue.add(pInBuffer);
3928                LOGV("OutputTrack::write() %p thread %p adding overflow buffer %d", this, mThread.unsafe_get(), mBufferQueue.size());
3929            } else {
3930                LOGW("OutputTrack::write() %p thread %p no more overflow buffers", mThread.unsafe_get(), this);
3931            }
3932        }
3933    }
3934
3935    // Calling write() with a 0 length buffer, means that no more data will be written:
3936    // If no more buffers are pending, fill output track buffer to make sure it is started
3937    // by output mixer.
3938    if (frames == 0 && mBufferQueue.size() == 0) {
3939        if (mCblk->user < mCblk->frameCount) {
3940            frames = mCblk->frameCount - mCblk->user;
3941            pInBuffer = new Buffer;
3942            pInBuffer->mBuffer = new int16_t[frames * channelCount];
3943            pInBuffer->frameCount = frames;
3944            pInBuffer->i16 = pInBuffer->mBuffer;
3945            memset(pInBuffer->raw, 0, frames * channelCount * sizeof(int16_t));
3946            mBufferQueue.add(pInBuffer);
3947        } else if (mActive) {
3948            stop();
3949        }
3950    }
3951
3952    return outputBufferFull;
3953}
3954
3955status_t AudioFlinger::PlaybackThread::OutputTrack::obtainBuffer(AudioBufferProvider::Buffer* buffer, uint32_t waitTimeMs)
3956{
3957    int active;
3958    status_t result;
3959    audio_track_cblk_t* cblk = mCblk;
3960    uint32_t framesReq = buffer->frameCount;
3961
3962//    LOGV("OutputTrack::obtainBuffer user %d, server %d", cblk->user, cblk->server);
3963    buffer->frameCount  = 0;
3964
3965    uint32_t framesAvail = cblk->framesAvailable();
3966
3967
3968    if (framesAvail == 0) {
3969        Mutex::Autolock _l(cblk->lock);
3970        goto start_loop_here;
3971        while (framesAvail == 0) {
3972            active = mActive;
3973            if (UNLIKELY(!active)) {
3974                LOGV("Not active and NO_MORE_BUFFERS");
3975                return AudioTrack::NO_MORE_BUFFERS;
3976            }
3977            result = cblk->cv.waitRelative(cblk->lock, milliseconds(waitTimeMs));
3978            if (result != NO_ERROR) {
3979                return AudioTrack::NO_MORE_BUFFERS;
3980            }
3981            // read the server count again
3982        start_loop_here:
3983            framesAvail = cblk->framesAvailable_l();
3984        }
3985    }
3986
3987//    if (framesAvail < framesReq) {
3988//        return AudioTrack::NO_MORE_BUFFERS;
3989//    }
3990
3991    if (framesReq > framesAvail) {
3992        framesReq = framesAvail;
3993    }
3994
3995    uint32_t u = cblk->user;
3996    uint32_t bufferEnd = cblk->userBase + cblk->frameCount;
3997
3998    if (u + framesReq > bufferEnd) {
3999        framesReq = bufferEnd - u;
4000    }
4001
4002    buffer->frameCount  = framesReq;
4003    buffer->raw         = (void *)cblk->buffer(u);
4004    return NO_ERROR;
4005}
4006
4007
4008void AudioFlinger::PlaybackThread::OutputTrack::clearBufferQueue()
4009{
4010    size_t size = mBufferQueue.size();
4011    Buffer *pBuffer;
4012
4013    for (size_t i = 0; i < size; i++) {
4014        pBuffer = mBufferQueue.itemAt(i);
4015        delete [] pBuffer->mBuffer;
4016        delete pBuffer;
4017    }
4018    mBufferQueue.clear();
4019}
4020
4021// ----------------------------------------------------------------------------
4022
4023AudioFlinger::Client::Client(const sp<AudioFlinger>& audioFlinger, pid_t pid)
4024    :   RefBase(),
4025        mAudioFlinger(audioFlinger),
4026        mMemoryDealer(new MemoryDealer(1024*1024, "AudioFlinger::Client")),
4027        mPid(pid)
4028{
4029    // 1 MB of address space is good for 32 tracks, 8 buffers each, 4 KB/buffer
4030}
4031
4032// Client destructor must be called with AudioFlinger::mLock held
4033AudioFlinger::Client::~Client()
4034{
4035    mAudioFlinger->removeClient_l(mPid);
4036}
4037
4038const sp<MemoryDealer>& AudioFlinger::Client::heap() const
4039{
4040    return mMemoryDealer;
4041}
4042
4043// ----------------------------------------------------------------------------
4044
4045AudioFlinger::NotificationClient::NotificationClient(const sp<AudioFlinger>& audioFlinger,
4046                                                     const sp<IAudioFlingerClient>& client,
4047                                                     pid_t pid)
4048    : mAudioFlinger(audioFlinger), mPid(pid), mClient(client)
4049{
4050}
4051
4052AudioFlinger::NotificationClient::~NotificationClient()
4053{
4054    mClient.clear();
4055}
4056
4057void AudioFlinger::NotificationClient::binderDied(const wp<IBinder>& who)
4058{
4059    sp<NotificationClient> keep(this);
4060    {
4061        mAudioFlinger->removeNotificationClient(mPid);
4062    }
4063}
4064
4065// ----------------------------------------------------------------------------
4066
4067AudioFlinger::TrackHandle::TrackHandle(const sp<AudioFlinger::PlaybackThread::Track>& track)
4068    : BnAudioTrack(),
4069      mTrack(track)
4070{
4071}
4072
4073AudioFlinger::TrackHandle::~TrackHandle() {
4074    // just stop the track on deletion, associated resources
4075    // will be freed from the main thread once all pending buffers have
4076    // been played. Unless it's not in the active track list, in which
4077    // case we free everything now...
4078    mTrack->destroy();
4079}
4080
4081status_t AudioFlinger::TrackHandle::start() {
4082    return mTrack->start();
4083}
4084
4085void AudioFlinger::TrackHandle::stop() {
4086    mTrack->stop();
4087}
4088
4089void AudioFlinger::TrackHandle::flush() {
4090    mTrack->flush();
4091}
4092
4093void AudioFlinger::TrackHandle::mute(bool e) {
4094    mTrack->mute(e);
4095}
4096
4097void AudioFlinger::TrackHandle::pause() {
4098    mTrack->pause();
4099}
4100
4101void AudioFlinger::TrackHandle::setVolume(float left, float right) {
4102    mTrack->setVolume(left, right);
4103}
4104
4105sp<IMemory> AudioFlinger::TrackHandle::getCblk() const {
4106    return mTrack->getCblk();
4107}
4108
4109status_t AudioFlinger::TrackHandle::attachAuxEffect(int EffectId)
4110{
4111    return mTrack->attachAuxEffect(EffectId);
4112}
4113
4114status_t AudioFlinger::TrackHandle::onTransact(
4115    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
4116{
4117    return BnAudioTrack::onTransact(code, data, reply, flags);
4118}
4119
4120// ----------------------------------------------------------------------------
4121
4122sp<IAudioRecord> AudioFlinger::openRecord(
4123        pid_t pid,
4124        int input,
4125        uint32_t sampleRate,
4126        uint32_t format,
4127        uint32_t channelMask,
4128        int frameCount,
4129        uint32_t flags,
4130        int *sessionId,
4131        status_t *status)
4132{
4133    sp<RecordThread::RecordTrack> recordTrack;
4134    sp<RecordHandle> recordHandle;
4135    sp<Client> client;
4136    wp<Client> wclient;
4137    status_t lStatus;
4138    RecordThread *thread;
4139    size_t inFrameCount;
4140    int lSessionId;
4141
4142    // check calling permissions
4143    if (!recordingAllowed()) {
4144        lStatus = PERMISSION_DENIED;
4145        goto Exit;
4146    }
4147
4148    // add client to list
4149    { // scope for mLock
4150        Mutex::Autolock _l(mLock);
4151        thread = checkRecordThread_l(input);
4152        if (thread == NULL) {
4153            lStatus = BAD_VALUE;
4154            goto Exit;
4155        }
4156
4157        wclient = mClients.valueFor(pid);
4158        if (wclient != NULL) {
4159            client = wclient.promote();
4160        } else {
4161            client = new Client(this, pid);
4162            mClients.add(pid, client);
4163        }
4164
4165        // If no audio session id is provided, create one here
4166        if (sessionId != NULL && *sessionId != AUDIO_SESSION_OUTPUT_MIX) {
4167            lSessionId = *sessionId;
4168        } else {
4169            lSessionId = nextUniqueId();
4170            if (sessionId != NULL) {
4171                *sessionId = lSessionId;
4172            }
4173        }
4174        // create new record track. The record track uses one track in mHardwareMixerThread by convention.
4175        recordTrack = thread->createRecordTrack_l(client,
4176                                                sampleRate,
4177                                                format,
4178                                                channelMask,
4179                                                frameCount,
4180                                                flags,
4181                                                lSessionId,
4182                                                &lStatus);
4183    }
4184    if (lStatus != NO_ERROR) {
4185        // remove local strong reference to Client before deleting the RecordTrack so that the Client
4186        // destructor is called by the TrackBase destructor with mLock held
4187        client.clear();
4188        recordTrack.clear();
4189        goto Exit;
4190    }
4191
4192    // return to handle to client
4193    recordHandle = new RecordHandle(recordTrack);
4194    lStatus = NO_ERROR;
4195
4196Exit:
4197    if (status) {
4198        *status = lStatus;
4199    }
4200    return recordHandle;
4201}
4202
4203// ----------------------------------------------------------------------------
4204
4205AudioFlinger::RecordHandle::RecordHandle(const sp<AudioFlinger::RecordThread::RecordTrack>& recordTrack)
4206    : BnAudioRecord(),
4207    mRecordTrack(recordTrack)
4208{
4209}
4210
4211AudioFlinger::RecordHandle::~RecordHandle() {
4212    stop();
4213}
4214
4215status_t AudioFlinger::RecordHandle::start() {
4216    LOGV("RecordHandle::start()");
4217    return mRecordTrack->start();
4218}
4219
4220void AudioFlinger::RecordHandle::stop() {
4221    LOGV("RecordHandle::stop()");
4222    mRecordTrack->stop();
4223}
4224
4225sp<IMemory> AudioFlinger::RecordHandle::getCblk() const {
4226    return mRecordTrack->getCblk();
4227}
4228
4229status_t AudioFlinger::RecordHandle::onTransact(
4230    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
4231{
4232    return BnAudioRecord::onTransact(code, data, reply, flags);
4233}
4234
4235// ----------------------------------------------------------------------------
4236
4237AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
4238                                         AudioStreamIn *input,
4239                                         uint32_t sampleRate,
4240                                         uint32_t channels,
4241                                         int id,
4242                                         uint32_t device) :
4243    ThreadBase(audioFlinger, id, device),
4244    mInput(input), mTrack(NULL), mResampler(0), mRsmpOutBuffer(0), mRsmpInBuffer(0)
4245{
4246    mType = ThreadBase::RECORD;
4247
4248    snprintf(mName, kNameLength, "AudioIn_%d", id);
4249
4250    mReqChannelCount = popcount(channels);
4251    mReqSampleRate = sampleRate;
4252    readInputParameters();
4253}
4254
4255
4256AudioFlinger::RecordThread::~RecordThread()
4257{
4258    delete[] mRsmpInBuffer;
4259    if (mResampler != 0) {
4260        delete mResampler;
4261        delete[] mRsmpOutBuffer;
4262    }
4263}
4264
4265void AudioFlinger::RecordThread::onFirstRef()
4266{
4267    run(mName, PRIORITY_URGENT_AUDIO);
4268}
4269
4270status_t AudioFlinger::RecordThread::readyToRun()
4271{
4272    status_t status = initCheck();
4273    LOGW_IF(status != NO_ERROR,"RecordThread %p could not initialize", this);
4274    return status;
4275}
4276
4277bool AudioFlinger::RecordThread::threadLoop()
4278{
4279    AudioBufferProvider::Buffer buffer;
4280    sp<RecordTrack> activeTrack;
4281    Vector< sp<EffectChain> > effectChains;
4282
4283    nsecs_t lastWarning = 0;
4284
4285    acquireWakeLock();
4286
4287    // start recording
4288    while (!exitPending()) {
4289
4290        processConfigEvents();
4291
4292        { // scope for mLock
4293            Mutex::Autolock _l(mLock);
4294            checkForNewParameters_l();
4295            if (mActiveTrack == 0 && mConfigEvents.isEmpty()) {
4296                if (!mStandby) {
4297                    mInput->stream->common.standby(&mInput->stream->common);
4298                    mStandby = true;
4299                }
4300
4301                if (exitPending()) break;
4302
4303                releaseWakeLock_l();
4304                LOGV("RecordThread: loop stopping");
4305                // go to sleep
4306                mWaitWorkCV.wait(mLock);
4307                LOGV("RecordThread: loop starting");
4308                acquireWakeLock_l();
4309                continue;
4310            }
4311            if (mActiveTrack != 0) {
4312                if (mActiveTrack->mState == TrackBase::PAUSING) {
4313                    if (!mStandby) {
4314                        mInput->stream->common.standby(&mInput->stream->common);
4315                        mStandby = true;
4316                    }
4317                    mActiveTrack.clear();
4318                    mStartStopCond.broadcast();
4319                } else if (mActiveTrack->mState == TrackBase::RESUMING) {
4320                    if (mReqChannelCount != mActiveTrack->channelCount()) {
4321                        mActiveTrack.clear();
4322                        mStartStopCond.broadcast();
4323                    } else if (mBytesRead != 0) {
4324                        // record start succeeds only if first read from audio input
4325                        // succeeds
4326                        if (mBytesRead > 0) {
4327                            mActiveTrack->mState = TrackBase::ACTIVE;
4328                        } else {
4329                            mActiveTrack.clear();
4330                        }
4331                        mStartStopCond.broadcast();
4332                    }
4333                    mStandby = false;
4334                }
4335            }
4336            lockEffectChains_l(effectChains);
4337        }
4338
4339        if (mActiveTrack != 0) {
4340            if (mActiveTrack->mState != TrackBase::ACTIVE &&
4341                mActiveTrack->mState != TrackBase::RESUMING) {
4342                unlockEffectChains(effectChains);
4343                usleep(kRecordThreadSleepUs);
4344                continue;
4345            }
4346            for (size_t i = 0; i < effectChains.size(); i ++) {
4347                effectChains[i]->process_l();
4348            }
4349
4350            buffer.frameCount = mFrameCount;
4351            if (LIKELY(mActiveTrack->getNextBuffer(&buffer) == NO_ERROR)) {
4352                size_t framesOut = buffer.frameCount;
4353                if (mResampler == 0) {
4354                    // no resampling
4355                    while (framesOut) {
4356                        size_t framesIn = mFrameCount - mRsmpInIndex;
4357                        if (framesIn) {
4358                            int8_t *src = (int8_t *)mRsmpInBuffer + mRsmpInIndex * mFrameSize;
4359                            int8_t *dst = buffer.i8 + (buffer.frameCount - framesOut) * mActiveTrack->mCblk->frameSize;
4360                            if (framesIn > framesOut)
4361                                framesIn = framesOut;
4362                            mRsmpInIndex += framesIn;
4363                            framesOut -= framesIn;
4364                            if ((int)mChannelCount == mReqChannelCount ||
4365                                mFormat != AUDIO_FORMAT_PCM_16_BIT) {
4366                                memcpy(dst, src, framesIn * mFrameSize);
4367                            } else {
4368                                int16_t *src16 = (int16_t *)src;
4369                                int16_t *dst16 = (int16_t *)dst;
4370                                if (mChannelCount == 1) {
4371                                    while (framesIn--) {
4372                                        *dst16++ = *src16;
4373                                        *dst16++ = *src16++;
4374                                    }
4375                                } else {
4376                                    while (framesIn--) {
4377                                        *dst16++ = (int16_t)(((int32_t)*src16 + (int32_t)*(src16 + 1)) >> 1);
4378                                        src16 += 2;
4379                                    }
4380                                }
4381                            }
4382                        }
4383                        if (framesOut && mFrameCount == mRsmpInIndex) {
4384                            if (framesOut == mFrameCount &&
4385                                ((int)mChannelCount == mReqChannelCount || mFormat != AUDIO_FORMAT_PCM_16_BIT)) {
4386                                mBytesRead = mInput->stream->read(mInput->stream, buffer.raw, mInputBytes);
4387                                framesOut = 0;
4388                            } else {
4389                                mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes);
4390                                mRsmpInIndex = 0;
4391                            }
4392                            if (mBytesRead < 0) {
4393                                LOGE("Error reading audio input");
4394                                if (mActiveTrack->mState == TrackBase::ACTIVE) {
4395                                    // Force input into standby so that it tries to
4396                                    // recover at next read attempt
4397                                    mInput->stream->common.standby(&mInput->stream->common);
4398                                    usleep(kRecordThreadSleepUs);
4399                                }
4400                                mRsmpInIndex = mFrameCount;
4401                                framesOut = 0;
4402                                buffer.frameCount = 0;
4403                            }
4404                        }
4405                    }
4406                } else {
4407                    // resampling
4408
4409                    memset(mRsmpOutBuffer, 0, framesOut * 2 * sizeof(int32_t));
4410                    // alter output frame count as if we were expecting stereo samples
4411                    if (mChannelCount == 1 && mReqChannelCount == 1) {
4412                        framesOut >>= 1;
4413                    }
4414                    mResampler->resample(mRsmpOutBuffer, framesOut, this);
4415                    // ditherAndClamp() works as long as all buffers returned by mActiveTrack->getNextBuffer()
4416                    // are 32 bit aligned which should be always true.
4417                    if (mChannelCount == 2 && mReqChannelCount == 1) {
4418                        AudioMixer::ditherAndClamp(mRsmpOutBuffer, mRsmpOutBuffer, framesOut);
4419                        // the resampler always outputs stereo samples: do post stereo to mono conversion
4420                        int16_t *src = (int16_t *)mRsmpOutBuffer;
4421                        int16_t *dst = buffer.i16;
4422                        while (framesOut--) {
4423                            *dst++ = (int16_t)(((int32_t)*src + (int32_t)*(src + 1)) >> 1);
4424                            src += 2;
4425                        }
4426                    } else {
4427                        AudioMixer::ditherAndClamp((int32_t *)buffer.raw, mRsmpOutBuffer, framesOut);
4428                    }
4429
4430                }
4431                mActiveTrack->releaseBuffer(&buffer);
4432                mActiveTrack->overflow();
4433            }
4434            // client isn't retrieving buffers fast enough
4435            else {
4436                if (!mActiveTrack->setOverflow()) {
4437                    nsecs_t now = systemTime();
4438                    if ((now - lastWarning) > kWarningThrottle) {
4439                        LOGW("RecordThread: buffer overflow");
4440                        lastWarning = now;
4441                    }
4442                }
4443                // Release the processor for a while before asking for a new buffer.
4444                // This will give the application more chance to read from the buffer and
4445                // clear the overflow.
4446                usleep(kRecordThreadSleepUs);
4447            }
4448        }
4449        // enable changes in effect chain
4450        unlockEffectChains(effectChains);
4451        effectChains.clear();
4452    }
4453
4454    if (!mStandby) {
4455        mInput->stream->common.standby(&mInput->stream->common);
4456    }
4457    mActiveTrack.clear();
4458
4459    mStartStopCond.broadcast();
4460
4461    releaseWakeLock();
4462
4463    LOGV("RecordThread %p exiting", this);
4464    return false;
4465}
4466
4467
4468sp<AudioFlinger::RecordThread::RecordTrack>  AudioFlinger::RecordThread::createRecordTrack_l(
4469        const sp<AudioFlinger::Client>& client,
4470        uint32_t sampleRate,
4471        int format,
4472        int channelMask,
4473        int frameCount,
4474        uint32_t flags,
4475        int sessionId,
4476        status_t *status)
4477{
4478    sp<RecordTrack> track;
4479    status_t lStatus;
4480
4481    lStatus = initCheck();
4482    if (lStatus != NO_ERROR) {
4483        LOGE("Audio driver not initialized.");
4484        goto Exit;
4485    }
4486
4487    { // scope for mLock
4488        Mutex::Autolock _l(mLock);
4489
4490        track = new RecordTrack(this, client, sampleRate,
4491                      format, channelMask, frameCount, flags, sessionId);
4492
4493        if (track->getCblk() == NULL) {
4494            lStatus = NO_MEMORY;
4495            goto Exit;
4496        }
4497
4498        mTrack = track.get();
4499        // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
4500        bool suspend = audio_is_bluetooth_sco_device(
4501                (audio_devices_t)(mDevice & AUDIO_DEVICE_IN_ALL)) && mAudioFlinger->btNrecIsOff();
4502        setEffectSuspended_l(FX_IID_AEC, suspend, sessionId);
4503        setEffectSuspended_l(FX_IID_NS, suspend, sessionId);
4504    }
4505    lStatus = NO_ERROR;
4506
4507Exit:
4508    if (status) {
4509        *status = lStatus;
4510    }
4511    return track;
4512}
4513
4514status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack)
4515{
4516    LOGV("RecordThread::start");
4517    sp <ThreadBase> strongMe = this;
4518    status_t status = NO_ERROR;
4519    {
4520        AutoMutex lock(&mLock);
4521        if (mActiveTrack != 0) {
4522            if (recordTrack != mActiveTrack.get()) {
4523                status = -EBUSY;
4524            } else if (mActiveTrack->mState == TrackBase::PAUSING) {
4525                mActiveTrack->mState = TrackBase::ACTIVE;
4526            }
4527            return status;
4528        }
4529
4530        recordTrack->mState = TrackBase::IDLE;
4531        mActiveTrack = recordTrack;
4532        mLock.unlock();
4533        status_t status = AudioSystem::startInput(mId);
4534        mLock.lock();
4535        if (status != NO_ERROR) {
4536            mActiveTrack.clear();
4537            return status;
4538        }
4539        mRsmpInIndex = mFrameCount;
4540        mBytesRead = 0;
4541        if (mResampler != NULL) {
4542            mResampler->reset();
4543        }
4544        mActiveTrack->mState = TrackBase::RESUMING;
4545        // signal thread to start
4546        LOGV("Signal record thread");
4547        mWaitWorkCV.signal();
4548        // do not wait for mStartStopCond if exiting
4549        if (mExiting) {
4550            mActiveTrack.clear();
4551            status = INVALID_OPERATION;
4552            goto startError;
4553        }
4554        mStartStopCond.wait(mLock);
4555        if (mActiveTrack == 0) {
4556            LOGV("Record failed to start");
4557            status = BAD_VALUE;
4558            goto startError;
4559        }
4560        LOGV("Record started OK");
4561        return status;
4562    }
4563startError:
4564    AudioSystem::stopInput(mId);
4565    return status;
4566}
4567
4568void AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) {
4569    LOGV("RecordThread::stop");
4570    sp <ThreadBase> strongMe = this;
4571    {
4572        AutoMutex lock(&mLock);
4573        if (mActiveTrack != 0 && recordTrack == mActiveTrack.get()) {
4574            mActiveTrack->mState = TrackBase::PAUSING;
4575            // do not wait for mStartStopCond if exiting
4576            if (mExiting) {
4577                return;
4578            }
4579            mStartStopCond.wait(mLock);
4580            // if we have been restarted, recordTrack == mActiveTrack.get() here
4581            if (mActiveTrack == 0 || recordTrack != mActiveTrack.get()) {
4582                mLock.unlock();
4583                AudioSystem::stopInput(mId);
4584                mLock.lock();
4585                LOGV("Record stopped OK");
4586            }
4587        }
4588    }
4589}
4590
4591status_t AudioFlinger::RecordThread::dump(int fd, const Vector<String16>& args)
4592{
4593    const size_t SIZE = 256;
4594    char buffer[SIZE];
4595    String8 result;
4596    pid_t pid = 0;
4597
4598    snprintf(buffer, SIZE, "\nInput thread %p internals\n", this);
4599    result.append(buffer);
4600
4601    if (mActiveTrack != 0) {
4602        result.append("Active Track:\n");
4603        result.append("   Clien Fmt Chn mask   Session Buf  S SRate  Serv     User\n");
4604        mActiveTrack->dump(buffer, SIZE);
4605        result.append(buffer);
4606
4607        snprintf(buffer, SIZE, "In index: %d\n", mRsmpInIndex);
4608        result.append(buffer);
4609        snprintf(buffer, SIZE, "In size: %d\n", mInputBytes);
4610        result.append(buffer);
4611        snprintf(buffer, SIZE, "Resampling: %d\n", (mResampler != 0));
4612        result.append(buffer);
4613        snprintf(buffer, SIZE, "Out channel count: %d\n", mReqChannelCount);
4614        result.append(buffer);
4615        snprintf(buffer, SIZE, "Out sample rate: %d\n", mReqSampleRate);
4616        result.append(buffer);
4617
4618
4619    } else {
4620        result.append("No record client\n");
4621    }
4622    write(fd, result.string(), result.size());
4623
4624    dumpBase(fd, args);
4625    dumpEffectChains(fd, args);
4626
4627    return NO_ERROR;
4628}
4629
4630status_t AudioFlinger::RecordThread::getNextBuffer(AudioBufferProvider::Buffer* buffer)
4631{
4632    size_t framesReq = buffer->frameCount;
4633    size_t framesReady = mFrameCount - mRsmpInIndex;
4634    int channelCount;
4635
4636    if (framesReady == 0) {
4637        mBytesRead = mInput->stream->read(mInput->stream, mRsmpInBuffer, mInputBytes);
4638        if (mBytesRead < 0) {
4639            LOGE("RecordThread::getNextBuffer() Error reading audio input");
4640            if (mActiveTrack->mState == TrackBase::ACTIVE) {
4641                // Force input into standby so that it tries to
4642                // recover at next read attempt
4643                mInput->stream->common.standby(&mInput->stream->common);
4644                usleep(kRecordThreadSleepUs);
4645            }
4646            buffer->raw = 0;
4647            buffer->frameCount = 0;
4648            return NOT_ENOUGH_DATA;
4649        }
4650        mRsmpInIndex = 0;
4651        framesReady = mFrameCount;
4652    }
4653
4654    if (framesReq > framesReady) {
4655        framesReq = framesReady;
4656    }
4657
4658    if (mChannelCount == 1 && mReqChannelCount == 2) {
4659        channelCount = 1;
4660    } else {
4661        channelCount = 2;
4662    }
4663    buffer->raw = mRsmpInBuffer + mRsmpInIndex * channelCount;
4664    buffer->frameCount = framesReq;
4665    return NO_ERROR;
4666}
4667
4668void AudioFlinger::RecordThread::releaseBuffer(AudioBufferProvider::Buffer* buffer)
4669{
4670    mRsmpInIndex += buffer->frameCount;
4671    buffer->frameCount = 0;
4672}
4673
4674bool AudioFlinger::RecordThread::checkForNewParameters_l()
4675{
4676    bool reconfig = false;
4677
4678    while (!mNewParameters.isEmpty()) {
4679        status_t status = NO_ERROR;
4680        String8 keyValuePair = mNewParameters[0];
4681        AudioParameter param = AudioParameter(keyValuePair);
4682        int value;
4683        int reqFormat = mFormat;
4684        int reqSamplingRate = mReqSampleRate;
4685        int reqChannelCount = mReqChannelCount;
4686
4687        if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
4688            reqSamplingRate = value;
4689            reconfig = true;
4690        }
4691        if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
4692            reqFormat = value;
4693            reconfig = true;
4694        }
4695        if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
4696            reqChannelCount = popcount(value);
4697            reconfig = true;
4698        }
4699        if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
4700            // do not accept frame count changes if tracks are open as the track buffer
4701            // size depends on frame count and correct behavior would not be garantied
4702            // if frame count is changed after track creation
4703            if (mActiveTrack != 0) {
4704                status = INVALID_OPERATION;
4705            } else {
4706                reconfig = true;
4707            }
4708        }
4709        if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
4710            // forward device change to effects that have requested to be
4711            // aware of attached audio device.
4712            for (size_t i = 0; i < mEffectChains.size(); i++) {
4713                mEffectChains[i]->setDevice_l(value);
4714            }
4715            // store input device and output device but do not forward output device to audio HAL.
4716            // Note that status is ignored by the caller for output device
4717            // (see AudioFlinger::setParameters()
4718            if (value & AUDIO_DEVICE_OUT_ALL) {
4719                mDevice &= (uint32_t)~(value & AUDIO_DEVICE_OUT_ALL);
4720                status = BAD_VALUE;
4721            } else {
4722                mDevice &= (uint32_t)~(value & AUDIO_DEVICE_IN_ALL);
4723                // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
4724                if (mTrack != NULL) {
4725                    bool suspend = audio_is_bluetooth_sco_device(
4726                            (audio_devices_t)value) && mAudioFlinger->btNrecIsOff();
4727                    setEffectSuspended_l(FX_IID_AEC, suspend, mTrack->sessionId());
4728                    setEffectSuspended_l(FX_IID_NS, suspend, mTrack->sessionId());
4729                }
4730            }
4731            mDevice |= (uint32_t)value;
4732        }
4733        if (status == NO_ERROR) {
4734            status = mInput->stream->common.set_parameters(&mInput->stream->common, keyValuePair.string());
4735            if (status == INVALID_OPERATION) {
4736               mInput->stream->common.standby(&mInput->stream->common);
4737               status = mInput->stream->common.set_parameters(&mInput->stream->common, keyValuePair.string());
4738            }
4739            if (reconfig) {
4740                if (status == BAD_VALUE &&
4741                    reqFormat == mInput->stream->common.get_format(&mInput->stream->common) &&
4742                    reqFormat == AUDIO_FORMAT_PCM_16_BIT &&
4743                    ((int)mInput->stream->common.get_sample_rate(&mInput->stream->common) <= (2 * reqSamplingRate)) &&
4744                    (popcount(mInput->stream->common.get_channels(&mInput->stream->common)) < 3) &&
4745                    (reqChannelCount < 3)) {
4746                    status = NO_ERROR;
4747                }
4748                if (status == NO_ERROR) {
4749                    readInputParameters();
4750                    sendConfigEvent_l(AudioSystem::INPUT_CONFIG_CHANGED);
4751                }
4752            }
4753        }
4754
4755        mNewParameters.removeAt(0);
4756
4757        mParamStatus = status;
4758        mParamCond.signal();
4759        // wait for condition with time out in case the thread calling ThreadBase::setParameters()
4760        // already timed out waiting for the status and will never signal the condition.
4761        mWaitWorkCV.waitRelative(mLock, kSetParametersTimeout);
4762    }
4763    return reconfig;
4764}
4765
4766String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
4767{
4768    char *s;
4769    String8 out_s8 = String8();
4770
4771    Mutex::Autolock _l(mLock);
4772    if (initCheck() != NO_ERROR) {
4773        return out_s8;
4774    }
4775
4776    s = mInput->stream->common.get_parameters(&mInput->stream->common, keys.string());
4777    out_s8 = String8(s);
4778    free(s);
4779    return out_s8;
4780}
4781
4782void AudioFlinger::RecordThread::audioConfigChanged_l(int event, int param) {
4783    AudioSystem::OutputDescriptor desc;
4784    void *param2 = 0;
4785
4786    switch (event) {
4787    case AudioSystem::INPUT_OPENED:
4788    case AudioSystem::INPUT_CONFIG_CHANGED:
4789        desc.channels = mChannelMask;
4790        desc.samplingRate = mSampleRate;
4791        desc.format = mFormat;
4792        desc.frameCount = mFrameCount;
4793        desc.latency = 0;
4794        param2 = &desc;
4795        break;
4796
4797    case AudioSystem::INPUT_CLOSED:
4798    default:
4799        break;
4800    }
4801    mAudioFlinger->audioConfigChanged_l(event, mId, param2);
4802}
4803
4804void AudioFlinger::RecordThread::readInputParameters()
4805{
4806    if (mRsmpInBuffer) delete mRsmpInBuffer;
4807    if (mRsmpOutBuffer) delete mRsmpOutBuffer;
4808    if (mResampler) delete mResampler;
4809    mResampler = 0;
4810
4811    mSampleRate = mInput->stream->common.get_sample_rate(&mInput->stream->common);
4812    mChannelMask = mInput->stream->common.get_channels(&mInput->stream->common);
4813    mChannelCount = (uint16_t)popcount(mChannelMask);
4814    mFormat = mInput->stream->common.get_format(&mInput->stream->common);
4815    mFrameSize = (uint16_t)audio_stream_frame_size(&mInput->stream->common);
4816    mInputBytes = mInput->stream->common.get_buffer_size(&mInput->stream->common);
4817    mFrameCount = mInputBytes / mFrameSize;
4818    mRsmpInBuffer = new int16_t[mFrameCount * mChannelCount];
4819
4820    if (mSampleRate != mReqSampleRate && mChannelCount < 3 && mReqChannelCount < 3)
4821    {
4822        int channelCount;
4823         // optmization: if mono to mono, use the resampler in stereo to stereo mode to avoid
4824         // stereo to mono post process as the resampler always outputs stereo.
4825        if (mChannelCount == 1 && mReqChannelCount == 2) {
4826            channelCount = 1;
4827        } else {
4828            channelCount = 2;
4829        }
4830        mResampler = AudioResampler::create(16, channelCount, mReqSampleRate);
4831        mResampler->setSampleRate(mSampleRate);
4832        mResampler->setVolume(AudioMixer::UNITY_GAIN, AudioMixer::UNITY_GAIN);
4833        mRsmpOutBuffer = new int32_t[mFrameCount * 2];
4834
4835        // optmization: if mono to mono, alter input frame count as if we were inputing stereo samples
4836        if (mChannelCount == 1 && mReqChannelCount == 1) {
4837            mFrameCount >>= 1;
4838        }
4839
4840    }
4841    mRsmpInIndex = mFrameCount;
4842}
4843
4844unsigned int AudioFlinger::RecordThread::getInputFramesLost()
4845{
4846    Mutex::Autolock _l(mLock);
4847    if (initCheck() != NO_ERROR) {
4848        return 0;
4849    }
4850
4851    return mInput->stream->get_input_frames_lost(mInput->stream);
4852}
4853
4854uint32_t AudioFlinger::RecordThread::hasAudioSession(int sessionId)
4855{
4856    Mutex::Autolock _l(mLock);
4857    uint32_t result = 0;
4858    if (getEffectChain_l(sessionId) != 0) {
4859        result = EFFECT_SESSION;
4860    }
4861
4862    if (mTrack != NULL && sessionId == mTrack->sessionId()) {
4863        result |= TRACK_SESSION;
4864    }
4865
4866    return result;
4867}
4868
4869AudioFlinger::RecordThread::RecordTrack* AudioFlinger::RecordThread::track()
4870{
4871    Mutex::Autolock _l(mLock);
4872    return mTrack;
4873}
4874
4875AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::getInput()
4876{
4877    Mutex::Autolock _l(mLock);
4878    return mInput;
4879}
4880
4881AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
4882{
4883    Mutex::Autolock _l(mLock);
4884    AudioStreamIn *input = mInput;
4885    mInput = NULL;
4886    return input;
4887}
4888
4889// this method must always be called either with ThreadBase mLock held or inside the thread loop
4890audio_stream_t* AudioFlinger::RecordThread::stream()
4891{
4892    if (mInput == NULL) {
4893        return NULL;
4894    }
4895    return &mInput->stream->common;
4896}
4897
4898
4899// ----------------------------------------------------------------------------
4900
4901int AudioFlinger::openOutput(uint32_t *pDevices,
4902                                uint32_t *pSamplingRate,
4903                                uint32_t *pFormat,
4904                                uint32_t *pChannels,
4905                                uint32_t *pLatencyMs,
4906                                uint32_t flags)
4907{
4908    status_t status;
4909    PlaybackThread *thread = NULL;
4910    mHardwareStatus = AUDIO_HW_OUTPUT_OPEN;
4911    uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
4912    uint32_t format = pFormat ? *pFormat : 0;
4913    uint32_t channels = pChannels ? *pChannels : 0;
4914    uint32_t latency = pLatencyMs ? *pLatencyMs : 0;
4915    audio_stream_out_t *outStream;
4916    audio_hw_device_t *outHwDev;
4917
4918    LOGV("openOutput(), Device %x, SamplingRate %d, Format %d, Channels %x, flags %x",
4919            pDevices ? *pDevices : 0,
4920            samplingRate,
4921            format,
4922            channels,
4923            flags);
4924
4925    if (pDevices == NULL || *pDevices == 0) {
4926        return 0;
4927    }
4928
4929    Mutex::Autolock _l(mLock);
4930
4931    outHwDev = findSuitableHwDev_l(*pDevices);
4932    if (outHwDev == NULL)
4933        return 0;
4934
4935    status = outHwDev->open_output_stream(outHwDev, *pDevices, (int *)&format,
4936                                          &channels, &samplingRate, &outStream);
4937    LOGV("openOutput() openOutputStream returned output %p, SamplingRate %d, Format %d, Channels %x, status %d",
4938            outStream,
4939            samplingRate,
4940            format,
4941            channels,
4942            status);
4943
4944    mHardwareStatus = AUDIO_HW_IDLE;
4945    if (outStream != NULL) {
4946        AudioStreamOut *output = new AudioStreamOut(outHwDev, outStream);
4947        int id = nextUniqueId();
4948
4949        if ((flags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT) ||
4950            (format != AUDIO_FORMAT_PCM_16_BIT) ||
4951            (channels != AUDIO_CHANNEL_OUT_STEREO)) {
4952            thread = new DirectOutputThread(this, output, id, *pDevices);
4953            LOGV("openOutput() created direct output: ID %d thread %p", id, thread);
4954        } else {
4955            thread = new MixerThread(this, output, id, *pDevices);
4956            LOGV("openOutput() created mixer output: ID %d thread %p", id, thread);
4957        }
4958        mPlaybackThreads.add(id, thread);
4959
4960        if (pSamplingRate) *pSamplingRate = samplingRate;
4961        if (pFormat) *pFormat = format;
4962        if (pChannels) *pChannels = channels;
4963        if (pLatencyMs) *pLatencyMs = thread->latency();
4964
4965        // notify client processes of the new output creation
4966        thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED);
4967        return id;
4968    }
4969
4970    return 0;
4971}
4972
4973int AudioFlinger::openDuplicateOutput(int output1, int output2)
4974{
4975    Mutex::Autolock _l(mLock);
4976    MixerThread *thread1 = checkMixerThread_l(output1);
4977    MixerThread *thread2 = checkMixerThread_l(output2);
4978
4979    if (thread1 == NULL || thread2 == NULL) {
4980        LOGW("openDuplicateOutput() wrong output mixer type for output %d or %d", output1, output2);
4981        return 0;
4982    }
4983
4984    int id = nextUniqueId();
4985    DuplicatingThread *thread = new DuplicatingThread(this, thread1, id);
4986    thread->addOutputTrack(thread2);
4987    mPlaybackThreads.add(id, thread);
4988    // notify client processes of the new output creation
4989    thread->audioConfigChanged_l(AudioSystem::OUTPUT_OPENED);
4990    return id;
4991}
4992
4993status_t AudioFlinger::closeOutput(int output)
4994{
4995    // keep strong reference on the playback thread so that
4996    // it is not destroyed while exit() is executed
4997    sp <PlaybackThread> thread;
4998    {
4999        Mutex::Autolock _l(mLock);
5000        thread = checkPlaybackThread_l(output);
5001        if (thread == NULL) {
5002            return BAD_VALUE;
5003        }
5004
5005        LOGV("closeOutput() %d", output);
5006
5007        if (thread->type() == ThreadBase::MIXER) {
5008            for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
5009                if (mPlaybackThreads.valueAt(i)->type() == ThreadBase::DUPLICATING) {
5010                    DuplicatingThread *dupThread = (DuplicatingThread *)mPlaybackThreads.valueAt(i).get();
5011                    dupThread->removeOutputTrack((MixerThread *)thread.get());
5012                }
5013            }
5014        }
5015        void *param2 = 0;
5016        audioConfigChanged_l(AudioSystem::OUTPUT_CLOSED, output, param2);
5017        mPlaybackThreads.removeItem(output);
5018    }
5019    thread->exit();
5020
5021    if (thread->type() != ThreadBase::DUPLICATING) {
5022        AudioStreamOut *out = thread->clearOutput();
5023        // from now on thread->mOutput is NULL
5024        out->hwDev->close_output_stream(out->hwDev, out->stream);
5025        delete out;
5026    }
5027    return NO_ERROR;
5028}
5029
5030status_t AudioFlinger::suspendOutput(int output)
5031{
5032    Mutex::Autolock _l(mLock);
5033    PlaybackThread *thread = checkPlaybackThread_l(output);
5034
5035    if (thread == NULL) {
5036        return BAD_VALUE;
5037    }
5038
5039    LOGV("suspendOutput() %d", output);
5040    thread->suspend();
5041
5042    return NO_ERROR;
5043}
5044
5045status_t AudioFlinger::restoreOutput(int output)
5046{
5047    Mutex::Autolock _l(mLock);
5048    PlaybackThread *thread = checkPlaybackThread_l(output);
5049
5050    if (thread == NULL) {
5051        return BAD_VALUE;
5052    }
5053
5054    LOGV("restoreOutput() %d", output);
5055
5056    thread->restore();
5057
5058    return NO_ERROR;
5059}
5060
5061int AudioFlinger::openInput(uint32_t *pDevices,
5062                                uint32_t *pSamplingRate,
5063                                uint32_t *pFormat,
5064                                uint32_t *pChannels,
5065                                uint32_t acoustics)
5066{
5067    status_t status;
5068    RecordThread *thread = NULL;
5069    uint32_t samplingRate = pSamplingRate ? *pSamplingRate : 0;
5070    uint32_t format = pFormat ? *pFormat : 0;
5071    uint32_t channels = pChannels ? *pChannels : 0;
5072    uint32_t reqSamplingRate = samplingRate;
5073    uint32_t reqFormat = format;
5074    uint32_t reqChannels = channels;
5075    audio_stream_in_t *inStream;
5076    audio_hw_device_t *inHwDev;
5077
5078    if (pDevices == NULL || *pDevices == 0) {
5079        return 0;
5080    }
5081
5082    Mutex::Autolock _l(mLock);
5083
5084    inHwDev = findSuitableHwDev_l(*pDevices);
5085    if (inHwDev == NULL)
5086        return 0;
5087
5088    status = inHwDev->open_input_stream(inHwDev, *pDevices, (int *)&format,
5089                                        &channels, &samplingRate,
5090                                        (audio_in_acoustics_t)acoustics,
5091                                        &inStream);
5092    LOGV("openInput() openInputStream returned input %p, SamplingRate %d, Format %d, Channels %x, acoustics %x, status %d",
5093            inStream,
5094            samplingRate,
5095            format,
5096            channels,
5097            acoustics,
5098            status);
5099
5100    // If the input could not be opened with the requested parameters and we can handle the conversion internally,
5101    // try to open again with the proposed parameters. The AudioFlinger can resample the input and do mono to stereo
5102    // or stereo to mono conversions on 16 bit PCM inputs.
5103    if (inStream == NULL && status == BAD_VALUE &&
5104        reqFormat == format && format == AUDIO_FORMAT_PCM_16_BIT &&
5105        (samplingRate <= 2 * reqSamplingRate) &&
5106        (popcount(channels) < 3) && (popcount(reqChannels) < 3)) {
5107        LOGV("openInput() reopening with proposed sampling rate and channels");
5108        status = inHwDev->open_input_stream(inHwDev, *pDevices, (int *)&format,
5109                                            &channels, &samplingRate,
5110                                            (audio_in_acoustics_t)acoustics,
5111                                            &inStream);
5112    }
5113
5114    if (inStream != NULL) {
5115        AudioStreamIn *input = new AudioStreamIn(inHwDev, inStream);
5116
5117        int id = nextUniqueId();
5118        // Start record thread
5119        // RecorThread require both input and output device indication to forward to audio
5120        // pre processing modules
5121        uint32_t device = (*pDevices) | primaryOutputDevice_l();
5122        thread = new RecordThread(this,
5123                                  input,
5124                                  reqSamplingRate,
5125                                  reqChannels,
5126                                  id,
5127                                  device);
5128        mRecordThreads.add(id, thread);
5129        LOGV("openInput() created record thread: ID %d thread %p", id, thread);
5130        if (pSamplingRate) *pSamplingRate = reqSamplingRate;
5131        if (pFormat) *pFormat = format;
5132        if (pChannels) *pChannels = reqChannels;
5133
5134        input->stream->common.standby(&input->stream->common);
5135
5136        // notify client processes of the new input creation
5137        thread->audioConfigChanged_l(AudioSystem::INPUT_OPENED);
5138        return id;
5139    }
5140
5141    return 0;
5142}
5143
5144status_t AudioFlinger::closeInput(int input)
5145{
5146    // keep strong reference on the record thread so that
5147    // it is not destroyed while exit() is executed
5148    sp <RecordThread> thread;
5149    {
5150        Mutex::Autolock _l(mLock);
5151        thread = checkRecordThread_l(input);
5152        if (thread == NULL) {
5153            return BAD_VALUE;
5154        }
5155
5156        LOGV("closeInput() %d", input);
5157        void *param2 = 0;
5158        audioConfigChanged_l(AudioSystem::INPUT_CLOSED, input, param2);
5159        mRecordThreads.removeItem(input);
5160    }
5161    thread->exit();
5162
5163    AudioStreamIn *in = thread->clearInput();
5164    // from now on thread->mInput is NULL
5165    in->hwDev->close_input_stream(in->hwDev, in->stream);
5166    delete in;
5167
5168    return NO_ERROR;
5169}
5170
5171status_t AudioFlinger::setStreamOutput(uint32_t stream, int output)
5172{
5173    Mutex::Autolock _l(mLock);
5174    MixerThread *dstThread = checkMixerThread_l(output);
5175    if (dstThread == NULL) {
5176        LOGW("setStreamOutput() bad output id %d", output);
5177        return BAD_VALUE;
5178    }
5179
5180    LOGV("setStreamOutput() stream %d to output %d", stream, output);
5181    audioConfigChanged_l(AudioSystem::STREAM_CONFIG_CHANGED, output, &stream);
5182
5183    dstThread->setStreamValid(stream, true);
5184
5185    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
5186        PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
5187        if (thread != dstThread &&
5188            thread->type() != ThreadBase::DIRECT) {
5189            MixerThread *srcThread = (MixerThread *)thread;
5190            srcThread->setStreamValid(stream, false);
5191            srcThread->invalidateTracks(stream);
5192        }
5193    }
5194
5195    return NO_ERROR;
5196}
5197
5198
5199int AudioFlinger::newAudioSessionId()
5200{
5201    return nextUniqueId();
5202}
5203
5204void AudioFlinger::acquireAudioSessionId(int audioSession)
5205{
5206    Mutex::Autolock _l(mLock);
5207    int caller = IPCThreadState::self()->getCallingPid();
5208    LOGV("acquiring %d from %d", audioSession, caller);
5209    int num = mAudioSessionRefs.size();
5210    for (int i = 0; i< num; i++) {
5211        AudioSessionRef *ref = mAudioSessionRefs.editItemAt(i);
5212        if (ref->sessionid == audioSession && ref->pid == caller) {
5213            ref->cnt++;
5214            LOGV(" incremented refcount to %d", ref->cnt);
5215            return;
5216        }
5217    }
5218    AudioSessionRef *ref = new AudioSessionRef();
5219    ref->sessionid = audioSession;
5220    ref->pid = caller;
5221    ref->cnt = 1;
5222    mAudioSessionRefs.push(ref);
5223    LOGV(" added new entry for %d", ref->sessionid);
5224}
5225
5226void AudioFlinger::releaseAudioSessionId(int audioSession)
5227{
5228    Mutex::Autolock _l(mLock);
5229    int caller = IPCThreadState::self()->getCallingPid();
5230    LOGV("releasing %d from %d", audioSession, caller);
5231    int num = mAudioSessionRefs.size();
5232    for (int i = 0; i< num; i++) {
5233        AudioSessionRef *ref = mAudioSessionRefs.itemAt(i);
5234        if (ref->sessionid == audioSession && ref->pid == caller) {
5235            ref->cnt--;
5236            LOGV(" decremented refcount to %d", ref->cnt);
5237            if (ref->cnt == 0) {
5238                mAudioSessionRefs.removeAt(i);
5239                delete ref;
5240                purgeStaleEffects_l();
5241            }
5242            return;
5243        }
5244    }
5245    LOGW("session id %d not found for pid %d", audioSession, caller);
5246}
5247
5248void AudioFlinger::purgeStaleEffects_l() {
5249
5250    LOGV("purging stale effects");
5251
5252    Vector< sp<EffectChain> > chains;
5253
5254    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
5255        sp<PlaybackThread> t = mPlaybackThreads.valueAt(i);
5256        for (size_t j = 0; j < t->mEffectChains.size(); j++) {
5257            sp<EffectChain> ec = t->mEffectChains[j];
5258            if (ec->sessionId() > AUDIO_SESSION_OUTPUT_MIX) {
5259                chains.push(ec);
5260            }
5261        }
5262    }
5263    for (size_t i = 0; i < mRecordThreads.size(); i++) {
5264        sp<RecordThread> t = mRecordThreads.valueAt(i);
5265        for (size_t j = 0; j < t->mEffectChains.size(); j++) {
5266            sp<EffectChain> ec = t->mEffectChains[j];
5267            chains.push(ec);
5268        }
5269    }
5270
5271    for (size_t i = 0; i < chains.size(); i++) {
5272        sp<EffectChain> ec = chains[i];
5273        int sessionid = ec->sessionId();
5274        sp<ThreadBase> t = ec->mThread.promote();
5275        if (t == 0) {
5276            continue;
5277        }
5278        size_t numsessionrefs = mAudioSessionRefs.size();
5279        bool found = false;
5280        for (size_t k = 0; k < numsessionrefs; k++) {
5281            AudioSessionRef *ref = mAudioSessionRefs.itemAt(k);
5282            if (ref->sessionid == sessionid) {
5283                LOGV(" session %d still exists for %d with %d refs",
5284                     sessionid, ref->pid, ref->cnt);
5285                found = true;
5286                break;
5287            }
5288        }
5289        if (!found) {
5290            // remove all effects from the chain
5291            while (ec->mEffects.size()) {
5292                sp<EffectModule> effect = ec->mEffects[0];
5293                effect->unPin();
5294                Mutex::Autolock _l (t->mLock);
5295                t->removeEffect_l(effect);
5296                for (size_t j = 0; j < effect->mHandles.size(); j++) {
5297                    sp<EffectHandle> handle = effect->mHandles[j].promote();
5298                    if (handle != 0) {
5299                        handle->mEffect.clear();
5300                        if (handle->mHasControl && handle->mEnabled) {
5301                            t->checkSuspendOnEffectEnabled_l(effect, false, effect->sessionId());
5302                        }
5303                    }
5304                }
5305                AudioSystem::unregisterEffect(effect->id());
5306            }
5307        }
5308    }
5309    return;
5310}
5311
5312// checkPlaybackThread_l() must be called with AudioFlinger::mLock held
5313AudioFlinger::PlaybackThread *AudioFlinger::checkPlaybackThread_l(int output) const
5314{
5315    PlaybackThread *thread = NULL;
5316    if (mPlaybackThreads.indexOfKey(output) >= 0) {
5317        thread = (PlaybackThread *)mPlaybackThreads.valueFor(output).get();
5318    }
5319    return thread;
5320}
5321
5322// checkMixerThread_l() must be called with AudioFlinger::mLock held
5323AudioFlinger::MixerThread *AudioFlinger::checkMixerThread_l(int output) const
5324{
5325    PlaybackThread *thread = checkPlaybackThread_l(output);
5326    if (thread != NULL) {
5327        if (thread->type() == ThreadBase::DIRECT) {
5328            thread = NULL;
5329        }
5330    }
5331    return (MixerThread *)thread;
5332}
5333
5334// checkRecordThread_l() must be called with AudioFlinger::mLock held
5335AudioFlinger::RecordThread *AudioFlinger::checkRecordThread_l(int input) const
5336{
5337    RecordThread *thread = NULL;
5338    if (mRecordThreads.indexOfKey(input) >= 0) {
5339        thread = (RecordThread *)mRecordThreads.valueFor(input).get();
5340    }
5341    return thread;
5342}
5343
5344uint32_t AudioFlinger::nextUniqueId()
5345{
5346    return android_atomic_inc(&mNextUniqueId);
5347}
5348
5349AudioFlinger::PlaybackThread *AudioFlinger::primaryPlaybackThread_l()
5350{
5351    for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
5352        PlaybackThread *thread = mPlaybackThreads.valueAt(i).get();
5353        AudioStreamOut *output = thread->getOutput();
5354        if (output != NULL && output->hwDev == mPrimaryHardwareDev) {
5355            return thread;
5356        }
5357    }
5358    return NULL;
5359}
5360
5361uint32_t AudioFlinger::primaryOutputDevice_l()
5362{
5363    PlaybackThread *thread = primaryPlaybackThread_l();
5364
5365    if (thread == NULL) {
5366        return 0;
5367    }
5368
5369    return thread->device();
5370}
5371
5372
5373// ----------------------------------------------------------------------------
5374//  Effect management
5375// ----------------------------------------------------------------------------
5376
5377
5378status_t AudioFlinger::queryNumberEffects(uint32_t *numEffects)
5379{
5380    Mutex::Autolock _l(mLock);
5381    return EffectQueryNumberEffects(numEffects);
5382}
5383
5384status_t AudioFlinger::queryEffect(uint32_t index, effect_descriptor_t *descriptor)
5385{
5386    Mutex::Autolock _l(mLock);
5387    return EffectQueryEffect(index, descriptor);
5388}
5389
5390status_t AudioFlinger::getEffectDescriptor(effect_uuid_t *pUuid, effect_descriptor_t *descriptor)
5391{
5392    Mutex::Autolock _l(mLock);
5393    return EffectGetDescriptor(pUuid, descriptor);
5394}
5395
5396
5397sp<IEffect> AudioFlinger::createEffect(pid_t pid,
5398        effect_descriptor_t *pDesc,
5399        const sp<IEffectClient>& effectClient,
5400        int32_t priority,
5401        int io,
5402        int sessionId,
5403        status_t *status,
5404        int *id,
5405        int *enabled)
5406{
5407    status_t lStatus = NO_ERROR;
5408    sp<EffectHandle> handle;
5409    effect_descriptor_t desc;
5410    sp<Client> client;
5411    wp<Client> wclient;
5412
5413    LOGV("createEffect pid %d, client %p, priority %d, sessionId %d, io %d",
5414            pid, effectClient.get(), priority, sessionId, io);
5415
5416    if (pDesc == NULL) {
5417        lStatus = BAD_VALUE;
5418        goto Exit;
5419    }
5420
5421    // check audio settings permission for global effects
5422    if (sessionId == AUDIO_SESSION_OUTPUT_MIX && !settingsAllowed()) {
5423        lStatus = PERMISSION_DENIED;
5424        goto Exit;
5425    }
5426
5427    // Session AUDIO_SESSION_OUTPUT_STAGE is reserved for output stage effects
5428    // that can only be created by audio policy manager (running in same process)
5429    if (sessionId == AUDIO_SESSION_OUTPUT_STAGE && getpid() != pid) {
5430        lStatus = PERMISSION_DENIED;
5431        goto Exit;
5432    }
5433
5434    if (io == 0) {
5435        if (sessionId == AUDIO_SESSION_OUTPUT_STAGE) {
5436            // output must be specified by AudioPolicyManager when using session
5437            // AUDIO_SESSION_OUTPUT_STAGE
5438            lStatus = BAD_VALUE;
5439            goto Exit;
5440        } else if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
5441            // if the output returned by getOutputForEffect() is removed before we lock the
5442            // mutex below, the call to checkPlaybackThread_l(io) below will detect it
5443            // and we will exit safely
5444            io = AudioSystem::getOutputForEffect(&desc);
5445        }
5446    }
5447
5448    {
5449        Mutex::Autolock _l(mLock);
5450
5451
5452        if (!EffectIsNullUuid(&pDesc->uuid)) {
5453            // if uuid is specified, request effect descriptor
5454            lStatus = EffectGetDescriptor(&pDesc->uuid, &desc);
5455            if (lStatus < 0) {
5456                LOGW("createEffect() error %d from EffectGetDescriptor", lStatus);
5457                goto Exit;
5458            }
5459        } else {
5460            // if uuid is not specified, look for an available implementation
5461            // of the required type in effect factory
5462            if (EffectIsNullUuid(&pDesc->type)) {
5463                LOGW("createEffect() no effect type");
5464                lStatus = BAD_VALUE;
5465                goto Exit;
5466            }
5467            uint32_t numEffects = 0;
5468            effect_descriptor_t d;
5469            d.flags = 0; // prevent compiler warning
5470            bool found = false;
5471
5472            lStatus = EffectQueryNumberEffects(&numEffects);
5473            if (lStatus < 0) {
5474                LOGW("createEffect() error %d from EffectQueryNumberEffects", lStatus);
5475                goto Exit;
5476            }
5477            for (uint32_t i = 0; i < numEffects; i++) {
5478                lStatus = EffectQueryEffect(i, &desc);
5479                if (lStatus < 0) {
5480                    LOGW("createEffect() error %d from EffectQueryEffect", lStatus);
5481                    continue;
5482                }
5483                if (memcmp(&desc.type, &pDesc->type, sizeof(effect_uuid_t)) == 0) {
5484                    // If matching type found save effect descriptor. If the session is
5485                    // 0 and the effect is not auxiliary, continue enumeration in case
5486                    // an auxiliary version of this effect type is available
5487                    found = true;
5488                    memcpy(&d, &desc, sizeof(effect_descriptor_t));
5489                    if (sessionId != AUDIO_SESSION_OUTPUT_MIX ||
5490                            (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
5491                        break;
5492                    }
5493                }
5494            }
5495            if (!found) {
5496                lStatus = BAD_VALUE;
5497                LOGW("createEffect() effect not found");
5498                goto Exit;
5499            }
5500            // For same effect type, chose auxiliary version over insert version if
5501            // connect to output mix (Compliance to OpenSL ES)
5502            if (sessionId == AUDIO_SESSION_OUTPUT_MIX &&
5503                    (d.flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_AUXILIARY) {
5504                memcpy(&desc, &d, sizeof(effect_descriptor_t));
5505            }
5506        }
5507
5508        // Do not allow auxiliary effects on a session different from 0 (output mix)
5509        if (sessionId != AUDIO_SESSION_OUTPUT_MIX &&
5510             (desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
5511            lStatus = INVALID_OPERATION;
5512            goto Exit;
5513        }
5514
5515        // check recording permission for visualizer
5516        if ((memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) &&
5517            !recordingAllowed()) {
5518            lStatus = PERMISSION_DENIED;
5519            goto Exit;
5520        }
5521
5522        // return effect descriptor
5523        memcpy(pDesc, &desc, sizeof(effect_descriptor_t));
5524
5525        // If output is not specified try to find a matching audio session ID in one of the
5526        // output threads.
5527        // If output is 0 here, sessionId is neither SESSION_OUTPUT_STAGE nor SESSION_OUTPUT_MIX
5528        // because of code checking output when entering the function.
5529        // Note: io is never 0 when creating an effect on an input
5530        if (io == 0) {
5531             // look for the thread where the specified audio session is present
5532            for (size_t i = 0; i < mPlaybackThreads.size(); i++) {
5533                if (mPlaybackThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
5534                    io = mPlaybackThreads.keyAt(i);
5535                    break;
5536                }
5537            }
5538            if (io == 0) {
5539               for (size_t i = 0; i < mRecordThreads.size(); i++) {
5540                   if (mRecordThreads.valueAt(i)->hasAudioSession(sessionId) != 0) {
5541                       io = mRecordThreads.keyAt(i);
5542                       break;
5543                   }
5544               }
5545            }
5546            // If no output thread contains the requested session ID, default to
5547            // first output. The effect chain will be moved to the correct output
5548            // thread when a track with the same session ID is created
5549            if (io == 0 && mPlaybackThreads.size()) {
5550                io = mPlaybackThreads.keyAt(0);
5551            }
5552            LOGV("createEffect() got io %d for effect %s", io, desc.name);
5553        }
5554        ThreadBase *thread = checkRecordThread_l(io);
5555        if (thread == NULL) {
5556            thread = checkPlaybackThread_l(io);
5557            if (thread == NULL) {
5558                LOGE("createEffect() unknown output thread");
5559                lStatus = BAD_VALUE;
5560                goto Exit;
5561            }
5562        }
5563
5564        wclient = mClients.valueFor(pid);
5565
5566        if (wclient != NULL) {
5567            client = wclient.promote();
5568        } else {
5569            client = new Client(this, pid);
5570            mClients.add(pid, client);
5571        }
5572
5573        // create effect on selected output thread
5574        handle = thread->createEffect_l(client, effectClient, priority, sessionId,
5575                &desc, enabled, &lStatus);
5576        if (handle != 0 && id != NULL) {
5577            *id = handle->id();
5578        }
5579    }
5580
5581Exit:
5582    if(status) {
5583        *status = lStatus;
5584    }
5585    return handle;
5586}
5587
5588status_t AudioFlinger::moveEffects(int sessionId, int srcOutput, int dstOutput)
5589{
5590    LOGV("moveEffects() session %d, srcOutput %d, dstOutput %d",
5591            sessionId, srcOutput, dstOutput);
5592    Mutex::Autolock _l(mLock);
5593    if (srcOutput == dstOutput) {
5594        LOGW("moveEffects() same dst and src outputs %d", dstOutput);
5595        return NO_ERROR;
5596    }
5597    PlaybackThread *srcThread = checkPlaybackThread_l(srcOutput);
5598    if (srcThread == NULL) {
5599        LOGW("moveEffects() bad srcOutput %d", srcOutput);
5600        return BAD_VALUE;
5601    }
5602    PlaybackThread *dstThread = checkPlaybackThread_l(dstOutput);
5603    if (dstThread == NULL) {
5604        LOGW("moveEffects() bad dstOutput %d", dstOutput);
5605        return BAD_VALUE;
5606    }
5607
5608    Mutex::Autolock _dl(dstThread->mLock);
5609    Mutex::Autolock _sl(srcThread->mLock);
5610    moveEffectChain_l(sessionId, srcThread, dstThread, false);
5611
5612    return NO_ERROR;
5613}
5614
5615// moveEffectChain_l must be called with both srcThread and dstThread mLocks held
5616status_t AudioFlinger::moveEffectChain_l(int sessionId,
5617                                   AudioFlinger::PlaybackThread *srcThread,
5618                                   AudioFlinger::PlaybackThread *dstThread,
5619                                   bool reRegister)
5620{
5621    LOGV("moveEffectChain_l() session %d from thread %p to thread %p",
5622            sessionId, srcThread, dstThread);
5623
5624    sp<EffectChain> chain = srcThread->getEffectChain_l(sessionId);
5625    if (chain == 0) {
5626        LOGW("moveEffectChain_l() effect chain for session %d not on source thread %p",
5627                sessionId, srcThread);
5628        return INVALID_OPERATION;
5629    }
5630
5631    // remove chain first. This is useful only if reconfiguring effect chain on same output thread,
5632    // so that a new chain is created with correct parameters when first effect is added. This is
5633    // otherwise unnecessary as removeEffect_l() will remove the chain when last effect is
5634    // removed.
5635    srcThread->removeEffectChain_l(chain);
5636
5637    // transfer all effects one by one so that new effect chain is created on new thread with
5638    // correct buffer sizes and audio parameters and effect engines reconfigured accordingly
5639    int dstOutput = dstThread->id();
5640    sp<EffectChain> dstChain;
5641    uint32_t strategy = 0; // prevent compiler warning
5642    sp<EffectModule> effect = chain->getEffectFromId_l(0);
5643    while (effect != 0) {
5644        srcThread->removeEffect_l(effect);
5645        dstThread->addEffect_l(effect);
5646        // removeEffect_l() has stopped the effect if it was active so it must be restarted
5647        if (effect->state() == EffectModule::ACTIVE ||
5648                effect->state() == EffectModule::STOPPING) {
5649            effect->start();
5650        }
5651        // if the move request is not received from audio policy manager, the effect must be
5652        // re-registered with the new strategy and output
5653        if (dstChain == 0) {
5654            dstChain = effect->chain().promote();
5655            if (dstChain == 0) {
5656                LOGW("moveEffectChain_l() cannot get chain from effect %p", effect.get());
5657                srcThread->addEffect_l(effect);
5658                return NO_INIT;
5659            }
5660            strategy = dstChain->strategy();
5661        }
5662        if (reRegister) {
5663            AudioSystem::unregisterEffect(effect->id());
5664            AudioSystem::registerEffect(&effect->desc(),
5665                                        dstOutput,
5666                                        strategy,
5667                                        sessionId,
5668                                        effect->id());
5669        }
5670        effect = chain->getEffectFromId_l(0);
5671    }
5672
5673    return NO_ERROR;
5674}
5675
5676
5677// PlaybackThread::createEffect_l() must be called with AudioFlinger::mLock held
5678sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
5679        const sp<AudioFlinger::Client>& client,
5680        const sp<IEffectClient>& effectClient,
5681        int32_t priority,
5682        int sessionId,
5683        effect_descriptor_t *desc,
5684        int *enabled,
5685        status_t *status
5686        )
5687{
5688    sp<EffectModule> effect;
5689    sp<EffectHandle> handle;
5690    status_t lStatus;
5691    sp<EffectChain> chain;
5692    bool chainCreated = false;
5693    bool effectCreated = false;
5694    bool effectRegistered = false;
5695
5696    lStatus = initCheck();
5697    if (lStatus != NO_ERROR) {
5698        LOGW("createEffect_l() Audio driver not initialized.");
5699        goto Exit;
5700    }
5701
5702    // Do not allow effects with session ID 0 on direct output or duplicating threads
5703    // TODO: add rule for hw accelerated effects on direct outputs with non PCM format
5704    if (sessionId == AUDIO_SESSION_OUTPUT_MIX && mType != MIXER) {
5705        LOGW("createEffect_l() Cannot add auxiliary effect %s to session %d",
5706                desc->name, sessionId);
5707        lStatus = BAD_VALUE;
5708        goto Exit;
5709    }
5710    // Only Pre processor effects are allowed on input threads and only on input threads
5711    if ((mType == RECORD &&
5712            (desc->flags & EFFECT_FLAG_TYPE_MASK) != EFFECT_FLAG_TYPE_PRE_PROC) ||
5713            (mType != RECORD &&
5714                    (desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
5715        LOGW("createEffect_l() effect %s (flags %08x) created on wrong thread type %d",
5716                desc->name, desc->flags, mType);
5717        lStatus = BAD_VALUE;
5718        goto Exit;
5719    }
5720
5721    LOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
5722
5723    { // scope for mLock
5724        Mutex::Autolock _l(mLock);
5725
5726        // check for existing effect chain with the requested audio session
5727        chain = getEffectChain_l(sessionId);
5728        if (chain == 0) {
5729            // create a new chain for this session
5730            LOGV("createEffect_l() new effect chain for session %d", sessionId);
5731            chain = new EffectChain(this, sessionId);
5732            addEffectChain_l(chain);
5733            chain->setStrategy(getStrategyForSession_l(sessionId));
5734            chainCreated = true;
5735        } else {
5736            effect = chain->getEffectFromDesc_l(desc);
5737        }
5738
5739        LOGV("createEffect_l() got effect %p on chain %p", effect == 0 ? 0 : effect.get(), chain.get());
5740
5741        if (effect == 0) {
5742            int id = mAudioFlinger->nextUniqueId();
5743            // Check CPU and memory usage
5744            lStatus = AudioSystem::registerEffect(desc, mId, chain->strategy(), sessionId, id);
5745            if (lStatus != NO_ERROR) {
5746                goto Exit;
5747            }
5748            effectRegistered = true;
5749            // create a new effect module if none present in the chain
5750            effect = new EffectModule(this, chain, desc, id, sessionId);
5751            lStatus = effect->status();
5752            if (lStatus != NO_ERROR) {
5753                goto Exit;
5754            }
5755            lStatus = chain->addEffect_l(effect);
5756            if (lStatus != NO_ERROR) {
5757                goto Exit;
5758            }
5759            effectCreated = true;
5760
5761            effect->setDevice(mDevice);
5762            effect->setMode(mAudioFlinger->getMode());
5763        }
5764        // create effect handle and connect it to effect module
5765        handle = new EffectHandle(effect, client, effectClient, priority);
5766        lStatus = effect->addHandle(handle);
5767        if (enabled) {
5768            *enabled = (int)effect->isEnabled();
5769        }
5770    }
5771
5772Exit:
5773    if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
5774        Mutex::Autolock _l(mLock);
5775        if (effectCreated) {
5776            chain->removeEffect_l(effect);
5777        }
5778        if (effectRegistered) {
5779            AudioSystem::unregisterEffect(effect->id());
5780        }
5781        if (chainCreated) {
5782            removeEffectChain_l(chain);
5783        }
5784        handle.clear();
5785    }
5786
5787    if(status) {
5788        *status = lStatus;
5789    }
5790    return handle;
5791}
5792
5793sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(int sessionId, int effectId)
5794{
5795    sp<EffectModule> effect;
5796
5797    sp<EffectChain> chain = getEffectChain_l(sessionId);
5798    if (chain != 0) {
5799        effect = chain->getEffectFromId_l(effectId);
5800    }
5801    return effect;
5802}
5803
5804// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
5805// PlaybackThread::mLock held
5806status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
5807{
5808    // check for existing effect chain with the requested audio session
5809    int sessionId = effect->sessionId();
5810    sp<EffectChain> chain = getEffectChain_l(sessionId);
5811    bool chainCreated = false;
5812
5813    if (chain == 0) {
5814        // create a new chain for this session
5815        LOGV("addEffect_l() new effect chain for session %d", sessionId);
5816        chain = new EffectChain(this, sessionId);
5817        addEffectChain_l(chain);
5818        chain->setStrategy(getStrategyForSession_l(sessionId));
5819        chainCreated = true;
5820    }
5821    LOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
5822
5823    if (chain->getEffectFromId_l(effect->id()) != 0) {
5824        LOGW("addEffect_l() %p effect %s already present in chain %p",
5825                this, effect->desc().name, chain.get());
5826        return BAD_VALUE;
5827    }
5828
5829    status_t status = chain->addEffect_l(effect);
5830    if (status != NO_ERROR) {
5831        if (chainCreated) {
5832            removeEffectChain_l(chain);
5833        }
5834        return status;
5835    }
5836
5837    effect->setDevice(mDevice);
5838    effect->setMode(mAudioFlinger->getMode());
5839    return NO_ERROR;
5840}
5841
5842void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect) {
5843
5844    LOGV("removeEffect_l() %p effect %p", this, effect.get());
5845    effect_descriptor_t desc = effect->desc();
5846    if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
5847        detachAuxEffect_l(effect->id());
5848    }
5849
5850    sp<EffectChain> chain = effect->chain().promote();
5851    if (chain != 0) {
5852        // remove effect chain if removing last effect
5853        if (chain->removeEffect_l(effect) == 0) {
5854            removeEffectChain_l(chain);
5855        }
5856    } else {
5857        LOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
5858    }
5859}
5860
5861void AudioFlinger::ThreadBase::lockEffectChains_l(
5862        Vector<sp <AudioFlinger::EffectChain> >& effectChains)
5863{
5864    effectChains = mEffectChains;
5865    for (size_t i = 0; i < mEffectChains.size(); i++) {
5866        mEffectChains[i]->lock();
5867    }
5868}
5869
5870void AudioFlinger::ThreadBase::unlockEffectChains(
5871        Vector<sp <AudioFlinger::EffectChain> >& effectChains)
5872{
5873    for (size_t i = 0; i < effectChains.size(); i++) {
5874        effectChains[i]->unlock();
5875    }
5876}
5877
5878sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(int sessionId)
5879{
5880    Mutex::Autolock _l(mLock);
5881    return getEffectChain_l(sessionId);
5882}
5883
5884sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(int sessionId)
5885{
5886    sp<EffectChain> chain;
5887
5888    size_t size = mEffectChains.size();
5889    for (size_t i = 0; i < size; i++) {
5890        if (mEffectChains[i]->sessionId() == sessionId) {
5891            chain = mEffectChains[i];
5892            break;
5893        }
5894    }
5895    return chain;
5896}
5897
5898void AudioFlinger::ThreadBase::setMode(uint32_t mode)
5899{
5900    Mutex::Autolock _l(mLock);
5901    size_t size = mEffectChains.size();
5902    for (size_t i = 0; i < size; i++) {
5903        mEffectChains[i]->setMode_l(mode);
5904    }
5905}
5906
5907void AudioFlinger::ThreadBase::disconnectEffect(const sp<EffectModule>& effect,
5908                                                    const wp<EffectHandle>& handle,
5909                                                    bool unpiniflast) {
5910
5911    Mutex::Autolock _l(mLock);
5912    LOGV("disconnectEffect() %p effect %p", this, effect.get());
5913    // delete the effect module if removing last handle on it
5914    if (effect->removeHandle(handle) == 0) {
5915        if (!effect->isPinned() || unpiniflast) {
5916            removeEffect_l(effect);
5917            AudioSystem::unregisterEffect(effect->id());
5918        }
5919    }
5920}
5921
5922status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
5923{
5924    int session = chain->sessionId();
5925    int16_t *buffer = mMixBuffer;
5926    bool ownsBuffer = false;
5927
5928    LOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
5929    if (session > 0) {
5930        // Only one effect chain can be present in direct output thread and it uses
5931        // the mix buffer as input
5932        if (mType != DIRECT) {
5933            size_t numSamples = mFrameCount * mChannelCount;
5934            buffer = new int16_t[numSamples];
5935            memset(buffer, 0, numSamples * sizeof(int16_t));
5936            LOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session);
5937            ownsBuffer = true;
5938        }
5939
5940        // Attach all tracks with same session ID to this chain.
5941        for (size_t i = 0; i < mTracks.size(); ++i) {
5942            sp<Track> track = mTracks[i];
5943            if (session == track->sessionId()) {
5944                LOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(), buffer);
5945                track->setMainBuffer(buffer);
5946                chain->incTrackCnt();
5947            }
5948        }
5949
5950        // indicate all active tracks in the chain
5951        for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
5952            sp<Track> track = mActiveTracks[i].promote();
5953            if (track == 0) continue;
5954            if (session == track->sessionId()) {
5955                LOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
5956                chain->incActiveTrackCnt();
5957            }
5958        }
5959    }
5960
5961    chain->setInBuffer(buffer, ownsBuffer);
5962    chain->setOutBuffer(mMixBuffer);
5963    // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect
5964    // chains list in order to be processed last as it contains output stage effects
5965    // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
5966    // session AUDIO_SESSION_OUTPUT_STAGE to be processed
5967    // after track specific effects and before output stage
5968    // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
5969    // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX
5970    // Effect chain for other sessions are inserted at beginning of effect
5971    // chains list to be processed before output mix effects. Relative order between other
5972    // sessions is not important
5973    size_t size = mEffectChains.size();
5974    size_t i = 0;
5975    for (i = 0; i < size; i++) {
5976        if (mEffectChains[i]->sessionId() < session) break;
5977    }
5978    mEffectChains.insertAt(chain, i);
5979    checkSuspendOnAddEffectChain_l(chain);
5980
5981    return NO_ERROR;
5982}
5983
5984size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
5985{
5986    int session = chain->sessionId();
5987
5988    LOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
5989
5990    for (size_t i = 0; i < mEffectChains.size(); i++) {
5991        if (chain == mEffectChains[i]) {
5992            mEffectChains.removeAt(i);
5993            // detach all active tracks from the chain
5994            for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
5995                sp<Track> track = mActiveTracks[i].promote();
5996                if (track == 0) continue;
5997                if (session == track->sessionId()) {
5998                    LOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
5999                            chain.get(), session);
6000                    chain->decActiveTrackCnt();
6001                }
6002            }
6003
6004            // detach all tracks with same session ID from this chain
6005            for (size_t i = 0; i < mTracks.size(); ++i) {
6006                sp<Track> track = mTracks[i];
6007                if (session == track->sessionId()) {
6008                    track->setMainBuffer(mMixBuffer);
6009                    chain->decTrackCnt();
6010                }
6011            }
6012            break;
6013        }
6014    }
6015    return mEffectChains.size();
6016}
6017
6018status_t AudioFlinger::PlaybackThread::attachAuxEffect(
6019        const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
6020{
6021    Mutex::Autolock _l(mLock);
6022    return attachAuxEffect_l(track, EffectId);
6023}
6024
6025status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
6026        const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
6027{
6028    status_t status = NO_ERROR;
6029
6030    if (EffectId == 0) {
6031        track->setAuxBuffer(0, NULL);
6032    } else {
6033        // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
6034        sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
6035        if (effect != 0) {
6036            if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
6037                track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
6038            } else {
6039                status = INVALID_OPERATION;
6040            }
6041        } else {
6042            status = BAD_VALUE;
6043        }
6044    }
6045    return status;
6046}
6047
6048void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
6049{
6050     for (size_t i = 0; i < mTracks.size(); ++i) {
6051        sp<Track> track = mTracks[i];
6052        if (track->auxEffectId() == effectId) {
6053            attachAuxEffect_l(track, 0);
6054        }
6055    }
6056}
6057
6058status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
6059{
6060    // only one chain per input thread
6061    if (mEffectChains.size() != 0) {
6062        return INVALID_OPERATION;
6063    }
6064    LOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
6065
6066    chain->setInBuffer(NULL);
6067    chain->setOutBuffer(NULL);
6068
6069    checkSuspendOnAddEffectChain_l(chain);
6070
6071    mEffectChains.add(chain);
6072
6073    return NO_ERROR;
6074}
6075
6076size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
6077{
6078    LOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
6079    LOGW_IF(mEffectChains.size() != 1,
6080            "removeEffectChain_l() %p invalid chain size %d on thread %p",
6081            chain.get(), mEffectChains.size(), this);
6082    if (mEffectChains.size() == 1) {
6083        mEffectChains.removeAt(0);
6084    }
6085    return 0;
6086}
6087
6088// ----------------------------------------------------------------------------
6089//  EffectModule implementation
6090// ----------------------------------------------------------------------------
6091
6092#undef LOG_TAG
6093#define LOG_TAG "AudioFlinger::EffectModule"
6094
6095AudioFlinger::EffectModule::EffectModule(const wp<ThreadBase>& wThread,
6096                                        const wp<AudioFlinger::EffectChain>& chain,
6097                                        effect_descriptor_t *desc,
6098                                        int id,
6099                                        int sessionId)
6100    : mThread(wThread), mChain(chain), mId(id), mSessionId(sessionId), mEffectInterface(NULL),
6101      mStatus(NO_INIT), mState(IDLE), mSuspended(false)
6102{
6103    LOGV("Constructor %p", this);
6104    int lStatus;
6105    sp<ThreadBase> thread = mThread.promote();
6106    if (thread == 0) {
6107        return;
6108    }
6109
6110    memcpy(&mDescriptor, desc, sizeof(effect_descriptor_t));
6111
6112    // create effect engine from effect factory
6113    mStatus = EffectCreate(&desc->uuid, sessionId, thread->id(), &mEffectInterface);
6114
6115    if (mStatus != NO_ERROR) {
6116        return;
6117    }
6118    lStatus = init();
6119    if (lStatus < 0) {
6120        mStatus = lStatus;
6121        goto Error;
6122    }
6123
6124    if (mSessionId > AUDIO_SESSION_OUTPUT_MIX) {
6125        mPinned = true;
6126    }
6127    LOGV("Constructor success name %s, Interface %p", mDescriptor.name, mEffectInterface);
6128    return;
6129Error:
6130    EffectRelease(mEffectInterface);
6131    mEffectInterface = NULL;
6132    LOGV("Constructor Error %d", mStatus);
6133}
6134
6135AudioFlinger::EffectModule::~EffectModule()
6136{
6137    LOGV("Destructor %p", this);
6138    if (mEffectInterface != NULL) {
6139        if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
6140                (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC) {
6141            sp<ThreadBase> thread = mThread.promote();
6142            if (thread != 0) {
6143                audio_stream_t *stream = thread->stream();
6144                if (stream != NULL) {
6145                    stream->remove_audio_effect(stream, mEffectInterface);
6146                }
6147            }
6148        }
6149        // release effect engine
6150        EffectRelease(mEffectInterface);
6151    }
6152}
6153
6154status_t AudioFlinger::EffectModule::addHandle(sp<EffectHandle>& handle)
6155{
6156    status_t status;
6157
6158    Mutex::Autolock _l(mLock);
6159    // First handle in mHandles has highest priority and controls the effect module
6160    int priority = handle->priority();
6161    size_t size = mHandles.size();
6162    sp<EffectHandle> h;
6163    size_t i;
6164    for (i = 0; i < size; i++) {
6165        h = mHandles[i].promote();
6166        if (h == 0) continue;
6167        if (h->priority() <= priority) break;
6168    }
6169    // if inserted in first place, move effect control from previous owner to this handle
6170    if (i == 0) {
6171        bool enabled = false;
6172        if (h != 0) {
6173            enabled = h->enabled();
6174            h->setControl(false/*hasControl*/, true /*signal*/, enabled /*enabled*/);
6175        }
6176        handle->setControl(true /*hasControl*/, false /*signal*/, enabled /*enabled*/);
6177        status = NO_ERROR;
6178    } else {
6179        status = ALREADY_EXISTS;
6180    }
6181    LOGV("addHandle() %p added handle %p in position %d", this, handle.get(), i);
6182    mHandles.insertAt(handle, i);
6183    return status;
6184}
6185
6186size_t AudioFlinger::EffectModule::removeHandle(const wp<EffectHandle>& handle)
6187{
6188    Mutex::Autolock _l(mLock);
6189    size_t size = mHandles.size();
6190    size_t i;
6191    for (i = 0; i < size; i++) {
6192        if (mHandles[i] == handle) break;
6193    }
6194    if (i == size) {
6195        return size;
6196    }
6197    LOGV("removeHandle() %p removed handle %p in position %d", this, handle.unsafe_get(), i);
6198
6199    bool enabled = false;
6200    EffectHandle *hdl = handle.unsafe_get();
6201    if (hdl) {
6202        LOGV("removeHandle() unsafe_get OK");
6203        enabled = hdl->enabled();
6204    }
6205    mHandles.removeAt(i);
6206    size = mHandles.size();
6207    // if removed from first place, move effect control from this handle to next in line
6208    if (i == 0 && size != 0) {
6209        sp<EffectHandle> h = mHandles[0].promote();
6210        if (h != 0) {
6211            h->setControl(true /*hasControl*/, true /*signal*/ , enabled /*enabled*/);
6212        }
6213    }
6214
6215    // Prevent calls to process() and other functions on effect interface from now on.
6216    // The effect engine will be released by the destructor when the last strong reference on
6217    // this object is released which can happen after next process is called.
6218    if (size == 0 && !mPinned) {
6219        mState = DESTROYED;
6220    }
6221
6222    return size;
6223}
6224
6225sp<AudioFlinger::EffectHandle> AudioFlinger::EffectModule::controlHandle()
6226{
6227    Mutex::Autolock _l(mLock);
6228    sp<EffectHandle> handle;
6229    if (mHandles.size() != 0) {
6230        handle = mHandles[0].promote();
6231    }
6232    return handle;
6233}
6234
6235void AudioFlinger::EffectModule::disconnect(const wp<EffectHandle>& handle, bool unpiniflast)
6236{
6237    LOGV("disconnect() %p handle %p ", this, handle.unsafe_get());
6238    // keep a strong reference on this EffectModule to avoid calling the
6239    // destructor before we exit
6240    sp<EffectModule> keep(this);
6241    {
6242        sp<ThreadBase> thread = mThread.promote();
6243        if (thread != 0) {
6244            thread->disconnectEffect(keep, handle, unpiniflast);
6245        }
6246    }
6247}
6248
6249void AudioFlinger::EffectModule::updateState() {
6250    Mutex::Autolock _l(mLock);
6251
6252    switch (mState) {
6253    case RESTART:
6254        reset_l();
6255        // FALL THROUGH
6256
6257    case STARTING:
6258        // clear auxiliary effect input buffer for next accumulation
6259        if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
6260            memset(mConfig.inputCfg.buffer.raw,
6261                   0,
6262                   mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
6263        }
6264        start_l();
6265        mState = ACTIVE;
6266        break;
6267    case STOPPING:
6268        stop_l();
6269        mDisableWaitCnt = mMaxDisableWaitCnt;
6270        mState = STOPPED;
6271        break;
6272    case STOPPED:
6273        // mDisableWaitCnt is forced to 1 by process() when the engine indicates the end of the
6274        // turn off sequence.
6275        if (--mDisableWaitCnt == 0) {
6276            reset_l();
6277            mState = IDLE;
6278        }
6279        break;
6280    default: //IDLE , ACTIVE, DESTROYED
6281        break;
6282    }
6283}
6284
6285void AudioFlinger::EffectModule::process()
6286{
6287    Mutex::Autolock _l(mLock);
6288
6289    if (mState == DESTROYED || mEffectInterface == NULL ||
6290            mConfig.inputCfg.buffer.raw == NULL ||
6291            mConfig.outputCfg.buffer.raw == NULL) {
6292        return;
6293    }
6294
6295    if (isProcessEnabled()) {
6296        // do 32 bit to 16 bit conversion for auxiliary effect input buffer
6297        if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
6298            AudioMixer::ditherAndClamp(mConfig.inputCfg.buffer.s32,
6299                                        mConfig.inputCfg.buffer.s32,
6300                                        mConfig.inputCfg.buffer.frameCount/2);
6301        }
6302
6303        // do the actual processing in the effect engine
6304        int ret = (*mEffectInterface)->process(mEffectInterface,
6305                                               &mConfig.inputCfg.buffer,
6306                                               &mConfig.outputCfg.buffer);
6307
6308        // force transition to IDLE state when engine is ready
6309        if (mState == STOPPED && ret == -ENODATA) {
6310            mDisableWaitCnt = 1;
6311        }
6312
6313        // clear auxiliary effect input buffer for next accumulation
6314        if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
6315            memset(mConfig.inputCfg.buffer.raw, 0,
6316                   mConfig.inputCfg.buffer.frameCount*sizeof(int32_t));
6317        }
6318    } else if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_INSERT &&
6319                mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
6320        // If an insert effect is idle and input buffer is different from output buffer,
6321        // accumulate input onto output
6322        sp<EffectChain> chain = mChain.promote();
6323        if (chain != 0 && chain->activeTrackCnt() != 0) {
6324            size_t frameCnt = mConfig.inputCfg.buffer.frameCount * 2;  //always stereo here
6325            int16_t *in = mConfig.inputCfg.buffer.s16;
6326            int16_t *out = mConfig.outputCfg.buffer.s16;
6327            for (size_t i = 0; i < frameCnt; i++) {
6328                out[i] = clamp16((int32_t)out[i] + (int32_t)in[i]);
6329            }
6330        }
6331    }
6332}
6333
6334void AudioFlinger::EffectModule::reset_l()
6335{
6336    if (mEffectInterface == NULL) {
6337        return;
6338    }
6339    (*mEffectInterface)->command(mEffectInterface, EFFECT_CMD_RESET, 0, NULL, 0, NULL);
6340}
6341
6342status_t AudioFlinger::EffectModule::configure()
6343{
6344    uint32_t channels;
6345    if (mEffectInterface == NULL) {
6346        return NO_INIT;
6347    }
6348
6349    sp<ThreadBase> thread = mThread.promote();
6350    if (thread == 0) {
6351        return DEAD_OBJECT;
6352    }
6353
6354    // TODO: handle configuration of effects replacing track process
6355    if (thread->channelCount() == 1) {
6356        channels = AUDIO_CHANNEL_OUT_MONO;
6357    } else {
6358        channels = AUDIO_CHANNEL_OUT_STEREO;
6359    }
6360
6361    if ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
6362        mConfig.inputCfg.channels = AUDIO_CHANNEL_OUT_MONO;
6363    } else {
6364        mConfig.inputCfg.channels = channels;
6365    }
6366    mConfig.outputCfg.channels = channels;
6367    mConfig.inputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
6368    mConfig.outputCfg.format = AUDIO_FORMAT_PCM_16_BIT;
6369    mConfig.inputCfg.samplingRate = thread->sampleRate();
6370    mConfig.outputCfg.samplingRate = mConfig.inputCfg.samplingRate;
6371    mConfig.inputCfg.bufferProvider.cookie = NULL;
6372    mConfig.inputCfg.bufferProvider.getBuffer = NULL;
6373    mConfig.inputCfg.bufferProvider.releaseBuffer = NULL;
6374    mConfig.outputCfg.bufferProvider.cookie = NULL;
6375    mConfig.outputCfg.bufferProvider.getBuffer = NULL;
6376    mConfig.outputCfg.bufferProvider.releaseBuffer = NULL;
6377    mConfig.inputCfg.accessMode = EFFECT_BUFFER_ACCESS_READ;
6378    // Insert effect:
6379    // - in session AUDIO_SESSION_OUTPUT_MIX or AUDIO_SESSION_OUTPUT_STAGE,
6380    // always overwrites output buffer: input buffer == output buffer
6381    // - in other sessions:
6382    //      last effect in the chain accumulates in output buffer: input buffer != output buffer
6383    //      other effect: overwrites output buffer: input buffer == output buffer
6384    // Auxiliary effect:
6385    //      accumulates in output buffer: input buffer != output buffer
6386    // Therefore: accumulate <=> input buffer != output buffer
6387    if (mConfig.inputCfg.buffer.raw != mConfig.outputCfg.buffer.raw) {
6388        mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_ACCUMULATE;
6389    } else {
6390        mConfig.outputCfg.accessMode = EFFECT_BUFFER_ACCESS_WRITE;
6391    }
6392    mConfig.inputCfg.mask = EFFECT_CONFIG_ALL;
6393    mConfig.outputCfg.mask = EFFECT_CONFIG_ALL;
6394    mConfig.inputCfg.buffer.frameCount = thread->frameCount();
6395    mConfig.outputCfg.buffer.frameCount = mConfig.inputCfg.buffer.frameCount;
6396
6397    LOGV("configure() %p thread %p buffer %p framecount %d",
6398            this, thread.get(), mConfig.inputCfg.buffer.raw, mConfig.inputCfg.buffer.frameCount);
6399
6400    status_t cmdStatus;
6401    uint32_t size = sizeof(int);
6402    status_t status = (*mEffectInterface)->command(mEffectInterface,
6403                                                   EFFECT_CMD_CONFIGURE,
6404                                                   sizeof(effect_config_t),
6405                                                   &mConfig,
6406                                                   &size,
6407                                                   &cmdStatus);
6408    if (status == 0) {
6409        status = cmdStatus;
6410    }
6411
6412    mMaxDisableWaitCnt = (MAX_DISABLE_TIME_MS * mConfig.outputCfg.samplingRate) /
6413            (1000 * mConfig.outputCfg.buffer.frameCount);
6414
6415    return status;
6416}
6417
6418status_t AudioFlinger::EffectModule::init()
6419{
6420    Mutex::Autolock _l(mLock);
6421    if (mEffectInterface == NULL) {
6422        return NO_INIT;
6423    }
6424    status_t cmdStatus;
6425    uint32_t size = sizeof(status_t);
6426    status_t status = (*mEffectInterface)->command(mEffectInterface,
6427                                                   EFFECT_CMD_INIT,
6428                                                   0,
6429                                                   NULL,
6430                                                   &size,
6431                                                   &cmdStatus);
6432    if (status == 0) {
6433        status = cmdStatus;
6434    }
6435    return status;
6436}
6437
6438status_t AudioFlinger::EffectModule::start()
6439{
6440    Mutex::Autolock _l(mLock);
6441    return start_l();
6442}
6443
6444status_t AudioFlinger::EffectModule::start_l()
6445{
6446    if (mEffectInterface == NULL) {
6447        return NO_INIT;
6448    }
6449    status_t cmdStatus;
6450    uint32_t size = sizeof(status_t);
6451    status_t status = (*mEffectInterface)->command(mEffectInterface,
6452                                                   EFFECT_CMD_ENABLE,
6453                                                   0,
6454                                                   NULL,
6455                                                   &size,
6456                                                   &cmdStatus);
6457    if (status == 0) {
6458        status = cmdStatus;
6459    }
6460    if (status == 0 &&
6461            ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
6462             (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC)) {
6463        sp<ThreadBase> thread = mThread.promote();
6464        if (thread != 0) {
6465            audio_stream_t *stream = thread->stream();
6466            if (stream != NULL) {
6467                stream->add_audio_effect(stream, mEffectInterface);
6468            }
6469        }
6470    }
6471    return status;
6472}
6473
6474status_t AudioFlinger::EffectModule::stop()
6475{
6476    Mutex::Autolock _l(mLock);
6477    return stop_l();
6478}
6479
6480status_t AudioFlinger::EffectModule::stop_l()
6481{
6482    if (mEffectInterface == NULL) {
6483        return NO_INIT;
6484    }
6485    status_t cmdStatus;
6486    uint32_t size = sizeof(status_t);
6487    status_t status = (*mEffectInterface)->command(mEffectInterface,
6488                                                   EFFECT_CMD_DISABLE,
6489                                                   0,
6490                                                   NULL,
6491                                                   &size,
6492                                                   &cmdStatus);
6493    if (status == 0) {
6494        status = cmdStatus;
6495    }
6496    if (status == 0 &&
6497            ((mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC ||
6498             (mDescriptor.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_POST_PROC)) {
6499        sp<ThreadBase> thread = mThread.promote();
6500        if (thread != 0) {
6501            audio_stream_t *stream = thread->stream();
6502            if (stream != NULL) {
6503                stream->remove_audio_effect(stream, mEffectInterface);
6504            }
6505        }
6506    }
6507    return status;
6508}
6509
6510status_t AudioFlinger::EffectModule::command(uint32_t cmdCode,
6511                                             uint32_t cmdSize,
6512                                             void *pCmdData,
6513                                             uint32_t *replySize,
6514                                             void *pReplyData)
6515{
6516    Mutex::Autolock _l(mLock);
6517//    LOGV("command(), cmdCode: %d, mEffectInterface: %p", cmdCode, mEffectInterface);
6518
6519    if (mState == DESTROYED || mEffectInterface == NULL) {
6520        return NO_INIT;
6521    }
6522    status_t status = (*mEffectInterface)->command(mEffectInterface,
6523                                                   cmdCode,
6524                                                   cmdSize,
6525                                                   pCmdData,
6526                                                   replySize,
6527                                                   pReplyData);
6528    if (cmdCode != EFFECT_CMD_GET_PARAM && status == NO_ERROR) {
6529        uint32_t size = (replySize == NULL) ? 0 : *replySize;
6530        for (size_t i = 1; i < mHandles.size(); i++) {
6531            sp<EffectHandle> h = mHandles[i].promote();
6532            if (h != 0) {
6533                h->commandExecuted(cmdCode, cmdSize, pCmdData, size, pReplyData);
6534            }
6535        }
6536    }
6537    return status;
6538}
6539
6540status_t AudioFlinger::EffectModule::setEnabled(bool enabled)
6541{
6542
6543    Mutex::Autolock _l(mLock);
6544    LOGV("setEnabled %p enabled %d", this, enabled);
6545
6546    if (enabled != isEnabled()) {
6547        status_t status = AudioSystem::setEffectEnabled(mId, enabled);
6548        if (enabled && status != NO_ERROR) {
6549            return status;
6550        }
6551
6552        switch (mState) {
6553        // going from disabled to enabled
6554        case IDLE:
6555            mState = STARTING;
6556            break;
6557        case STOPPED:
6558            mState = RESTART;
6559            break;
6560        case STOPPING:
6561            mState = ACTIVE;
6562            break;
6563
6564        // going from enabled to disabled
6565        case RESTART:
6566            mState = STOPPED;
6567            break;
6568        case STARTING:
6569            mState = IDLE;
6570            break;
6571        case ACTIVE:
6572            mState = STOPPING;
6573            break;
6574        case DESTROYED:
6575            return NO_ERROR; // simply ignore as we are being destroyed
6576        }
6577        for (size_t i = 1; i < mHandles.size(); i++) {
6578            sp<EffectHandle> h = mHandles[i].promote();
6579            if (h != 0) {
6580                h->setEnabled(enabled);
6581            }
6582        }
6583    }
6584    return NO_ERROR;
6585}
6586
6587bool AudioFlinger::EffectModule::isEnabled()
6588{
6589    switch (mState) {
6590    case RESTART:
6591    case STARTING:
6592    case ACTIVE:
6593        return true;
6594    case IDLE:
6595    case STOPPING:
6596    case STOPPED:
6597    case DESTROYED:
6598    default:
6599        return false;
6600    }
6601}
6602
6603bool AudioFlinger::EffectModule::isProcessEnabled()
6604{
6605    switch (mState) {
6606    case RESTART:
6607    case ACTIVE:
6608    case STOPPING:
6609    case STOPPED:
6610        return true;
6611    case IDLE:
6612    case STARTING:
6613    case DESTROYED:
6614    default:
6615        return false;
6616    }
6617}
6618
6619status_t AudioFlinger::EffectModule::setVolume(uint32_t *left, uint32_t *right, bool controller)
6620{
6621    Mutex::Autolock _l(mLock);
6622    status_t status = NO_ERROR;
6623
6624    // Send volume indication if EFFECT_FLAG_VOLUME_IND is set and read back altered volume
6625    // if controller flag is set (Note that controller == TRUE => EFFECT_FLAG_VOLUME_CTRL set)
6626    if (isProcessEnabled() &&
6627            ((mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL ||
6628            (mDescriptor.flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_IND)) {
6629        status_t cmdStatus;
6630        uint32_t volume[2];
6631        uint32_t *pVolume = NULL;
6632        uint32_t size = sizeof(volume);
6633        volume[0] = *left;
6634        volume[1] = *right;
6635        if (controller) {
6636            pVolume = volume;
6637        }
6638        status = (*mEffectInterface)->command(mEffectInterface,
6639                                              EFFECT_CMD_SET_VOLUME,
6640                                              size,
6641                                              volume,
6642                                              &size,
6643                                              pVolume);
6644        if (controller && status == NO_ERROR && size == sizeof(volume)) {
6645            *left = volume[0];
6646            *right = volume[1];
6647        }
6648    }
6649    return status;
6650}
6651
6652status_t AudioFlinger::EffectModule::setDevice(uint32_t device)
6653{
6654    Mutex::Autolock _l(mLock);
6655    status_t status = NO_ERROR;
6656    if (device && (mDescriptor.flags & EFFECT_FLAG_DEVICE_MASK) == EFFECT_FLAG_DEVICE_IND) {
6657        // audio pre processing modules on RecordThread can receive both output and
6658        // input device indication in the same call
6659        uint32_t dev = device & AUDIO_DEVICE_OUT_ALL;
6660        if (dev) {
6661            status_t cmdStatus;
6662            uint32_t size = sizeof(status_t);
6663
6664            status = (*mEffectInterface)->command(mEffectInterface,
6665                                                  EFFECT_CMD_SET_DEVICE,
6666                                                  sizeof(uint32_t),
6667                                                  &dev,
6668                                                  &size,
6669                                                  &cmdStatus);
6670            if (status == NO_ERROR) {
6671                status = cmdStatus;
6672            }
6673        }
6674        dev = device & AUDIO_DEVICE_IN_ALL;
6675        if (dev) {
6676            status_t cmdStatus;
6677            uint32_t size = sizeof(status_t);
6678
6679            status_t status2 = (*mEffectInterface)->command(mEffectInterface,
6680                                                  EFFECT_CMD_SET_INPUT_DEVICE,
6681                                                  sizeof(uint32_t),
6682                                                  &dev,
6683                                                  &size,
6684                                                  &cmdStatus);
6685            if (status2 == NO_ERROR) {
6686                status2 = cmdStatus;
6687            }
6688            if (status == NO_ERROR) {
6689                status = status2;
6690            }
6691        }
6692    }
6693    return status;
6694}
6695
6696status_t AudioFlinger::EffectModule::setMode(uint32_t mode)
6697{
6698    Mutex::Autolock _l(mLock);
6699    status_t status = NO_ERROR;
6700    if ((mDescriptor.flags & EFFECT_FLAG_AUDIO_MODE_MASK) == EFFECT_FLAG_AUDIO_MODE_IND) {
6701        status_t cmdStatus;
6702        uint32_t size = sizeof(status_t);
6703        status = (*mEffectInterface)->command(mEffectInterface,
6704                                              EFFECT_CMD_SET_AUDIO_MODE,
6705                                              sizeof(int),
6706                                              &mode,
6707                                              &size,
6708                                              &cmdStatus);
6709        if (status == NO_ERROR) {
6710            status = cmdStatus;
6711        }
6712    }
6713    return status;
6714}
6715
6716void AudioFlinger::EffectModule::setSuspended(bool suspended)
6717{
6718    Mutex::Autolock _l(mLock);
6719    mSuspended = suspended;
6720}
6721bool AudioFlinger::EffectModule::suspended()
6722{
6723    Mutex::Autolock _l(mLock);
6724    return mSuspended;
6725}
6726
6727status_t AudioFlinger::EffectModule::dump(int fd, const Vector<String16>& args)
6728{
6729    const size_t SIZE = 256;
6730    char buffer[SIZE];
6731    String8 result;
6732
6733    snprintf(buffer, SIZE, "\tEffect ID %d:\n", mId);
6734    result.append(buffer);
6735
6736    bool locked = tryLock(mLock);
6737    // failed to lock - AudioFlinger is probably deadlocked
6738    if (!locked) {
6739        result.append("\t\tCould not lock Fx mutex:\n");
6740    }
6741
6742    result.append("\t\tSession Status State Engine:\n");
6743    snprintf(buffer, SIZE, "\t\t%05d   %03d    %03d   0x%08x\n",
6744            mSessionId, mStatus, mState, (uint32_t)mEffectInterface);
6745    result.append(buffer);
6746
6747    result.append("\t\tDescriptor:\n");
6748    snprintf(buffer, SIZE, "\t\t- UUID: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
6749            mDescriptor.uuid.timeLow, mDescriptor.uuid.timeMid, mDescriptor.uuid.timeHiAndVersion,
6750            mDescriptor.uuid.clockSeq, mDescriptor.uuid.node[0], mDescriptor.uuid.node[1],mDescriptor.uuid.node[2],
6751            mDescriptor.uuid.node[3],mDescriptor.uuid.node[4],mDescriptor.uuid.node[5]);
6752    result.append(buffer);
6753    snprintf(buffer, SIZE, "\t\t- TYPE: %08X-%04X-%04X-%04X-%02X%02X%02X%02X%02X%02X\n",
6754                mDescriptor.type.timeLow, mDescriptor.type.timeMid, mDescriptor.type.timeHiAndVersion,
6755                mDescriptor.type.clockSeq, mDescriptor.type.node[0], mDescriptor.type.node[1],mDescriptor.type.node[2],
6756                mDescriptor.type.node[3],mDescriptor.type.node[4],mDescriptor.type.node[5]);
6757    result.append(buffer);
6758    snprintf(buffer, SIZE, "\t\t- apiVersion: %08X\n\t\t- flags: %08X\n",
6759            mDescriptor.apiVersion,
6760            mDescriptor.flags);
6761    result.append(buffer);
6762    snprintf(buffer, SIZE, "\t\t- name: %s\n",
6763            mDescriptor.name);
6764    result.append(buffer);
6765    snprintf(buffer, SIZE, "\t\t- implementor: %s\n",
6766            mDescriptor.implementor);
6767    result.append(buffer);
6768
6769    result.append("\t\t- Input configuration:\n");
6770    result.append("\t\t\tBuffer     Frames  Smp rate Channels Format\n");
6771    snprintf(buffer, SIZE, "\t\t\t0x%08x %05d   %05d    %08x %d\n",
6772            (uint32_t)mConfig.inputCfg.buffer.raw,
6773            mConfig.inputCfg.buffer.frameCount,
6774            mConfig.inputCfg.samplingRate,
6775            mConfig.inputCfg.channels,
6776            mConfig.inputCfg.format);
6777    result.append(buffer);
6778
6779    result.append("\t\t- Output configuration:\n");
6780    result.append("\t\t\tBuffer     Frames  Smp rate Channels Format\n");
6781    snprintf(buffer, SIZE, "\t\t\t0x%08x %05d   %05d    %08x %d\n",
6782            (uint32_t)mConfig.outputCfg.buffer.raw,
6783            mConfig.outputCfg.buffer.frameCount,
6784            mConfig.outputCfg.samplingRate,
6785            mConfig.outputCfg.channels,
6786            mConfig.outputCfg.format);
6787    result.append(buffer);
6788
6789    snprintf(buffer, SIZE, "\t\t%d Clients:\n", mHandles.size());
6790    result.append(buffer);
6791    result.append("\t\t\tPid   Priority Ctrl Locked client server\n");
6792    for (size_t i = 0; i < mHandles.size(); ++i) {
6793        sp<EffectHandle> handle = mHandles[i].promote();
6794        if (handle != 0) {
6795            handle->dump(buffer, SIZE);
6796            result.append(buffer);
6797        }
6798    }
6799
6800    result.append("\n");
6801
6802    write(fd, result.string(), result.length());
6803
6804    if (locked) {
6805        mLock.unlock();
6806    }
6807
6808    return NO_ERROR;
6809}
6810
6811// ----------------------------------------------------------------------------
6812//  EffectHandle implementation
6813// ----------------------------------------------------------------------------
6814
6815#undef LOG_TAG
6816#define LOG_TAG "AudioFlinger::EffectHandle"
6817
6818AudioFlinger::EffectHandle::EffectHandle(const sp<EffectModule>& effect,
6819                                        const sp<AudioFlinger::Client>& client,
6820                                        const sp<IEffectClient>& effectClient,
6821                                        int32_t priority)
6822    : BnEffect(),
6823    mEffect(effect), mEffectClient(effectClient), mClient(client), mCblk(NULL),
6824    mPriority(priority), mHasControl(false), mEnabled(false)
6825{
6826    LOGV("constructor %p", this);
6827
6828    if (client == 0) {
6829        return;
6830    }
6831    int bufOffset = ((sizeof(effect_param_cblk_t) - 1) / sizeof(int) + 1) * sizeof(int);
6832    mCblkMemory = client->heap()->allocate(EFFECT_PARAM_BUFFER_SIZE + bufOffset);
6833    if (mCblkMemory != 0) {
6834        mCblk = static_cast<effect_param_cblk_t *>(mCblkMemory->pointer());
6835
6836        if (mCblk) {
6837            new(mCblk) effect_param_cblk_t();
6838            mBuffer = (uint8_t *)mCblk + bufOffset;
6839         }
6840    } else {
6841        LOGE("not enough memory for Effect size=%u", EFFECT_PARAM_BUFFER_SIZE + sizeof(effect_param_cblk_t));
6842        return;
6843    }
6844}
6845
6846AudioFlinger::EffectHandle::~EffectHandle()
6847{
6848    LOGV("Destructor %p", this);
6849    disconnect(false);
6850    LOGV("Destructor DONE %p", this);
6851}
6852
6853status_t AudioFlinger::EffectHandle::enable()
6854{
6855    LOGV("enable %p", this);
6856    if (!mHasControl) return INVALID_OPERATION;
6857    if (mEffect == 0) return DEAD_OBJECT;
6858
6859    if (mEnabled) {
6860        return NO_ERROR;
6861    }
6862
6863    mEnabled = true;
6864
6865    sp<ThreadBase> thread = mEffect->thread().promote();
6866    if (thread != 0) {
6867        thread->checkSuspendOnEffectEnabled(mEffect, true, mEffect->sessionId());
6868    }
6869
6870    // checkSuspendOnEffectEnabled() can suspend this same effect when enabled
6871    if (mEffect->suspended()) {
6872        return NO_ERROR;
6873    }
6874
6875    status_t status = mEffect->setEnabled(true);
6876    if (status != NO_ERROR) {
6877        if (thread != 0) {
6878            thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId());
6879        }
6880        mEnabled = false;
6881    }
6882    return status;
6883}
6884
6885status_t AudioFlinger::EffectHandle::disable()
6886{
6887    LOGV("disable %p", this);
6888    if (!mHasControl) return INVALID_OPERATION;
6889    if (mEffect == 0) return DEAD_OBJECT;
6890
6891    if (!mEnabled) {
6892        return NO_ERROR;
6893    }
6894    mEnabled = false;
6895
6896    if (mEffect->suspended()) {
6897        return NO_ERROR;
6898    }
6899
6900    status_t status = mEffect->setEnabled(false);
6901
6902    sp<ThreadBase> thread = mEffect->thread().promote();
6903    if (thread != 0) {
6904        thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId());
6905    }
6906
6907    return status;
6908}
6909
6910void AudioFlinger::EffectHandle::disconnect()
6911{
6912    disconnect(true);
6913}
6914
6915void AudioFlinger::EffectHandle::disconnect(bool unpiniflast)
6916{
6917    LOGV("disconnect(%s)", unpiniflast ? "true" : "false");
6918    if (mEffect == 0) {
6919        return;
6920    }
6921    mEffect->disconnect(this, unpiniflast);
6922
6923    if (mHasControl && mEnabled) {
6924        sp<ThreadBase> thread = mEffect->thread().promote();
6925        if (thread != 0) {
6926            thread->checkSuspendOnEffectEnabled(mEffect, false, mEffect->sessionId());
6927        }
6928    }
6929
6930    // release sp on module => module destructor can be called now
6931    mEffect.clear();
6932    if (mClient != 0) {
6933        if (mCblk) {
6934            mCblk->~effect_param_cblk_t();   // destroy our shared-structure.
6935        }
6936        mCblkMemory.clear();            // and free the shared memory
6937        Mutex::Autolock _l(mClient->audioFlinger()->mLock);
6938        mClient.clear();
6939    }
6940}
6941
6942status_t AudioFlinger::EffectHandle::command(uint32_t cmdCode,
6943                                             uint32_t cmdSize,
6944                                             void *pCmdData,
6945                                             uint32_t *replySize,
6946                                             void *pReplyData)
6947{
6948//    LOGV("command(), cmdCode: %d, mHasControl: %d, mEffect: %p",
6949//              cmdCode, mHasControl, (mEffect == 0) ? 0 : mEffect.get());
6950
6951    // only get parameter command is permitted for applications not controlling the effect
6952    if (!mHasControl && cmdCode != EFFECT_CMD_GET_PARAM) {
6953        return INVALID_OPERATION;
6954    }
6955    if (mEffect == 0) return DEAD_OBJECT;
6956    if (mClient == 0) return INVALID_OPERATION;
6957
6958    // handle commands that are not forwarded transparently to effect engine
6959    if (cmdCode == EFFECT_CMD_SET_PARAM_COMMIT) {
6960        // No need to trylock() here as this function is executed in the binder thread serving a particular client process:
6961        // no risk to block the whole media server process or mixer threads is we are stuck here
6962        Mutex::Autolock _l(mCblk->lock);
6963        if (mCblk->clientIndex > EFFECT_PARAM_BUFFER_SIZE ||
6964            mCblk->serverIndex > EFFECT_PARAM_BUFFER_SIZE) {
6965            mCblk->serverIndex = 0;
6966            mCblk->clientIndex = 0;
6967            return BAD_VALUE;
6968        }
6969        status_t status = NO_ERROR;
6970        while (mCblk->serverIndex < mCblk->clientIndex) {
6971            int reply;
6972            uint32_t rsize = sizeof(int);
6973            int *p = (int *)(mBuffer + mCblk->serverIndex);
6974            int size = *p++;
6975            if (((uint8_t *)p + size) > mBuffer + mCblk->clientIndex) {
6976                LOGW("command(): invalid parameter block size");
6977                break;
6978            }
6979            effect_param_t *param = (effect_param_t *)p;
6980            if (param->psize == 0 || param->vsize == 0) {
6981                LOGW("command(): null parameter or value size");
6982                mCblk->serverIndex += size;
6983                continue;
6984            }
6985            uint32_t psize = sizeof(effect_param_t) +
6986                             ((param->psize - 1) / sizeof(int) + 1) * sizeof(int) +
6987                             param->vsize;
6988            status_t ret = mEffect->command(EFFECT_CMD_SET_PARAM,
6989                                            psize,
6990                                            p,
6991                                            &rsize,
6992                                            &reply);
6993            // stop at first error encountered
6994            if (ret != NO_ERROR) {
6995                status = ret;
6996                *(int *)pReplyData = reply;
6997                break;
6998            } else if (reply != NO_ERROR) {
6999                *(int *)pReplyData = reply;
7000                break;
7001            }
7002            mCblk->serverIndex += size;
7003        }
7004        mCblk->serverIndex = 0;
7005        mCblk->clientIndex = 0;
7006        return status;
7007    } else if (cmdCode == EFFECT_CMD_ENABLE) {
7008        *(int *)pReplyData = NO_ERROR;
7009        return enable();
7010    } else if (cmdCode == EFFECT_CMD_DISABLE) {
7011        *(int *)pReplyData = NO_ERROR;
7012        return disable();
7013    }
7014
7015    return mEffect->command(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
7016}
7017
7018sp<IMemory> AudioFlinger::EffectHandle::getCblk() const {
7019    return mCblkMemory;
7020}
7021
7022void AudioFlinger::EffectHandle::setControl(bool hasControl, bool signal, bool enabled)
7023{
7024    LOGV("setControl %p control %d", this, hasControl);
7025
7026    mHasControl = hasControl;
7027    mEnabled = enabled;
7028
7029    if (signal && mEffectClient != 0) {
7030        mEffectClient->controlStatusChanged(hasControl);
7031    }
7032}
7033
7034void AudioFlinger::EffectHandle::commandExecuted(uint32_t cmdCode,
7035                                                 uint32_t cmdSize,
7036                                                 void *pCmdData,
7037                                                 uint32_t replySize,
7038                                                 void *pReplyData)
7039{
7040    if (mEffectClient != 0) {
7041        mEffectClient->commandExecuted(cmdCode, cmdSize, pCmdData, replySize, pReplyData);
7042    }
7043}
7044
7045
7046
7047void AudioFlinger::EffectHandle::setEnabled(bool enabled)
7048{
7049    if (mEffectClient != 0) {
7050        mEffectClient->enableStatusChanged(enabled);
7051    }
7052}
7053
7054status_t AudioFlinger::EffectHandle::onTransact(
7055    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
7056{
7057    return BnEffect::onTransact(code, data, reply, flags);
7058}
7059
7060
7061void AudioFlinger::EffectHandle::dump(char* buffer, size_t size)
7062{
7063    bool locked = mCblk ? tryLock(mCblk->lock) : false;
7064
7065    snprintf(buffer, size, "\t\t\t%05d %05d    %01u    %01u      %05u  %05u\n",
7066            (mClient == NULL) ? getpid() : mClient->pid(),
7067            mPriority,
7068            mHasControl,
7069            !locked,
7070            mCblk ? mCblk->clientIndex : 0,
7071            mCblk ? mCblk->serverIndex : 0
7072            );
7073
7074    if (locked) {
7075        mCblk->lock.unlock();
7076    }
7077}
7078
7079#undef LOG_TAG
7080#define LOG_TAG "AudioFlinger::EffectChain"
7081
7082AudioFlinger::EffectChain::EffectChain(const wp<ThreadBase>& wThread,
7083                                        int sessionId)
7084    : mThread(wThread), mSessionId(sessionId), mActiveTrackCnt(0), mTrackCnt(0), mTailBufferCount(0),
7085      mOwnInBuffer(false), mVolumeCtrlIdx(-1), mLeftVolume(UINT_MAX), mRightVolume(UINT_MAX),
7086      mNewLeftVolume(UINT_MAX), mNewRightVolume(UINT_MAX)
7087{
7088    mStrategy = AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
7089    sp<ThreadBase> thread = mThread.promote();
7090    if (thread == 0) {
7091        return;
7092    }
7093    mMaxTailBuffers = ((kProcessTailDurationMs * thread->sampleRate()) / 1000) /
7094                                    thread->frameCount();
7095}
7096
7097AudioFlinger::EffectChain::~EffectChain()
7098{
7099    if (mOwnInBuffer) {
7100        delete mInBuffer;
7101    }
7102
7103}
7104
7105// getEffectFromDesc_l() must be called with ThreadBase::mLock held
7106sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromDesc_l(effect_descriptor_t *descriptor)
7107{
7108    sp<EffectModule> effect;
7109    size_t size = mEffects.size();
7110
7111    for (size_t i = 0; i < size; i++) {
7112        if (memcmp(&mEffects[i]->desc().uuid, &descriptor->uuid, sizeof(effect_uuid_t)) == 0) {
7113            effect = mEffects[i];
7114            break;
7115        }
7116    }
7117    return effect;
7118}
7119
7120// getEffectFromId_l() must be called with ThreadBase::mLock held
7121sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromId_l(int id)
7122{
7123    sp<EffectModule> effect;
7124    size_t size = mEffects.size();
7125
7126    for (size_t i = 0; i < size; i++) {
7127        // by convention, return first effect if id provided is 0 (0 is never a valid id)
7128        if (id == 0 || mEffects[i]->id() == id) {
7129            effect = mEffects[i];
7130            break;
7131        }
7132    }
7133    return effect;
7134}
7135
7136// getEffectFromType_l() must be called with ThreadBase::mLock held
7137sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectFromType_l(
7138        const effect_uuid_t *type)
7139{
7140    sp<EffectModule> effect;
7141    size_t size = mEffects.size();
7142
7143    for (size_t i = 0; i < size; i++) {
7144        if (memcmp(&mEffects[i]->desc().type, type, sizeof(effect_uuid_t)) == 0) {
7145            effect = mEffects[i];
7146            break;
7147        }
7148    }
7149    return effect;
7150}
7151
7152// Must be called with EffectChain::mLock locked
7153void AudioFlinger::EffectChain::process_l()
7154{
7155    sp<ThreadBase> thread = mThread.promote();
7156    if (thread == 0) {
7157        LOGW("process_l(): cannot promote mixer thread");
7158        return;
7159    }
7160    bool isGlobalSession = (mSessionId == AUDIO_SESSION_OUTPUT_MIX) ||
7161            (mSessionId == AUDIO_SESSION_OUTPUT_STAGE);
7162    // always process effects unless no more tracks are on the session and the effect tail
7163    // has been rendered
7164    bool doProcess = true;
7165    if (!isGlobalSession) {
7166        bool tracksOnSession = (trackCnt() != 0);
7167
7168        if (!tracksOnSession && mTailBufferCount == 0) {
7169            doProcess = false;
7170        }
7171
7172        if (activeTrackCnt() == 0) {
7173            // if no track is active and the effect tail has not been rendered,
7174            // the input buffer must be cleared here as the mixer process will not do it
7175            if (tracksOnSession || mTailBufferCount > 0) {
7176                size_t numSamples = thread->frameCount() * thread->channelCount();
7177                memset(mInBuffer, 0, numSamples * sizeof(int16_t));
7178                if (mTailBufferCount > 0) {
7179                    mTailBufferCount--;
7180                }
7181            }
7182        }
7183    }
7184
7185    size_t size = mEffects.size();
7186    if (doProcess) {
7187        for (size_t i = 0; i < size; i++) {
7188            mEffects[i]->process();
7189        }
7190    }
7191    for (size_t i = 0; i < size; i++) {
7192        mEffects[i]->updateState();
7193    }
7194}
7195
7196// addEffect_l() must be called with PlaybackThread::mLock held
7197status_t AudioFlinger::EffectChain::addEffect_l(const sp<EffectModule>& effect)
7198{
7199    effect_descriptor_t desc = effect->desc();
7200    uint32_t insertPref = desc.flags & EFFECT_FLAG_INSERT_MASK;
7201
7202    Mutex::Autolock _l(mLock);
7203    effect->setChain(this);
7204    sp<ThreadBase> thread = mThread.promote();
7205    if (thread == 0) {
7206        return NO_INIT;
7207    }
7208    effect->setThread(thread);
7209
7210    if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
7211        // Auxiliary effects are inserted at the beginning of mEffects vector as
7212        // they are processed first and accumulated in chain input buffer
7213        mEffects.insertAt(effect, 0);
7214
7215        // the input buffer for auxiliary effect contains mono samples in
7216        // 32 bit format. This is to avoid saturation in AudoMixer
7217        // accumulation stage. Saturation is done in EffectModule::process() before
7218        // calling the process in effect engine
7219        size_t numSamples = thread->frameCount();
7220        int32_t *buffer = new int32_t[numSamples];
7221        memset(buffer, 0, numSamples * sizeof(int32_t));
7222        effect->setInBuffer((int16_t *)buffer);
7223        // auxiliary effects output samples to chain input buffer for further processing
7224        // by insert effects
7225        effect->setOutBuffer(mInBuffer);
7226    } else {
7227        // Insert effects are inserted at the end of mEffects vector as they are processed
7228        //  after track and auxiliary effects.
7229        // Insert effect order as a function of indicated preference:
7230        //  if EFFECT_FLAG_INSERT_EXCLUSIVE, insert in first position or reject if
7231        //  another effect is present
7232        //  else if EFFECT_FLAG_INSERT_FIRST, insert in first position or after the
7233        //  last effect claiming first position
7234        //  else if EFFECT_FLAG_INSERT_LAST, insert in last position or before the
7235        //  first effect claiming last position
7236        //  else if EFFECT_FLAG_INSERT_ANY insert after first or before last
7237        // Reject insertion if an effect with EFFECT_FLAG_INSERT_EXCLUSIVE is
7238        // already present
7239
7240        int size = (int)mEffects.size();
7241        int idx_insert = size;
7242        int idx_insert_first = -1;
7243        int idx_insert_last = -1;
7244
7245        for (int i = 0; i < size; i++) {
7246            effect_descriptor_t d = mEffects[i]->desc();
7247            uint32_t iMode = d.flags & EFFECT_FLAG_TYPE_MASK;
7248            uint32_t iPref = d.flags & EFFECT_FLAG_INSERT_MASK;
7249            if (iMode == EFFECT_FLAG_TYPE_INSERT) {
7250                // check invalid effect chaining combinations
7251                if (insertPref == EFFECT_FLAG_INSERT_EXCLUSIVE ||
7252                    iPref == EFFECT_FLAG_INSERT_EXCLUSIVE) {
7253                    LOGW("addEffect_l() could not insert effect %s: exclusive conflict with %s", desc.name, d.name);
7254                    return INVALID_OPERATION;
7255                }
7256                // remember position of first insert effect and by default
7257                // select this as insert position for new effect
7258                if (idx_insert == size) {
7259                    idx_insert = i;
7260                }
7261                // remember position of last insert effect claiming
7262                // first position
7263                if (iPref == EFFECT_FLAG_INSERT_FIRST) {
7264                    idx_insert_first = i;
7265                }
7266                // remember position of first insert effect claiming
7267                // last position
7268                if (iPref == EFFECT_FLAG_INSERT_LAST &&
7269                    idx_insert_last == -1) {
7270                    idx_insert_last = i;
7271                }
7272            }
7273        }
7274
7275        // modify idx_insert from first position if needed
7276        if (insertPref == EFFECT_FLAG_INSERT_LAST) {
7277            if (idx_insert_last != -1) {
7278                idx_insert = idx_insert_last;
7279            } else {
7280                idx_insert = size;
7281            }
7282        } else {
7283            if (idx_insert_first != -1) {
7284                idx_insert = idx_insert_first + 1;
7285            }
7286        }
7287
7288        // always read samples from chain input buffer
7289        effect->setInBuffer(mInBuffer);
7290
7291        // if last effect in the chain, output samples to chain
7292        // output buffer, otherwise to chain input buffer
7293        if (idx_insert == size) {
7294            if (idx_insert != 0) {
7295                mEffects[idx_insert-1]->setOutBuffer(mInBuffer);
7296                mEffects[idx_insert-1]->configure();
7297            }
7298            effect->setOutBuffer(mOutBuffer);
7299        } else {
7300            effect->setOutBuffer(mInBuffer);
7301        }
7302        mEffects.insertAt(effect, idx_insert);
7303
7304        LOGV("addEffect_l() effect %p, added in chain %p at rank %d", effect.get(), this, idx_insert);
7305    }
7306    effect->configure();
7307    return NO_ERROR;
7308}
7309
7310// removeEffect_l() must be called with PlaybackThread::mLock held
7311size_t AudioFlinger::EffectChain::removeEffect_l(const sp<EffectModule>& effect)
7312{
7313    Mutex::Autolock _l(mLock);
7314    int size = (int)mEffects.size();
7315    int i;
7316    uint32_t type = effect->desc().flags & EFFECT_FLAG_TYPE_MASK;
7317
7318    for (i = 0; i < size; i++) {
7319        if (effect == mEffects[i]) {
7320            // calling stop here will remove pre-processing effect from the audio HAL.
7321            // This is safe as we hold the EffectChain mutex which guarantees that we are not in
7322            // the middle of a read from audio HAL
7323            if (mEffects[i]->state() == EffectModule::ACTIVE ||
7324                    mEffects[i]->state() == EffectModule::STOPPING) {
7325                mEffects[i]->stop();
7326            }
7327            if (type == EFFECT_FLAG_TYPE_AUXILIARY) {
7328                delete[] effect->inBuffer();
7329            } else {
7330                if (i == size - 1 && i != 0) {
7331                    mEffects[i - 1]->setOutBuffer(mOutBuffer);
7332                    mEffects[i - 1]->configure();
7333                }
7334            }
7335            mEffects.removeAt(i);
7336            LOGV("removeEffect_l() effect %p, removed from chain %p at rank %d", effect.get(), this, i);
7337            break;
7338        }
7339    }
7340
7341    return mEffects.size();
7342}
7343
7344// setDevice_l() must be called with PlaybackThread::mLock held
7345void AudioFlinger::EffectChain::setDevice_l(uint32_t device)
7346{
7347    size_t size = mEffects.size();
7348    for (size_t i = 0; i < size; i++) {
7349        mEffects[i]->setDevice(device);
7350    }
7351}
7352
7353// setMode_l() must be called with PlaybackThread::mLock held
7354void AudioFlinger::EffectChain::setMode_l(uint32_t mode)
7355{
7356    size_t size = mEffects.size();
7357    for (size_t i = 0; i < size; i++) {
7358        mEffects[i]->setMode(mode);
7359    }
7360}
7361
7362// setVolume_l() must be called with PlaybackThread::mLock held
7363bool AudioFlinger::EffectChain::setVolume_l(uint32_t *left, uint32_t *right)
7364{
7365    uint32_t newLeft = *left;
7366    uint32_t newRight = *right;
7367    bool hasControl = false;
7368    int ctrlIdx = -1;
7369    size_t size = mEffects.size();
7370
7371    // first update volume controller
7372    for (size_t i = size; i > 0; i--) {
7373        if (mEffects[i - 1]->isProcessEnabled() &&
7374            (mEffects[i - 1]->desc().flags & EFFECT_FLAG_VOLUME_MASK) == EFFECT_FLAG_VOLUME_CTRL) {
7375            ctrlIdx = i - 1;
7376            hasControl = true;
7377            break;
7378        }
7379    }
7380
7381    if (ctrlIdx == mVolumeCtrlIdx && *left == mLeftVolume && *right == mRightVolume) {
7382        if (hasControl) {
7383            *left = mNewLeftVolume;
7384            *right = mNewRightVolume;
7385        }
7386        return hasControl;
7387    }
7388
7389    mVolumeCtrlIdx = ctrlIdx;
7390    mLeftVolume = newLeft;
7391    mRightVolume = newRight;
7392
7393    // second get volume update from volume controller
7394    if (ctrlIdx >= 0) {
7395        mEffects[ctrlIdx]->setVolume(&newLeft, &newRight, true);
7396        mNewLeftVolume = newLeft;
7397        mNewRightVolume = newRight;
7398    }
7399    // then indicate volume to all other effects in chain.
7400    // Pass altered volume to effects before volume controller
7401    // and requested volume to effects after controller
7402    uint32_t lVol = newLeft;
7403    uint32_t rVol = newRight;
7404
7405    for (size_t i = 0; i < size; i++) {
7406        if ((int)i == ctrlIdx) continue;
7407        // this also works for ctrlIdx == -1 when there is no volume controller
7408        if ((int)i > ctrlIdx) {
7409            lVol = *left;
7410            rVol = *right;
7411        }
7412        mEffects[i]->setVolume(&lVol, &rVol, false);
7413    }
7414    *left = newLeft;
7415    *right = newRight;
7416
7417    return hasControl;
7418}
7419
7420status_t AudioFlinger::EffectChain::dump(int fd, const Vector<String16>& args)
7421{
7422    const size_t SIZE = 256;
7423    char buffer[SIZE];
7424    String8 result;
7425
7426    snprintf(buffer, SIZE, "Effects for session %d:\n", mSessionId);
7427    result.append(buffer);
7428
7429    bool locked = tryLock(mLock);
7430    // failed to lock - AudioFlinger is probably deadlocked
7431    if (!locked) {
7432        result.append("\tCould not lock mutex:\n");
7433    }
7434
7435    result.append("\tNum fx In buffer   Out buffer   Active tracks:\n");
7436    snprintf(buffer, SIZE, "\t%02d     0x%08x  0x%08x   %d\n",
7437            mEffects.size(),
7438            (uint32_t)mInBuffer,
7439            (uint32_t)mOutBuffer,
7440            mActiveTrackCnt);
7441    result.append(buffer);
7442    write(fd, result.string(), result.size());
7443
7444    for (size_t i = 0; i < mEffects.size(); ++i) {
7445        sp<EffectModule> effect = mEffects[i];
7446        if (effect != 0) {
7447            effect->dump(fd, args);
7448        }
7449    }
7450
7451    if (locked) {
7452        mLock.unlock();
7453    }
7454
7455    return NO_ERROR;
7456}
7457
7458// must be called with ThreadBase::mLock held
7459void AudioFlinger::EffectChain::setEffectSuspended_l(
7460        const effect_uuid_t *type, bool suspend)
7461{
7462    sp<SuspendedEffectDesc> desc;
7463    // use effect type UUID timelow as key as there is no real risk of identical
7464    // timeLow fields among effect type UUIDs.
7465    int index = mSuspendedEffects.indexOfKey(type->timeLow);
7466    if (suspend) {
7467        if (index >= 0) {
7468            desc = mSuspendedEffects.valueAt(index);
7469        } else {
7470            desc = new SuspendedEffectDesc();
7471            memcpy(&desc->mType, type, sizeof(effect_uuid_t));
7472            mSuspendedEffects.add(type->timeLow, desc);
7473            LOGV("setEffectSuspended_l() add entry for %08x", type->timeLow);
7474        }
7475        if (desc->mRefCount++ == 0) {
7476            sp<EffectModule> effect = getEffectIfEnabled(type);
7477            if (effect != 0) {
7478                desc->mEffect = effect;
7479                effect->setSuspended(true);
7480                effect->setEnabled(false);
7481            }
7482        }
7483    } else {
7484        if (index < 0) {
7485            return;
7486        }
7487        desc = mSuspendedEffects.valueAt(index);
7488        if (desc->mRefCount <= 0) {
7489            LOGW("setEffectSuspended_l() restore refcount should not be 0 %d", desc->mRefCount);
7490            desc->mRefCount = 1;
7491        }
7492        if (--desc->mRefCount == 0) {
7493            LOGV("setEffectSuspended_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
7494            if (desc->mEffect != 0) {
7495                sp<EffectModule> effect = desc->mEffect.promote();
7496                if (effect != 0) {
7497                    effect->setSuspended(false);
7498                    sp<EffectHandle> handle = effect->controlHandle();
7499                    if (handle != 0) {
7500                        effect->setEnabled(handle->enabled());
7501                    }
7502                }
7503                desc->mEffect.clear();
7504            }
7505            mSuspendedEffects.removeItemsAt(index);
7506        }
7507    }
7508}
7509
7510// must be called with ThreadBase::mLock held
7511void AudioFlinger::EffectChain::setEffectSuspendedAll_l(bool suspend)
7512{
7513    sp<SuspendedEffectDesc> desc;
7514
7515    int index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
7516    if (suspend) {
7517        if (index >= 0) {
7518            desc = mSuspendedEffects.valueAt(index);
7519        } else {
7520            desc = new SuspendedEffectDesc();
7521            mSuspendedEffects.add((int)kKeyForSuspendAll, desc);
7522            LOGV("setEffectSuspendedAll_l() add entry for 0");
7523        }
7524        if (desc->mRefCount++ == 0) {
7525            Vector< sp<EffectModule> > effects = getSuspendEligibleEffects();
7526            for (size_t i = 0; i < effects.size(); i++) {
7527                setEffectSuspended_l(&effects[i]->desc().type, true);
7528            }
7529        }
7530    } else {
7531        if (index < 0) {
7532            return;
7533        }
7534        desc = mSuspendedEffects.valueAt(index);
7535        if (desc->mRefCount <= 0) {
7536            LOGW("setEffectSuspendedAll_l() restore refcount should not be 0 %d", desc->mRefCount);
7537            desc->mRefCount = 1;
7538        }
7539        if (--desc->mRefCount == 0) {
7540            Vector<const effect_uuid_t *> types;
7541            for (size_t i = 0; i < mSuspendedEffects.size(); i++) {
7542                if (mSuspendedEffects.keyAt(i) == (int)kKeyForSuspendAll) {
7543                    continue;
7544                }
7545                types.add(&mSuspendedEffects.valueAt(i)->mType);
7546            }
7547            for (size_t i = 0; i < types.size(); i++) {
7548                setEffectSuspended_l(types[i], false);
7549            }
7550            LOGV("setEffectSuspendedAll_l() remove entry for %08x", mSuspendedEffects.keyAt(index));
7551            mSuspendedEffects.removeItem((int)kKeyForSuspendAll);
7552        }
7553    }
7554}
7555
7556
7557// The volume effect is used for automated tests only
7558#ifndef OPENSL_ES_H_
7559static const effect_uuid_t SL_IID_VOLUME_ = { 0x09e8ede0, 0xddde, 0x11db, 0xb4f6,
7560                                            { 0x00, 0x02, 0xa5, 0xd5, 0xc5, 0x1b } };
7561const effect_uuid_t * const SL_IID_VOLUME = &SL_IID_VOLUME_;
7562#endif //OPENSL_ES_H_
7563
7564bool AudioFlinger::EffectChain::isEffectEligibleForSuspend(const effect_descriptor_t& desc)
7565{
7566    // auxiliary effects and visualizer are never suspended on output mix
7567    if ((mSessionId == AUDIO_SESSION_OUTPUT_MIX) &&
7568        (((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) ||
7569         (memcmp(&desc.type, SL_IID_VISUALIZATION, sizeof(effect_uuid_t)) == 0) ||
7570         (memcmp(&desc.type, SL_IID_VOLUME, sizeof(effect_uuid_t)) == 0))) {
7571        return false;
7572    }
7573    return true;
7574}
7575
7576Vector< sp<AudioFlinger::EffectModule> > AudioFlinger::EffectChain::getSuspendEligibleEffects()
7577{
7578    Vector< sp<EffectModule> > effects;
7579    for (size_t i = 0; i < mEffects.size(); i++) {
7580        if (!isEffectEligibleForSuspend(mEffects[i]->desc())) {
7581            continue;
7582        }
7583        effects.add(mEffects[i]);
7584    }
7585    return effects;
7586}
7587
7588sp<AudioFlinger::EffectModule> AudioFlinger::EffectChain::getEffectIfEnabled(
7589                                                            const effect_uuid_t *type)
7590{
7591    sp<EffectModule> effect;
7592    effect = getEffectFromType_l(type);
7593    if (effect != 0 && !effect->isEnabled()) {
7594        effect.clear();
7595    }
7596    return effect;
7597}
7598
7599void AudioFlinger::EffectChain::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
7600                                                            bool enabled)
7601{
7602    int index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
7603    if (enabled) {
7604        if (index < 0) {
7605            // if the effect is not suspend check if all effects are suspended
7606            index = mSuspendedEffects.indexOfKey((int)kKeyForSuspendAll);
7607            if (index < 0) {
7608                return;
7609            }
7610            if (!isEffectEligibleForSuspend(effect->desc())) {
7611                return;
7612            }
7613            setEffectSuspended_l(&effect->desc().type, enabled);
7614            index = mSuspendedEffects.indexOfKey(effect->desc().type.timeLow);
7615            if (index < 0) {
7616                LOGW("checkSuspendOnEffectEnabled() Fx should be suspended here!");
7617                return;
7618            }
7619        }
7620        LOGV("checkSuspendOnEffectEnabled() enable suspending fx %08x",
7621             effect->desc().type.timeLow);
7622        sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
7623        // if effect is requested to suspended but was not yet enabled, supend it now.
7624        if (desc->mEffect == 0) {
7625            desc->mEffect = effect;
7626            effect->setEnabled(false);
7627            effect->setSuspended(true);
7628        }
7629    } else {
7630        if (index < 0) {
7631            return;
7632        }
7633        LOGV("checkSuspendOnEffectEnabled() disable restoring fx %08x",
7634             effect->desc().type.timeLow);
7635        sp<SuspendedEffectDesc> desc = mSuspendedEffects.valueAt(index);
7636        desc->mEffect.clear();
7637        effect->setSuspended(false);
7638    }
7639}
7640
7641#undef LOG_TAG
7642#define LOG_TAG "AudioFlinger"
7643
7644// ----------------------------------------------------------------------------
7645
7646status_t AudioFlinger::onTransact(
7647        uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
7648{
7649    return BnAudioFlinger::onTransact(code, data, reply, flags);
7650}
7651
7652}; // namespace android
7653