1/*
2**
3** Copyright 2012, 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#define ATRACE_TAG ATRACE_TAG_AUDIO
22
23#include "Configuration.h"
24#include <math.h>
25#include <fcntl.h>
26#include <linux/futex.h>
27#include <sys/stat.h>
28#include <sys/syscall.h>
29#include <cutils/properties.h>
30#include <media/AudioParameter.h>
31#include <media/AudioResamplerPublic.h>
32#include <utils/Log.h>
33#include <utils/Trace.h>
34
35#include <private/media/AudioTrackShared.h>
36#include <hardware/audio.h>
37#include <audio_effects/effect_ns.h>
38#include <audio_effects/effect_aec.h>
39#include <audio_utils/conversion.h>
40#include <audio_utils/primitives.h>
41#include <audio_utils/format.h>
42#include <audio_utils/minifloat.h>
43
44// NBAIO implementations
45#include <media/nbaio/AudioStreamInSource.h>
46#include <media/nbaio/AudioStreamOutSink.h>
47#include <media/nbaio/MonoPipe.h>
48#include <media/nbaio/MonoPipeReader.h>
49#include <media/nbaio/Pipe.h>
50#include <media/nbaio/PipeReader.h>
51#include <media/nbaio/SourceAudioBufferProvider.h>
52#include <mediautils/BatteryNotifier.h>
53
54#include <powermanager/PowerManager.h>
55
56#include "AudioFlinger.h"
57#include "AudioMixer.h"
58#include "BufferProviders.h"
59#include "FastMixer.h"
60#include "FastCapture.h"
61#include "ServiceUtilities.h"
62#include "mediautils/SchedulingPolicyService.h"
63
64#ifdef ADD_BATTERY_DATA
65#include <media/IMediaPlayerService.h>
66#include <media/IMediaDeathNotifier.h>
67#endif
68
69#ifdef DEBUG_CPU_USAGE
70#include <cpustats/CentralTendencyStatistics.h>
71#include <cpustats/ThreadCpuUsage.h>
72#endif
73
74#include "AutoPark.h"
75
76// ----------------------------------------------------------------------------
77
78// Note: the following macro is used for extremely verbose logging message.  In
79// order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
80// 0; but one side effect of this is to turn all LOGV's as well.  Some messages
81// are so verbose that we want to suppress them even when we have ALOG_ASSERT
82// turned on.  Do not uncomment the #def below unless you really know what you
83// are doing and want to see all of the extremely verbose messages.
84//#define VERY_VERY_VERBOSE_LOGGING
85#ifdef VERY_VERY_VERBOSE_LOGGING
86#define ALOGVV ALOGV
87#else
88#define ALOGVV(a...) do { } while(0)
89#endif
90
91// TODO: Move these macro/inlines to a header file.
92#define max(a, b) ((a) > (b) ? (a) : (b))
93template <typename T>
94static inline T min(const T& a, const T& b)
95{
96    return a < b ? a : b;
97}
98
99#ifndef ARRAY_SIZE
100#define ARRAY_SIZE(a) (sizeof(a) / sizeof(a[0]))
101#endif
102
103namespace android {
104
105// retry counts for buffer fill timeout
106// 50 * ~20msecs = 1 second
107static const int8_t kMaxTrackRetries = 50;
108static const int8_t kMaxTrackStartupRetries = 50;
109// allow less retry attempts on direct output thread.
110// direct outputs can be a scarce resource in audio hardware and should
111// be released as quickly as possible.
112static const int8_t kMaxTrackRetriesDirect = 2;
113
114
115
116// don't warn about blocked writes or record buffer overflows more often than this
117static const nsecs_t kWarningThrottleNs = seconds(5);
118
119// RecordThread loop sleep time upon application overrun or audio HAL read error
120static const int kRecordThreadSleepUs = 5000;
121
122// maximum time to wait in sendConfigEvent_l() for a status to be received
123static const nsecs_t kConfigEventTimeoutNs = seconds(2);
124
125// minimum sleep time for the mixer thread loop when tracks are active but in underrun
126static const uint32_t kMinThreadSleepTimeUs = 5000;
127// maximum divider applied to the active sleep time in the mixer thread loop
128static const uint32_t kMaxThreadSleepTimeShift = 2;
129
130// minimum normal sink buffer size, expressed in milliseconds rather than frames
131// FIXME This should be based on experimentally observed scheduling jitter
132static const uint32_t kMinNormalSinkBufferSizeMs = 20;
133// maximum normal sink buffer size
134static const uint32_t kMaxNormalSinkBufferSizeMs = 24;
135
136// minimum capture buffer size in milliseconds to _not_ need a fast capture thread
137// FIXME This should be based on experimentally observed scheduling jitter
138static const uint32_t kMinNormalCaptureBufferSizeMs = 12;
139
140// Offloaded output thread standby delay: allows track transition without going to standby
141static const nsecs_t kOffloadStandbyDelayNs = seconds(1);
142
143// Direct output thread minimum sleep time in idle or active(underrun) state
144static const nsecs_t kDirectMinSleepTimeUs = 10000;
145
146
147// Whether to use fast mixer
148static const enum {
149    FastMixer_Never,    // never initialize or use: for debugging only
150    FastMixer_Always,   // always initialize and use, even if not needed: for debugging only
151                        // normal mixer multiplier is 1
152    FastMixer_Static,   // initialize if needed, then use all the time if initialized,
153                        // multiplier is calculated based on min & max normal mixer buffer size
154    FastMixer_Dynamic,  // initialize if needed, then use dynamically depending on track load,
155                        // multiplier is calculated based on min & max normal mixer buffer size
156    // FIXME for FastMixer_Dynamic:
157    //  Supporting this option will require fixing HALs that can't handle large writes.
158    //  For example, one HAL implementation returns an error from a large write,
159    //  and another HAL implementation corrupts memory, possibly in the sample rate converter.
160    //  We could either fix the HAL implementations, or provide a wrapper that breaks
161    //  up large writes into smaller ones, and the wrapper would need to deal with scheduler.
162} kUseFastMixer = FastMixer_Static;
163
164// Whether to use fast capture
165static const enum {
166    FastCapture_Never,  // never initialize or use: for debugging only
167    FastCapture_Always, // always initialize and use, even if not needed: for debugging only
168    FastCapture_Static, // initialize if needed, then use all the time if initialized
169} kUseFastCapture = FastCapture_Static;
170
171// Priorities for requestPriority
172static const int kPriorityAudioApp = 2;
173static const int kPriorityFastMixer = 3;
174static const int kPriorityFastCapture = 3;
175
176// IAudioFlinger::createTrack() has an in/out parameter 'pFrameCount' for the total size of the
177// track buffer in shared memory.  Zero on input means to use a default value.  For fast tracks,
178// AudioFlinger derives the default from HAL buffer size and 'fast track multiplier'.
179
180// This is the default value, if not specified by property.
181static const int kFastTrackMultiplier = 2;
182
183// The minimum and maximum allowed values
184static const int kFastTrackMultiplierMin = 1;
185static const int kFastTrackMultiplierMax = 2;
186
187// The actual value to use, which can be specified per-device via property af.fast_track_multiplier.
188static int sFastTrackMultiplier = kFastTrackMultiplier;
189
190// See Thread::readOnlyHeap().
191// Initially this heap is used to allocate client buffers for "fast" AudioRecord.
192// Eventually it will be the single buffer that FastCapture writes into via HAL read(),
193// and that all "fast" AudioRecord clients read from.  In either case, the size can be small.
194static const size_t kRecordThreadReadOnlyHeapSize = 0x2000;
195
196// ----------------------------------------------------------------------------
197
198static pthread_once_t sFastTrackMultiplierOnce = PTHREAD_ONCE_INIT;
199
200static void sFastTrackMultiplierInit()
201{
202    char value[PROPERTY_VALUE_MAX];
203    if (property_get("af.fast_track_multiplier", value, NULL) > 0) {
204        char *endptr;
205        unsigned long ul = strtoul(value, &endptr, 0);
206        if (*endptr == '\0' && kFastTrackMultiplierMin <= ul && ul <= kFastTrackMultiplierMax) {
207            sFastTrackMultiplier = (int) ul;
208        }
209    }
210}
211
212// ----------------------------------------------------------------------------
213
214#ifdef ADD_BATTERY_DATA
215// To collect the amplifier usage
216static void addBatteryData(uint32_t params) {
217    sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
218    if (service == NULL) {
219        // it already logged
220        return;
221    }
222
223    service->addBatteryData(params);
224}
225#endif
226
227// Track the CLOCK_BOOTTIME versus CLOCK_MONOTONIC timebase offset
228struct {
229    // call when you acquire a partial wakelock
230    void acquire(const sp<IBinder> &wakeLockToken) {
231        pthread_mutex_lock(&mLock);
232        if (wakeLockToken.get() == nullptr) {
233            adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
234        } else {
235            if (mCount == 0) {
236                adjustTimebaseOffset(&mBoottimeOffset, ExtendedTimestamp::TIMEBASE_BOOTTIME);
237            }
238            ++mCount;
239        }
240        pthread_mutex_unlock(&mLock);
241    }
242
243    // call when you release a partial wakelock.
244    void release(const sp<IBinder> &wakeLockToken) {
245        if (wakeLockToken.get() == nullptr) {
246            return;
247        }
248        pthread_mutex_lock(&mLock);
249        if (--mCount < 0) {
250            ALOGE("negative wakelock count");
251            mCount = 0;
252        }
253        pthread_mutex_unlock(&mLock);
254    }
255
256    // retrieves the boottime timebase offset from monotonic.
257    int64_t getBoottimeOffset() {
258        pthread_mutex_lock(&mLock);
259        int64_t boottimeOffset = mBoottimeOffset;
260        pthread_mutex_unlock(&mLock);
261        return boottimeOffset;
262    }
263
264    // Adjusts the timebase offset between TIMEBASE_MONOTONIC
265    // and the selected timebase.
266    // Currently only TIMEBASE_BOOTTIME is allowed.
267    //
268    // This only needs to be called upon acquiring the first partial wakelock
269    // after all other partial wakelocks are released.
270    //
271    // We do an empirical measurement of the offset rather than parsing
272    // /proc/timer_list since the latter is not a formal kernel ABI.
273    static void adjustTimebaseOffset(int64_t *offset, ExtendedTimestamp::Timebase timebase) {
274        int clockbase;
275        switch (timebase) {
276        case ExtendedTimestamp::TIMEBASE_BOOTTIME:
277            clockbase = SYSTEM_TIME_BOOTTIME;
278            break;
279        default:
280            LOG_ALWAYS_FATAL("invalid timebase %d", timebase);
281            break;
282        }
283        // try three times to get the clock offset, choose the one
284        // with the minimum gap in measurements.
285        const int tries = 3;
286        nsecs_t bestGap, measured;
287        for (int i = 0; i < tries; ++i) {
288            const nsecs_t tmono = systemTime(SYSTEM_TIME_MONOTONIC);
289            const nsecs_t tbase = systemTime(clockbase);
290            const nsecs_t tmono2 = systemTime(SYSTEM_TIME_MONOTONIC);
291            const nsecs_t gap = tmono2 - tmono;
292            if (i == 0 || gap < bestGap) {
293                bestGap = gap;
294                measured = tbase - ((tmono + tmono2) >> 1);
295            }
296        }
297
298        // to avoid micro-adjusting, we don't change the timebase
299        // unless it is significantly different.
300        //
301        // Assumption: It probably takes more than toleranceNs to
302        // suspend and resume the device.
303        static int64_t toleranceNs = 10000; // 10 us
304        if (llabs(*offset - measured) > toleranceNs) {
305            ALOGV("Adjusting timebase offset old: %lld  new: %lld",
306                    (long long)*offset, (long long)measured);
307            *offset = measured;
308        }
309    }
310
311    pthread_mutex_t mLock;
312    int32_t mCount;
313    int64_t mBoottimeOffset;
314} gBoottime = { PTHREAD_MUTEX_INITIALIZER, 0, 0 }; // static, so use POD initialization
315
316// ----------------------------------------------------------------------------
317//      CPU Stats
318// ----------------------------------------------------------------------------
319
320class CpuStats {
321public:
322    CpuStats();
323    void sample(const String8 &title);
324#ifdef DEBUG_CPU_USAGE
325private:
326    ThreadCpuUsage mCpuUsage;           // instantaneous thread CPU usage in wall clock ns
327    CentralTendencyStatistics mWcStats; // statistics on thread CPU usage in wall clock ns
328
329    CentralTendencyStatistics mHzStats; // statistics on thread CPU usage in cycles
330
331    int mCpuNum;                        // thread's current CPU number
332    int mCpukHz;                        // frequency of thread's current CPU in kHz
333#endif
334};
335
336CpuStats::CpuStats()
337#ifdef DEBUG_CPU_USAGE
338    : mCpuNum(-1), mCpukHz(-1)
339#endif
340{
341}
342
343void CpuStats::sample(const String8 &title
344#ifndef DEBUG_CPU_USAGE
345                __unused
346#endif
347        ) {
348#ifdef DEBUG_CPU_USAGE
349    // get current thread's delta CPU time in wall clock ns
350    double wcNs;
351    bool valid = mCpuUsage.sampleAndEnable(wcNs);
352
353    // record sample for wall clock statistics
354    if (valid) {
355        mWcStats.sample(wcNs);
356    }
357
358    // get the current CPU number
359    int cpuNum = sched_getcpu();
360
361    // get the current CPU frequency in kHz
362    int cpukHz = mCpuUsage.getCpukHz(cpuNum);
363
364    // check if either CPU number or frequency changed
365    if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
366        mCpuNum = cpuNum;
367        mCpukHz = cpukHz;
368        // ignore sample for purposes of cycles
369        valid = false;
370    }
371
372    // if no change in CPU number or frequency, then record sample for cycle statistics
373    if (valid && mCpukHz > 0) {
374        double cycles = wcNs * cpukHz * 0.000001;
375        mHzStats.sample(cycles);
376    }
377
378    unsigned n = mWcStats.n();
379    // mCpuUsage.elapsed() is expensive, so don't call it every loop
380    if ((n & 127) == 1) {
381        long long elapsed = mCpuUsage.elapsed();
382        if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
383            double perLoop = elapsed / (double) n;
384            double perLoop100 = perLoop * 0.01;
385            double perLoop1k = perLoop * 0.001;
386            double mean = mWcStats.mean();
387            double stddev = mWcStats.stddev();
388            double minimum = mWcStats.minimum();
389            double maximum = mWcStats.maximum();
390            double meanCycles = mHzStats.mean();
391            double stddevCycles = mHzStats.stddev();
392            double minCycles = mHzStats.minimum();
393            double maxCycles = mHzStats.maximum();
394            mCpuUsage.resetElapsed();
395            mWcStats.reset();
396            mHzStats.reset();
397            ALOGD("CPU usage for %s over past %.1f secs\n"
398                "  (%u mixer loops at %.1f mean ms per loop):\n"
399                "  us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
400                "  %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
401                "  MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
402                    title.string(),
403                    elapsed * .000000001, n, perLoop * .000001,
404                    mean * .001,
405                    stddev * .001,
406                    minimum * .001,
407                    maximum * .001,
408                    mean / perLoop100,
409                    stddev / perLoop100,
410                    minimum / perLoop100,
411                    maximum / perLoop100,
412                    meanCycles / perLoop1k,
413                    stddevCycles / perLoop1k,
414                    minCycles / perLoop1k,
415                    maxCycles / perLoop1k);
416
417        }
418    }
419#endif
420};
421
422// ----------------------------------------------------------------------------
423//      ThreadBase
424// ----------------------------------------------------------------------------
425
426// static
427const char *AudioFlinger::ThreadBase::threadTypeToString(AudioFlinger::ThreadBase::type_t type)
428{
429    switch (type) {
430    case MIXER:
431        return "MIXER";
432    case DIRECT:
433        return "DIRECT";
434    case DUPLICATING:
435        return "DUPLICATING";
436    case RECORD:
437        return "RECORD";
438    case OFFLOAD:
439        return "OFFLOAD";
440    default:
441        return "unknown";
442    }
443}
444
445String8 devicesToString(audio_devices_t devices)
446{
447    static const struct mapping {
448        audio_devices_t mDevices;
449        const char *    mString;
450    } mappingsOut[] = {
451        {AUDIO_DEVICE_OUT_EARPIECE,         "EARPIECE"},
452        {AUDIO_DEVICE_OUT_SPEAKER,          "SPEAKER"},
453        {AUDIO_DEVICE_OUT_WIRED_HEADSET,    "WIRED_HEADSET"},
454        {AUDIO_DEVICE_OUT_WIRED_HEADPHONE,  "WIRED_HEADPHONE"},
455        {AUDIO_DEVICE_OUT_BLUETOOTH_SCO,    "BLUETOOTH_SCO"},
456        {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_HEADSET,    "BLUETOOTH_SCO_HEADSET"},
457        {AUDIO_DEVICE_OUT_BLUETOOTH_SCO_CARKIT,     "BLUETOOTH_SCO_CARKIT"},
458        {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP,           "BLUETOOTH_A2DP"},
459        {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES,"BLUETOOTH_A2DP_HEADPHONES"},
460        {AUDIO_DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER,   "BLUETOOTH_A2DP_SPEAKER"},
461        {AUDIO_DEVICE_OUT_AUX_DIGITAL,      "AUX_DIGITAL"},
462        {AUDIO_DEVICE_OUT_HDMI,             "HDMI"},
463        {AUDIO_DEVICE_OUT_ANLG_DOCK_HEADSET,"ANLG_DOCK_HEADSET"},
464        {AUDIO_DEVICE_OUT_DGTL_DOCK_HEADSET,"DGTL_DOCK_HEADSET"},
465        {AUDIO_DEVICE_OUT_USB_ACCESSORY,    "USB_ACCESSORY"},
466        {AUDIO_DEVICE_OUT_USB_DEVICE,       "USB_DEVICE"},
467        {AUDIO_DEVICE_OUT_TELEPHONY_TX,     "TELEPHONY_TX"},
468        {AUDIO_DEVICE_OUT_LINE,             "LINE"},
469        {AUDIO_DEVICE_OUT_HDMI_ARC,         "HDMI_ARC"},
470        {AUDIO_DEVICE_OUT_SPDIF,            "SPDIF"},
471        {AUDIO_DEVICE_OUT_FM,               "FM"},
472        {AUDIO_DEVICE_OUT_AUX_LINE,         "AUX_LINE"},
473        {AUDIO_DEVICE_OUT_SPEAKER_SAFE,     "SPEAKER_SAFE"},
474        {AUDIO_DEVICE_OUT_IP,               "IP"},
475        {AUDIO_DEVICE_OUT_BUS,              "BUS"},
476        {AUDIO_DEVICE_NONE,                 "NONE"},       // must be last
477    }, mappingsIn[] = {
478        {AUDIO_DEVICE_IN_COMMUNICATION,     "COMMUNICATION"},
479        {AUDIO_DEVICE_IN_AMBIENT,           "AMBIENT"},
480        {AUDIO_DEVICE_IN_BUILTIN_MIC,       "BUILTIN_MIC"},
481        {AUDIO_DEVICE_IN_BLUETOOTH_SCO_HEADSET, "BLUETOOTH_SCO_HEADSET"},
482        {AUDIO_DEVICE_IN_WIRED_HEADSET,     "WIRED_HEADSET"},
483        {AUDIO_DEVICE_IN_AUX_DIGITAL,       "AUX_DIGITAL"},
484        {AUDIO_DEVICE_IN_VOICE_CALL,        "VOICE_CALL"},
485        {AUDIO_DEVICE_IN_TELEPHONY_RX,      "TELEPHONY_RX"},
486        {AUDIO_DEVICE_IN_BACK_MIC,          "BACK_MIC"},
487        {AUDIO_DEVICE_IN_REMOTE_SUBMIX,     "REMOTE_SUBMIX"},
488        {AUDIO_DEVICE_IN_ANLG_DOCK_HEADSET, "ANLG_DOCK_HEADSET"},
489        {AUDIO_DEVICE_IN_DGTL_DOCK_HEADSET, "DGTL_DOCK_HEADSET"},
490        {AUDIO_DEVICE_IN_USB_ACCESSORY,     "USB_ACCESSORY"},
491        {AUDIO_DEVICE_IN_USB_DEVICE,        "USB_DEVICE"},
492        {AUDIO_DEVICE_IN_FM_TUNER,          "FM_TUNER"},
493        {AUDIO_DEVICE_IN_TV_TUNER,          "TV_TUNER"},
494        {AUDIO_DEVICE_IN_LINE,              "LINE"},
495        {AUDIO_DEVICE_IN_SPDIF,             "SPDIF"},
496        {AUDIO_DEVICE_IN_BLUETOOTH_A2DP,    "BLUETOOTH_A2DP"},
497        {AUDIO_DEVICE_IN_LOOPBACK,          "LOOPBACK"},
498        {AUDIO_DEVICE_IN_IP,                "IP"},
499        {AUDIO_DEVICE_IN_BUS,               "BUS"},
500        {AUDIO_DEVICE_NONE,                 "NONE"},        // must be last
501    };
502    String8 result;
503    audio_devices_t allDevices = AUDIO_DEVICE_NONE;
504    const mapping *entry;
505    if (devices & AUDIO_DEVICE_BIT_IN) {
506        devices &= ~AUDIO_DEVICE_BIT_IN;
507        entry = mappingsIn;
508    } else {
509        entry = mappingsOut;
510    }
511    for ( ; entry->mDevices != AUDIO_DEVICE_NONE; entry++) {
512        allDevices = (audio_devices_t) (allDevices | entry->mDevices);
513        if (devices & entry->mDevices) {
514            if (!result.isEmpty()) {
515                result.append("|");
516            }
517            result.append(entry->mString);
518        }
519    }
520    if (devices & ~allDevices) {
521        if (!result.isEmpty()) {
522            result.append("|");
523        }
524        result.appendFormat("0x%X", devices & ~allDevices);
525    }
526    if (result.isEmpty()) {
527        result.append(entry->mString);
528    }
529    return result;
530}
531
532String8 inputFlagsToString(audio_input_flags_t flags)
533{
534    static const struct mapping {
535        audio_input_flags_t     mFlag;
536        const char *            mString;
537    } mappings[] = {
538        {AUDIO_INPUT_FLAG_FAST,             "FAST"},
539        {AUDIO_INPUT_FLAG_HW_HOTWORD,       "HW_HOTWORD"},
540        {AUDIO_INPUT_FLAG_RAW,              "RAW"},
541        {AUDIO_INPUT_FLAG_SYNC,             "SYNC"},
542        {AUDIO_INPUT_FLAG_NONE,             "NONE"},        // must be last
543    };
544    String8 result;
545    audio_input_flags_t allFlags = AUDIO_INPUT_FLAG_NONE;
546    const mapping *entry;
547    for (entry = mappings; entry->mFlag != AUDIO_INPUT_FLAG_NONE; entry++) {
548        allFlags = (audio_input_flags_t) (allFlags | entry->mFlag);
549        if (flags & entry->mFlag) {
550            if (!result.isEmpty()) {
551                result.append("|");
552            }
553            result.append(entry->mString);
554        }
555    }
556    if (flags & ~allFlags) {
557        if (!result.isEmpty()) {
558            result.append("|");
559        }
560        result.appendFormat("0x%X", flags & ~allFlags);
561    }
562    if (result.isEmpty()) {
563        result.append(entry->mString);
564    }
565    return result;
566}
567
568String8 outputFlagsToString(audio_output_flags_t flags)
569{
570    static const struct mapping {
571        audio_output_flags_t    mFlag;
572        const char *            mString;
573    } mappings[] = {
574        {AUDIO_OUTPUT_FLAG_DIRECT,          "DIRECT"},
575        {AUDIO_OUTPUT_FLAG_PRIMARY,         "PRIMARY"},
576        {AUDIO_OUTPUT_FLAG_FAST,            "FAST"},
577        {AUDIO_OUTPUT_FLAG_DEEP_BUFFER,     "DEEP_BUFFER"},
578        {AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD,"COMPRESS_OFFLOAD"},
579        {AUDIO_OUTPUT_FLAG_NON_BLOCKING,    "NON_BLOCKING"},
580        {AUDIO_OUTPUT_FLAG_HW_AV_SYNC,      "HW_AV_SYNC"},
581        {AUDIO_OUTPUT_FLAG_RAW,             "RAW"},
582        {AUDIO_OUTPUT_FLAG_SYNC,            "SYNC"},
583        {AUDIO_OUTPUT_FLAG_IEC958_NONAUDIO, "IEC958_NONAUDIO"},
584        {AUDIO_OUTPUT_FLAG_NONE,            "NONE"},        // must be last
585    };
586    String8 result;
587    audio_output_flags_t allFlags = AUDIO_OUTPUT_FLAG_NONE;
588    const mapping *entry;
589    for (entry = mappings; entry->mFlag != AUDIO_OUTPUT_FLAG_NONE; entry++) {
590        allFlags = (audio_output_flags_t) (allFlags | entry->mFlag);
591        if (flags & entry->mFlag) {
592            if (!result.isEmpty()) {
593                result.append("|");
594            }
595            result.append(entry->mString);
596        }
597    }
598    if (flags & ~allFlags) {
599        if (!result.isEmpty()) {
600            result.append("|");
601        }
602        result.appendFormat("0x%X", flags & ~allFlags);
603    }
604    if (result.isEmpty()) {
605        result.append(entry->mString);
606    }
607    return result;
608}
609
610const char *sourceToString(audio_source_t source)
611{
612    switch (source) {
613    case AUDIO_SOURCE_DEFAULT:              return "default";
614    case AUDIO_SOURCE_MIC:                  return "mic";
615    case AUDIO_SOURCE_VOICE_UPLINK:         return "voice uplink";
616    case AUDIO_SOURCE_VOICE_DOWNLINK:       return "voice downlink";
617    case AUDIO_SOURCE_VOICE_CALL:           return "voice call";
618    case AUDIO_SOURCE_CAMCORDER:            return "camcorder";
619    case AUDIO_SOURCE_VOICE_RECOGNITION:    return "voice recognition";
620    case AUDIO_SOURCE_VOICE_COMMUNICATION:  return "voice communication";
621    case AUDIO_SOURCE_REMOTE_SUBMIX:        return "remote submix";
622    case AUDIO_SOURCE_UNPROCESSED:          return "unprocessed";
623    case AUDIO_SOURCE_FM_TUNER:             return "FM tuner";
624    case AUDIO_SOURCE_HOTWORD:              return "hotword";
625    default:                                return "unknown";
626    }
627}
628
629AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
630        audio_devices_t outDevice, audio_devices_t inDevice, type_t type, bool systemReady)
631    :   Thread(false /*canCallJava*/),
632        mType(type),
633        mAudioFlinger(audioFlinger),
634        // mSampleRate, mFrameCount, mChannelMask, mChannelCount, mFrameSize, mFormat, mBufferSize
635        // are set by PlaybackThread::readOutputParameters_l() or
636        // RecordThread::readInputParameters_l()
637        //FIXME: mStandby should be true here. Is this some kind of hack?
638        mStandby(false), mOutDevice(outDevice), mInDevice(inDevice),
639        mPrevOutDevice(AUDIO_DEVICE_NONE), mPrevInDevice(AUDIO_DEVICE_NONE),
640        mAudioSource(AUDIO_SOURCE_DEFAULT), mId(id),
641        // mName will be set by concrete (non-virtual) subclass
642        mDeathRecipient(new PMDeathRecipient(this)),
643        mSystemReady(systemReady),
644        mNotifiedBatteryStart(false)
645{
646    memset(&mPatch, 0, sizeof(struct audio_patch));
647}
648
649AudioFlinger::ThreadBase::~ThreadBase()
650{
651    // mConfigEvents should be empty, but just in case it isn't, free the memory it owns
652    mConfigEvents.clear();
653
654    // do not lock the mutex in destructor
655    releaseWakeLock_l();
656    if (mPowerManager != 0) {
657        sp<IBinder> binder = IInterface::asBinder(mPowerManager);
658        binder->unlinkToDeath(mDeathRecipient);
659    }
660}
661
662status_t AudioFlinger::ThreadBase::readyToRun()
663{
664    status_t status = initCheck();
665    if (status == NO_ERROR) {
666        ALOGI("AudioFlinger's thread %p ready to run", this);
667    } else {
668        ALOGE("No working audio driver found.");
669    }
670    return status;
671}
672
673void AudioFlinger::ThreadBase::exit()
674{
675    ALOGV("ThreadBase::exit");
676    // do any cleanup required for exit to succeed
677    preExit();
678    {
679        // This lock prevents the following race in thread (uniprocessor for illustration):
680        //  if (!exitPending()) {
681        //      // context switch from here to exit()
682        //      // exit() calls requestExit(), what exitPending() observes
683        //      // exit() calls signal(), which is dropped since no waiters
684        //      // context switch back from exit() to here
685        //      mWaitWorkCV.wait(...);
686        //      // now thread is hung
687        //  }
688        AutoMutex lock(mLock);
689        requestExit();
690        mWaitWorkCV.broadcast();
691    }
692    // When Thread::requestExitAndWait is made virtual and this method is renamed to
693    // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
694    requestExitAndWait();
695}
696
697status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
698{
699    ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
700    Mutex::Autolock _l(mLock);
701
702    return sendSetParameterConfigEvent_l(keyValuePairs);
703}
704
705// sendConfigEvent_l() must be called with ThreadBase::mLock held
706// Can temporarily release the lock if waiting for a reply from processConfigEvents_l().
707status_t AudioFlinger::ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
708{
709    status_t status = NO_ERROR;
710
711    if (event->mRequiresSystemReady && !mSystemReady) {
712        event->mWaitStatus = false;
713        mPendingConfigEvents.add(event);
714        return status;
715    }
716    mConfigEvents.add(event);
717    ALOGV("sendConfigEvent_l() num events %zu event %d", mConfigEvents.size(), event->mType);
718    mWaitWorkCV.signal();
719    mLock.unlock();
720    {
721        Mutex::Autolock _l(event->mLock);
722        while (event->mWaitStatus) {
723            if (event->mCond.waitRelative(event->mLock, kConfigEventTimeoutNs) != NO_ERROR) {
724                event->mStatus = TIMED_OUT;
725                event->mWaitStatus = false;
726            }
727        }
728        status = event->mStatus;
729    }
730    mLock.lock();
731    return status;
732}
733
734void AudioFlinger::ThreadBase::sendIoConfigEvent(audio_io_config_event event, pid_t pid)
735{
736    Mutex::Autolock _l(mLock);
737    sendIoConfigEvent_l(event, pid);
738}
739
740// sendIoConfigEvent_l() must be called with ThreadBase::mLock held
741void AudioFlinger::ThreadBase::sendIoConfigEvent_l(audio_io_config_event event, pid_t pid)
742{
743    sp<ConfigEvent> configEvent = (ConfigEvent *)new IoConfigEvent(event, pid);
744    sendConfigEvent_l(configEvent);
745}
746
747void AudioFlinger::ThreadBase::sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio)
748{
749    Mutex::Autolock _l(mLock);
750    sendPrioConfigEvent_l(pid, tid, prio);
751}
752
753// sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
754void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio)
755{
756    sp<ConfigEvent> configEvent = (ConfigEvent *)new PrioConfigEvent(pid, tid, prio);
757    sendConfigEvent_l(configEvent);
758}
759
760// sendSetParameterConfigEvent_l() must be called with ThreadBase::mLock held
761status_t AudioFlinger::ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
762{
763    sp<ConfigEvent> configEvent;
764    AudioParameter param(keyValuePair);
765    int value;
766    if (param.getInt(String8(AUDIO_PARAMETER_MONO_OUTPUT), value) == NO_ERROR) {
767        setMasterMono_l(value != 0);
768        if (param.size() == 1) {
769            return NO_ERROR; // should be a solo parameter - we don't pass down
770        }
771        param.remove(String8(AUDIO_PARAMETER_MONO_OUTPUT));
772        configEvent = new SetParameterConfigEvent(param.toString());
773    } else {
774        configEvent = new SetParameterConfigEvent(keyValuePair);
775    }
776    return sendConfigEvent_l(configEvent);
777}
778
779status_t AudioFlinger::ThreadBase::sendCreateAudioPatchConfigEvent(
780                                                        const struct audio_patch *patch,
781                                                        audio_patch_handle_t *handle)
782{
783    Mutex::Autolock _l(mLock);
784    sp<ConfigEvent> configEvent = (ConfigEvent *)new CreateAudioPatchConfigEvent(*patch, *handle);
785    status_t status = sendConfigEvent_l(configEvent);
786    if (status == NO_ERROR) {
787        CreateAudioPatchConfigEventData *data =
788                                        (CreateAudioPatchConfigEventData *)configEvent->mData.get();
789        *handle = data->mHandle;
790    }
791    return status;
792}
793
794status_t AudioFlinger::ThreadBase::sendReleaseAudioPatchConfigEvent(
795                                                                const audio_patch_handle_t handle)
796{
797    Mutex::Autolock _l(mLock);
798    sp<ConfigEvent> configEvent = (ConfigEvent *)new ReleaseAudioPatchConfigEvent(handle);
799    return sendConfigEvent_l(configEvent);
800}
801
802
803// post condition: mConfigEvents.isEmpty()
804void AudioFlinger::ThreadBase::processConfigEvents_l()
805{
806    bool configChanged = false;
807
808    while (!mConfigEvents.isEmpty()) {
809        ALOGV("processConfigEvents_l() remaining events %zu", mConfigEvents.size());
810        sp<ConfigEvent> event = mConfigEvents[0];
811        mConfigEvents.removeAt(0);
812        switch (event->mType) {
813        case CFG_EVENT_PRIO: {
814            PrioConfigEventData *data = (PrioConfigEventData *)event->mData.get();
815            // FIXME Need to understand why this has to be done asynchronously
816            int err = requestPriority(data->mPid, data->mTid, data->mPrio,
817                    true /*asynchronous*/);
818            if (err != 0) {
819                ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
820                      data->mPrio, data->mPid, data->mTid, err);
821            }
822        } break;
823        case CFG_EVENT_IO: {
824            IoConfigEventData *data = (IoConfigEventData *)event->mData.get();
825            ioConfigChanged(data->mEvent, data->mPid);
826        } break;
827        case CFG_EVENT_SET_PARAMETER: {
828            SetParameterConfigEventData *data = (SetParameterConfigEventData *)event->mData.get();
829            if (checkForNewParameter_l(data->mKeyValuePairs, event->mStatus)) {
830                configChanged = true;
831            }
832        } break;
833        case CFG_EVENT_CREATE_AUDIO_PATCH: {
834            CreateAudioPatchConfigEventData *data =
835                                            (CreateAudioPatchConfigEventData *)event->mData.get();
836            event->mStatus = createAudioPatch_l(&data->mPatch, &data->mHandle);
837        } break;
838        case CFG_EVENT_RELEASE_AUDIO_PATCH: {
839            ReleaseAudioPatchConfigEventData *data =
840                                            (ReleaseAudioPatchConfigEventData *)event->mData.get();
841            event->mStatus = releaseAudioPatch_l(data->mHandle);
842        } break;
843        default:
844            ALOG_ASSERT(false, "processConfigEvents_l() unknown event type %d", event->mType);
845            break;
846        }
847        {
848            Mutex::Autolock _l(event->mLock);
849            if (event->mWaitStatus) {
850                event->mWaitStatus = false;
851                event->mCond.signal();
852            }
853        }
854        ALOGV_IF(mConfigEvents.isEmpty(), "processConfigEvents_l() DONE thread %p", this);
855    }
856
857    if (configChanged) {
858        cacheParameters_l();
859    }
860}
861
862String8 channelMaskToString(audio_channel_mask_t mask, bool output) {
863    String8 s;
864    const audio_channel_representation_t representation =
865            audio_channel_mask_get_representation(mask);
866
867    switch (representation) {
868    case AUDIO_CHANNEL_REPRESENTATION_POSITION: {
869        if (output) {
870            if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT) s.append("front-left, ");
871            if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT) s.append("front-right, ");
872            if (mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) s.append("front-center, ");
873            if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) s.append("low freq, ");
874            if (mask & AUDIO_CHANNEL_OUT_BACK_LEFT) s.append("back-left, ");
875            if (mask & AUDIO_CHANNEL_OUT_BACK_RIGHT) s.append("back-right, ");
876            if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER) s.append("front-left-of-center, ");
877            if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER) s.append("front-right-of-center, ");
878            if (mask & AUDIO_CHANNEL_OUT_BACK_CENTER) s.append("back-center, ");
879            if (mask & AUDIO_CHANNEL_OUT_SIDE_LEFT) s.append("side-left, ");
880            if (mask & AUDIO_CHANNEL_OUT_SIDE_RIGHT) s.append("side-right, ");
881            if (mask & AUDIO_CHANNEL_OUT_TOP_CENTER) s.append("top-center ,");
882            if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT) s.append("top-front-left, ");
883            if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER) s.append("top-front-center, ");
884            if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT) s.append("top-front-right, ");
885            if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_LEFT) s.append("top-back-left, ");
886            if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_CENTER) s.append("top-back-center, " );
887            if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT) s.append("top-back-right, " );
888            if (mask & ~AUDIO_CHANNEL_OUT_ALL) s.append("unknown,  ");
889        } else {
890            if (mask & AUDIO_CHANNEL_IN_LEFT) s.append("left, ");
891            if (mask & AUDIO_CHANNEL_IN_RIGHT) s.append("right, ");
892            if (mask & AUDIO_CHANNEL_IN_FRONT) s.append("front, ");
893            if (mask & AUDIO_CHANNEL_IN_BACK) s.append("back, ");
894            if (mask & AUDIO_CHANNEL_IN_LEFT_PROCESSED) s.append("left-processed, ");
895            if (mask & AUDIO_CHANNEL_IN_RIGHT_PROCESSED) s.append("right-processed, ");
896            if (mask & AUDIO_CHANNEL_IN_FRONT_PROCESSED) s.append("front-processed, ");
897            if (mask & AUDIO_CHANNEL_IN_BACK_PROCESSED) s.append("back-processed, ");
898            if (mask & AUDIO_CHANNEL_IN_PRESSURE) s.append("pressure, ");
899            if (mask & AUDIO_CHANNEL_IN_X_AXIS) s.append("X, ");
900            if (mask & AUDIO_CHANNEL_IN_Y_AXIS) s.append("Y, ");
901            if (mask & AUDIO_CHANNEL_IN_Z_AXIS) s.append("Z, ");
902            if (mask & AUDIO_CHANNEL_IN_VOICE_UPLINK) s.append("voice-uplink, ");
903            if (mask & AUDIO_CHANNEL_IN_VOICE_DNLINK) s.append("voice-dnlink, ");
904            if (mask & ~AUDIO_CHANNEL_IN_ALL) s.append("unknown,  ");
905        }
906        const int len = s.length();
907        if (len > 2) {
908            (void) s.lockBuffer(len);      // needed?
909            s.unlockBuffer(len - 2);       // remove trailing ", "
910        }
911        return s;
912    }
913    case AUDIO_CHANNEL_REPRESENTATION_INDEX:
914        s.appendFormat("index mask, bits:%#x", audio_channel_mask_get_bits(mask));
915        return s;
916    default:
917        s.appendFormat("unknown mask, representation:%d  bits:%#x",
918                representation, audio_channel_mask_get_bits(mask));
919        return s;
920    }
921}
922
923void AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args __unused)
924{
925    const size_t SIZE = 256;
926    char buffer[SIZE];
927    String8 result;
928
929    bool locked = AudioFlinger::dumpTryLock(mLock);
930    if (!locked) {
931        dprintf(fd, "thread %p may be deadlocked\n", this);
932    }
933
934    dprintf(fd, "  Thread name: %s\n", mThreadName);
935    dprintf(fd, "  I/O handle: %d\n", mId);
936    dprintf(fd, "  TID: %d\n", getTid());
937    dprintf(fd, "  Standby: %s\n", mStandby ? "yes" : "no");
938    dprintf(fd, "  Sample rate: %u Hz\n", mSampleRate);
939    dprintf(fd, "  HAL frame count: %zu\n", mFrameCount);
940    dprintf(fd, "  HAL format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat));
941    dprintf(fd, "  HAL buffer size: %zu bytes\n", mBufferSize);
942    dprintf(fd, "  Channel count: %u\n", mChannelCount);
943    dprintf(fd, "  Channel mask: 0x%08x (%s)\n", mChannelMask,
944            channelMaskToString(mChannelMask, mType != RECORD).string());
945    dprintf(fd, "  Processing format: 0x%x (%s)\n", mFormat, formatToString(mFormat));
946    dprintf(fd, "  Processing frame size: %zu bytes\n", mFrameSize);
947    dprintf(fd, "  Pending config events:");
948    size_t numConfig = mConfigEvents.size();
949    if (numConfig) {
950        for (size_t i = 0; i < numConfig; i++) {
951            mConfigEvents[i]->dump(buffer, SIZE);
952            dprintf(fd, "\n    %s", buffer);
953        }
954        dprintf(fd, "\n");
955    } else {
956        dprintf(fd, " none\n");
957    }
958    dprintf(fd, "  Output device: %#x (%s)\n", mOutDevice, devicesToString(mOutDevice).string());
959    dprintf(fd, "  Input device: %#x (%s)\n", mInDevice, devicesToString(mInDevice).string());
960    dprintf(fd, "  Audio source: %d (%s)\n", mAudioSource, sourceToString(mAudioSource));
961
962    if (locked) {
963        mLock.unlock();
964    }
965}
966
967void AudioFlinger::ThreadBase::dumpEffectChains(int fd, const Vector<String16>& args)
968{
969    const size_t SIZE = 256;
970    char buffer[SIZE];
971    String8 result;
972
973    size_t numEffectChains = mEffectChains.size();
974    snprintf(buffer, SIZE, "  %zu Effect Chains\n", numEffectChains);
975    write(fd, buffer, strlen(buffer));
976
977    for (size_t i = 0; i < numEffectChains; ++i) {
978        sp<EffectChain> chain = mEffectChains[i];
979        if (chain != 0) {
980            chain->dump(fd, args);
981        }
982    }
983}
984
985void AudioFlinger::ThreadBase::acquireWakeLock(int uid)
986{
987    Mutex::Autolock _l(mLock);
988    acquireWakeLock_l(uid);
989}
990
991String16 AudioFlinger::ThreadBase::getWakeLockTag()
992{
993    switch (mType) {
994    case MIXER:
995        return String16("AudioMix");
996    case DIRECT:
997        return String16("AudioDirectOut");
998    case DUPLICATING:
999        return String16("AudioDup");
1000    case RECORD:
1001        return String16("AudioIn");
1002    case OFFLOAD:
1003        return String16("AudioOffload");
1004    default:
1005        ALOG_ASSERT(false);
1006        return String16("AudioUnknown");
1007    }
1008}
1009
1010void AudioFlinger::ThreadBase::acquireWakeLock_l(int uid)
1011{
1012    getPowerManager_l();
1013    if (mPowerManager != 0) {
1014        sp<IBinder> binder = new BBinder();
1015        status_t status;
1016        if (uid >= 0) {
1017            status = mPowerManager->acquireWakeLockWithUid(POWERMANAGER_PARTIAL_WAKE_LOCK,
1018                    binder,
1019                    getWakeLockTag(),
1020                    String16("audioserver"),
1021                    uid,
1022                    true /* FIXME force oneway contrary to .aidl */);
1023        } else {
1024            status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK,
1025                    binder,
1026                    getWakeLockTag(),
1027                    String16("audioserver"),
1028                    true /* FIXME force oneway contrary to .aidl */);
1029        }
1030        if (status == NO_ERROR) {
1031            mWakeLockToken = binder;
1032        }
1033        ALOGV("acquireWakeLock_l() %s status %d", mThreadName, status);
1034    }
1035
1036    if (!mNotifiedBatteryStart) {
1037        BatteryNotifier::getInstance().noteStartAudio();
1038        mNotifiedBatteryStart = true;
1039    }
1040    gBoottime.acquire(mWakeLockToken);
1041    mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME] =
1042            gBoottime.getBoottimeOffset();
1043}
1044
1045void AudioFlinger::ThreadBase::releaseWakeLock()
1046{
1047    Mutex::Autolock _l(mLock);
1048    releaseWakeLock_l();
1049}
1050
1051void AudioFlinger::ThreadBase::releaseWakeLock_l()
1052{
1053    gBoottime.release(mWakeLockToken);
1054    if (mWakeLockToken != 0) {
1055        ALOGV("releaseWakeLock_l() %s", mThreadName);
1056        if (mPowerManager != 0) {
1057            mPowerManager->releaseWakeLock(mWakeLockToken, 0,
1058                    true /* FIXME force oneway contrary to .aidl */);
1059        }
1060        mWakeLockToken.clear();
1061    }
1062
1063    if (mNotifiedBatteryStart) {
1064        BatteryNotifier::getInstance().noteStopAudio();
1065        mNotifiedBatteryStart = false;
1066    }
1067}
1068
1069void AudioFlinger::ThreadBase::updateWakeLockUids(const SortedVector<int> &uids) {
1070    Mutex::Autolock _l(mLock);
1071    updateWakeLockUids_l(uids);
1072}
1073
1074void AudioFlinger::ThreadBase::getPowerManager_l() {
1075    if (mSystemReady && mPowerManager == 0) {
1076        // use checkService() to avoid blocking if power service is not up yet
1077        sp<IBinder> binder =
1078            defaultServiceManager()->checkService(String16("power"));
1079        if (binder == 0) {
1080            ALOGW("Thread %s cannot connect to the power manager service", mThreadName);
1081        } else {
1082            mPowerManager = interface_cast<IPowerManager>(binder);
1083            binder->linkToDeath(mDeathRecipient);
1084        }
1085    }
1086}
1087
1088void AudioFlinger::ThreadBase::updateWakeLockUids_l(const SortedVector<int> &uids) {
1089    getPowerManager_l();
1090    if (mWakeLockToken == NULL) { // token may be NULL if AudioFlinger::systemReady() not called.
1091        if (mSystemReady) {
1092            ALOGE("no wake lock to update, but system ready!");
1093        } else {
1094            ALOGW("no wake lock to update, system not ready yet");
1095        }
1096        return;
1097    }
1098    if (mPowerManager != 0) {
1099        sp<IBinder> binder = new BBinder();
1100        status_t status;
1101        status = mPowerManager->updateWakeLockUids(mWakeLockToken, uids.size(), uids.array(),
1102                    true /* FIXME force oneway contrary to .aidl */);
1103        ALOGV("updateWakeLockUids_l() %s status %d", mThreadName, status);
1104    }
1105}
1106
1107void AudioFlinger::ThreadBase::clearPowerManager()
1108{
1109    Mutex::Autolock _l(mLock);
1110    releaseWakeLock_l();
1111    mPowerManager.clear();
1112}
1113
1114void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who __unused)
1115{
1116    sp<ThreadBase> thread = mThread.promote();
1117    if (thread != 0) {
1118        thread->clearPowerManager();
1119    }
1120    ALOGW("power manager service died !!!");
1121}
1122
1123void AudioFlinger::ThreadBase::setEffectSuspended(
1124        const effect_uuid_t *type, bool suspend, audio_session_t sessionId)
1125{
1126    Mutex::Autolock _l(mLock);
1127    setEffectSuspended_l(type, suspend, sessionId);
1128}
1129
1130void AudioFlinger::ThreadBase::setEffectSuspended_l(
1131        const effect_uuid_t *type, bool suspend, audio_session_t sessionId)
1132{
1133    sp<EffectChain> chain = getEffectChain_l(sessionId);
1134    if (chain != 0) {
1135        if (type != NULL) {
1136            chain->setEffectSuspended_l(type, suspend);
1137        } else {
1138            chain->setEffectSuspendedAll_l(suspend);
1139        }
1140    }
1141
1142    updateSuspendedSessions_l(type, suspend, sessionId);
1143}
1144
1145void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
1146{
1147    ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
1148    if (index < 0) {
1149        return;
1150    }
1151
1152    const KeyedVector <int, sp<SuspendedSessionDesc> >& sessionEffects =
1153            mSuspendedSessions.valueAt(index);
1154
1155    for (size_t i = 0; i < sessionEffects.size(); i++) {
1156        sp<SuspendedSessionDesc> desc = sessionEffects.valueAt(i);
1157        for (int j = 0; j < desc->mRefCount; j++) {
1158            if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
1159                chain->setEffectSuspendedAll_l(true);
1160            } else {
1161                ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
1162                    desc->mType.timeLow);
1163                chain->setEffectSuspended_l(&desc->mType, true);
1164            }
1165        }
1166    }
1167}
1168
1169void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
1170                                                         bool suspend,
1171                                                         audio_session_t sessionId)
1172{
1173    ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
1174
1175    KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
1176
1177    if (suspend) {
1178        if (index >= 0) {
1179            sessionEffects = mSuspendedSessions.valueAt(index);
1180        } else {
1181            mSuspendedSessions.add(sessionId, sessionEffects);
1182        }
1183    } else {
1184        if (index < 0) {
1185            return;
1186        }
1187        sessionEffects = mSuspendedSessions.valueAt(index);
1188    }
1189
1190
1191    int key = EffectChain::kKeyForSuspendAll;
1192    if (type != NULL) {
1193        key = type->timeLow;
1194    }
1195    index = sessionEffects.indexOfKey(key);
1196
1197    sp<SuspendedSessionDesc> desc;
1198    if (suspend) {
1199        if (index >= 0) {
1200            desc = sessionEffects.valueAt(index);
1201        } else {
1202            desc = new SuspendedSessionDesc();
1203            if (type != NULL) {
1204                desc->mType = *type;
1205            }
1206            sessionEffects.add(key, desc);
1207            ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
1208        }
1209        desc->mRefCount++;
1210    } else {
1211        if (index < 0) {
1212            return;
1213        }
1214        desc = sessionEffects.valueAt(index);
1215        if (--desc->mRefCount == 0) {
1216            ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
1217            sessionEffects.removeItemsAt(index);
1218            if (sessionEffects.isEmpty()) {
1219                ALOGV("updateSuspendedSessions_l() restore removing session %d",
1220                                 sessionId);
1221                mSuspendedSessions.removeItem(sessionId);
1222            }
1223        }
1224    }
1225    if (!sessionEffects.isEmpty()) {
1226        mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
1227    }
1228}
1229
1230void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
1231                                                            bool enabled,
1232                                                            audio_session_t sessionId)
1233{
1234    Mutex::Autolock _l(mLock);
1235    checkSuspendOnEffectEnabled_l(effect, enabled, sessionId);
1236}
1237
1238void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
1239                                                            bool enabled,
1240                                                            audio_session_t sessionId)
1241{
1242    if (mType != RECORD) {
1243        // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
1244        // another session. This gives the priority to well behaved effect control panels
1245        // and applications not using global effects.
1246        // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
1247        // global effects
1248        if ((sessionId != AUDIO_SESSION_OUTPUT_MIX) && (sessionId != AUDIO_SESSION_OUTPUT_STAGE)) {
1249            setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
1250        }
1251    }
1252
1253    sp<EffectChain> chain = getEffectChain_l(sessionId);
1254    if (chain != 0) {
1255        chain->checkSuspendOnEffectEnabled(effect, enabled);
1256    }
1257}
1258
1259// ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
1260sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
1261        const sp<AudioFlinger::Client>& client,
1262        const sp<IEffectClient>& effectClient,
1263        int32_t priority,
1264        audio_session_t sessionId,
1265        effect_descriptor_t *desc,
1266        int *enabled,
1267        status_t *status)
1268{
1269    sp<EffectModule> effect;
1270    sp<EffectHandle> handle;
1271    status_t lStatus;
1272    sp<EffectChain> chain;
1273    bool chainCreated = false;
1274    bool effectCreated = false;
1275    bool effectRegistered = false;
1276
1277    lStatus = initCheck();
1278    if (lStatus != NO_ERROR) {
1279        ALOGW("createEffect_l() Audio driver not initialized.");
1280        goto Exit;
1281    }
1282
1283    // Reject any effect on Direct output threads for now, since the format of
1284    // mSinkBuffer is not guaranteed to be compatible with effect processing (PCM 16 stereo).
1285    if (mType == DIRECT) {
1286        ALOGW("createEffect_l() Cannot add effect %s on Direct output type thread %s",
1287                desc->name, mThreadName);
1288        lStatus = BAD_VALUE;
1289        goto Exit;
1290    }
1291
1292    // Reject any effect on mixer or duplicating multichannel sinks.
1293    // TODO: fix both format and multichannel issues with effects.
1294    if ((mType == MIXER || mType == DUPLICATING) && mChannelCount != FCC_2) {
1295        ALOGW("createEffect_l() Cannot add effect %s for multichannel(%d) %s threads",
1296                desc->name, mChannelCount, mType == MIXER ? "MIXER" : "DUPLICATING");
1297        lStatus = BAD_VALUE;
1298        goto Exit;
1299    }
1300
1301    // Allow global effects only on offloaded and mixer threads
1302    if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
1303        switch (mType) {
1304        case MIXER:
1305        case OFFLOAD:
1306            break;
1307        case DIRECT:
1308        case DUPLICATING:
1309        case RECORD:
1310        default:
1311            ALOGW("createEffect_l() Cannot add global effect %s on thread %s",
1312                    desc->name, mThreadName);
1313            lStatus = BAD_VALUE;
1314            goto Exit;
1315        }
1316    }
1317
1318    // Only Pre processor effects are allowed on input threads and only on input threads
1319    if ((mType == RECORD) != ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
1320        ALOGW("createEffect_l() effect %s (flags %08x) created on wrong thread type %d",
1321                desc->name, desc->flags, mType);
1322        lStatus = BAD_VALUE;
1323        goto Exit;
1324    }
1325
1326    ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
1327
1328    { // scope for mLock
1329        Mutex::Autolock _l(mLock);
1330
1331        // check for existing effect chain with the requested audio session
1332        chain = getEffectChain_l(sessionId);
1333        if (chain == 0) {
1334            // create a new chain for this session
1335            ALOGV("createEffect_l() new effect chain for session %d", sessionId);
1336            chain = new EffectChain(this, sessionId);
1337            addEffectChain_l(chain);
1338            chain->setStrategy(getStrategyForSession_l(sessionId));
1339            chainCreated = true;
1340        } else {
1341            effect = chain->getEffectFromDesc_l(desc);
1342        }
1343
1344        ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
1345
1346        if (effect == 0) {
1347            audio_unique_id_t id = mAudioFlinger->nextUniqueId(AUDIO_UNIQUE_ID_USE_EFFECT);
1348            // Check CPU and memory usage
1349            lStatus = AudioSystem::registerEffect(desc, mId, chain->strategy(), sessionId, id);
1350            if (lStatus != NO_ERROR) {
1351                goto Exit;
1352            }
1353            effectRegistered = true;
1354            // create a new effect module if none present in the chain
1355            effect = new EffectModule(this, chain, desc, id, sessionId);
1356            lStatus = effect->status();
1357            if (lStatus != NO_ERROR) {
1358                goto Exit;
1359            }
1360            effect->setOffloaded(mType == OFFLOAD, mId);
1361
1362            lStatus = chain->addEffect_l(effect);
1363            if (lStatus != NO_ERROR) {
1364                goto Exit;
1365            }
1366            effectCreated = true;
1367
1368            effect->setDevice(mOutDevice);
1369            effect->setDevice(mInDevice);
1370            effect->setMode(mAudioFlinger->getMode());
1371            effect->setAudioSource(mAudioSource);
1372        }
1373        // create effect handle and connect it to effect module
1374        handle = new EffectHandle(effect, client, effectClient, priority);
1375        lStatus = handle->initCheck();
1376        if (lStatus == OK) {
1377            lStatus = effect->addHandle(handle.get());
1378        }
1379        if (enabled != NULL) {
1380            *enabled = (int)effect->isEnabled();
1381        }
1382    }
1383
1384Exit:
1385    if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
1386        Mutex::Autolock _l(mLock);
1387        if (effectCreated) {
1388            chain->removeEffect_l(effect);
1389        }
1390        if (effectRegistered) {
1391            AudioSystem::unregisterEffect(effect->id());
1392        }
1393        if (chainCreated) {
1394            removeEffectChain_l(chain);
1395        }
1396        handle.clear();
1397    }
1398
1399    *status = lStatus;
1400    return handle;
1401}
1402
1403sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(audio_session_t sessionId,
1404        int effectId)
1405{
1406    Mutex::Autolock _l(mLock);
1407    return getEffect_l(sessionId, effectId);
1408}
1409
1410sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(audio_session_t sessionId,
1411        int effectId)
1412{
1413    sp<EffectChain> chain = getEffectChain_l(sessionId);
1414    return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
1415}
1416
1417// PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
1418// PlaybackThread::mLock held
1419status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
1420{
1421    // check for existing effect chain with the requested audio session
1422    audio_session_t sessionId = effect->sessionId();
1423    sp<EffectChain> chain = getEffectChain_l(sessionId);
1424    bool chainCreated = false;
1425
1426    ALOGD_IF((mType == OFFLOAD) && !effect->isOffloadable(),
1427             "addEffect_l() on offloaded thread %p: effect %s does not support offload flags %x",
1428                    this, effect->desc().name, effect->desc().flags);
1429
1430    if (chain == 0) {
1431        // create a new chain for this session
1432        ALOGV("addEffect_l() new effect chain for session %d", sessionId);
1433        chain = new EffectChain(this, sessionId);
1434        addEffectChain_l(chain);
1435        chain->setStrategy(getStrategyForSession_l(sessionId));
1436        chainCreated = true;
1437    }
1438    ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
1439
1440    if (chain->getEffectFromId_l(effect->id()) != 0) {
1441        ALOGW("addEffect_l() %p effect %s already present in chain %p",
1442                this, effect->desc().name, chain.get());
1443        return BAD_VALUE;
1444    }
1445
1446    effect->setOffloaded(mType == OFFLOAD, mId);
1447
1448    status_t status = chain->addEffect_l(effect);
1449    if (status != NO_ERROR) {
1450        if (chainCreated) {
1451            removeEffectChain_l(chain);
1452        }
1453        return status;
1454    }
1455
1456    effect->setDevice(mOutDevice);
1457    effect->setDevice(mInDevice);
1458    effect->setMode(mAudioFlinger->getMode());
1459    effect->setAudioSource(mAudioSource);
1460    return NO_ERROR;
1461}
1462
1463void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect) {
1464
1465    ALOGV("removeEffect_l() %p effect %p", this, effect.get());
1466    effect_descriptor_t desc = effect->desc();
1467    if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
1468        detachAuxEffect_l(effect->id());
1469    }
1470
1471    sp<EffectChain> chain = effect->chain().promote();
1472    if (chain != 0) {
1473        // remove effect chain if removing last effect
1474        if (chain->removeEffect_l(effect) == 0) {
1475            removeEffectChain_l(chain);
1476        }
1477    } else {
1478        ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
1479    }
1480}
1481
1482void AudioFlinger::ThreadBase::lockEffectChains_l(
1483        Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1484{
1485    effectChains = mEffectChains;
1486    for (size_t i = 0; i < mEffectChains.size(); i++) {
1487        mEffectChains[i]->lock();
1488    }
1489}
1490
1491void AudioFlinger::ThreadBase::unlockEffectChains(
1492        const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
1493{
1494    for (size_t i = 0; i < effectChains.size(); i++) {
1495        effectChains[i]->unlock();
1496    }
1497}
1498
1499sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(audio_session_t sessionId)
1500{
1501    Mutex::Autolock _l(mLock);
1502    return getEffectChain_l(sessionId);
1503}
1504
1505sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(audio_session_t sessionId)
1506        const
1507{
1508    size_t size = mEffectChains.size();
1509    for (size_t i = 0; i < size; i++) {
1510        if (mEffectChains[i]->sessionId() == sessionId) {
1511            return mEffectChains[i];
1512        }
1513    }
1514    return 0;
1515}
1516
1517void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
1518{
1519    Mutex::Autolock _l(mLock);
1520    size_t size = mEffectChains.size();
1521    for (size_t i = 0; i < size; i++) {
1522        mEffectChains[i]->setMode_l(mode);
1523    }
1524}
1525
1526void AudioFlinger::ThreadBase::getAudioPortConfig(struct audio_port_config *config)
1527{
1528    config->type = AUDIO_PORT_TYPE_MIX;
1529    config->ext.mix.handle = mId;
1530    config->sample_rate = mSampleRate;
1531    config->format = mFormat;
1532    config->channel_mask = mChannelMask;
1533    config->config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE|AUDIO_PORT_CONFIG_CHANNEL_MASK|
1534                            AUDIO_PORT_CONFIG_FORMAT;
1535}
1536
1537void AudioFlinger::ThreadBase::systemReady()
1538{
1539    Mutex::Autolock _l(mLock);
1540    if (mSystemReady) {
1541        return;
1542    }
1543    mSystemReady = true;
1544
1545    for (size_t i = 0; i < mPendingConfigEvents.size(); i++) {
1546        sendConfigEvent_l(mPendingConfigEvents.editItemAt(i));
1547    }
1548    mPendingConfigEvents.clear();
1549}
1550
1551
1552// ----------------------------------------------------------------------------
1553//      Playback
1554// ----------------------------------------------------------------------------
1555
1556AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
1557                                             AudioStreamOut* output,
1558                                             audio_io_handle_t id,
1559                                             audio_devices_t device,
1560                                             type_t type,
1561                                             bool systemReady)
1562    :   ThreadBase(audioFlinger, id, device, AUDIO_DEVICE_NONE, type, systemReady),
1563        mNormalFrameCount(0), mSinkBuffer(NULL),
1564        mMixerBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
1565        mMixerBuffer(NULL),
1566        mMixerBufferSize(0),
1567        mMixerBufferFormat(AUDIO_FORMAT_INVALID),
1568        mMixerBufferValid(false),
1569        mEffectBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
1570        mEffectBuffer(NULL),
1571        mEffectBufferSize(0),
1572        mEffectBufferFormat(AUDIO_FORMAT_INVALID),
1573        mEffectBufferValid(false),
1574        mSuspended(0), mBytesWritten(0),
1575        mFramesWritten(0),
1576        mActiveTracksGeneration(0),
1577        // mStreamTypes[] initialized in constructor body
1578        mOutput(output),
1579        mLastWriteTime(-1), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
1580        mMixerStatus(MIXER_IDLE),
1581        mMixerStatusIgnoringFastTracks(MIXER_IDLE),
1582        mStandbyDelayNs(AudioFlinger::mStandbyTimeInNsecs),
1583        mBytesRemaining(0),
1584        mCurrentWriteLength(0),
1585        mUseAsyncWrite(false),
1586        mWriteAckSequence(0),
1587        mDrainSequence(0),
1588        mSignalPending(false),
1589        mScreenState(AudioFlinger::mScreenState),
1590        // index 0 is reserved for normal mixer's submix
1591        mFastTrackAvailMask(((1 << FastMixerState::sMaxFastTracks) - 1) & ~1),
1592        mHwSupportsPause(false), mHwPaused(false), mFlushPending(false)
1593{
1594    snprintf(mThreadName, kThreadNameLength, "AudioOut_%X", id);
1595    mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mThreadName);
1596
1597    // Assumes constructor is called by AudioFlinger with it's mLock held, but
1598    // it would be safer to explicitly pass initial masterVolume/masterMute as
1599    // parameter.
1600    //
1601    // If the HAL we are using has support for master volume or master mute,
1602    // then do not attenuate or mute during mixing (just leave the volume at 1.0
1603    // and the mute set to false).
1604    mMasterVolume = audioFlinger->masterVolume_l();
1605    mMasterMute = audioFlinger->masterMute_l();
1606    if (mOutput && mOutput->audioHwDev) {
1607        if (mOutput->audioHwDev->canSetMasterVolume()) {
1608            mMasterVolume = 1.0;
1609        }
1610
1611        if (mOutput->audioHwDev->canSetMasterMute()) {
1612            mMasterMute = false;
1613        }
1614    }
1615
1616    readOutputParameters_l();
1617
1618    // ++ operator does not compile
1619    for (audio_stream_type_t stream = AUDIO_STREAM_MIN; stream < AUDIO_STREAM_CNT;
1620            stream = (audio_stream_type_t) (stream + 1)) {
1621        mStreamTypes[stream].volume = mAudioFlinger->streamVolume_l(stream);
1622        mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
1623    }
1624}
1625
1626AudioFlinger::PlaybackThread::~PlaybackThread()
1627{
1628    mAudioFlinger->unregisterWriter(mNBLogWriter);
1629    free(mSinkBuffer);
1630    free(mMixerBuffer);
1631    free(mEffectBuffer);
1632}
1633
1634void AudioFlinger::PlaybackThread::dump(int fd, const Vector<String16>& args)
1635{
1636    dumpInternals(fd, args);
1637    dumpTracks(fd, args);
1638    dumpEffectChains(fd, args);
1639}
1640
1641void AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args __unused)
1642{
1643    const size_t SIZE = 256;
1644    char buffer[SIZE];
1645    String8 result;
1646
1647    result.appendFormat("  Stream volumes in dB: ");
1648    for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
1649        const stream_type_t *st = &mStreamTypes[i];
1650        if (i > 0) {
1651            result.appendFormat(", ");
1652        }
1653        result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
1654        if (st->mute) {
1655            result.append("M");
1656        }
1657    }
1658    result.append("\n");
1659    write(fd, result.string(), result.length());
1660    result.clear();
1661
1662    // These values are "raw"; they will wrap around.  See prepareTracks_l() for a better way.
1663    FastTrackUnderruns underruns = getFastTrackUnderruns(0);
1664    dprintf(fd, "  Normal mixer raw underrun counters: partial=%u empty=%u\n",
1665            underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
1666
1667    size_t numtracks = mTracks.size();
1668    size_t numactive = mActiveTracks.size();
1669    dprintf(fd, "  %zu Tracks", numtracks);
1670    size_t numactiveseen = 0;
1671    if (numtracks) {
1672        dprintf(fd, " of which %zu are active\n", numactive);
1673        Track::appendDumpHeader(result);
1674        for (size_t i = 0; i < numtracks; ++i) {
1675            sp<Track> track = mTracks[i];
1676            if (track != 0) {
1677                bool active = mActiveTracks.indexOf(track) >= 0;
1678                if (active) {
1679                    numactiveseen++;
1680                }
1681                track->dump(buffer, SIZE, active);
1682                result.append(buffer);
1683            }
1684        }
1685    } else {
1686        result.append("\n");
1687    }
1688    if (numactiveseen != numactive) {
1689        // some tracks in the active list were not in the tracks list
1690        snprintf(buffer, SIZE, "  The following tracks are in the active list but"
1691                " not in the track list\n");
1692        result.append(buffer);
1693        Track::appendDumpHeader(result);
1694        for (size_t i = 0; i < numactive; ++i) {
1695            sp<Track> track = mActiveTracks[i].promote();
1696            if (track != 0 && mTracks.indexOf(track) < 0) {
1697                track->dump(buffer, SIZE, true);
1698                result.append(buffer);
1699            }
1700        }
1701    }
1702
1703    write(fd, result.string(), result.size());
1704}
1705
1706void AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String16>& args)
1707{
1708    dprintf(fd, "\nOutput thread %p type %d (%s):\n", this, type(), threadTypeToString(type()));
1709
1710    dumpBase(fd, args);
1711
1712    dprintf(fd, "  Normal frame count: %zu\n", mNormalFrameCount);
1713    dprintf(fd, "  Last write occurred (msecs): %llu\n",
1714            (unsigned long long) ns2ms(systemTime() - mLastWriteTime));
1715    dprintf(fd, "  Total writes: %d\n", mNumWrites);
1716    dprintf(fd, "  Delayed writes: %d\n", mNumDelayedWrites);
1717    dprintf(fd, "  Blocked in write: %s\n", mInWrite ? "yes" : "no");
1718    dprintf(fd, "  Suspend count: %d\n", mSuspended);
1719    dprintf(fd, "  Sink buffer : %p\n", mSinkBuffer);
1720    dprintf(fd, "  Mixer buffer: %p\n", mMixerBuffer);
1721    dprintf(fd, "  Effect buffer: %p\n", mEffectBuffer);
1722    dprintf(fd, "  Fast track availMask=%#x\n", mFastTrackAvailMask);
1723    dprintf(fd, "  Standby delay ns=%lld\n", (long long)mStandbyDelayNs);
1724    AudioStreamOut *output = mOutput;
1725    audio_output_flags_t flags = output != NULL ? output->flags : AUDIO_OUTPUT_FLAG_NONE;
1726    String8 flagsAsString = outputFlagsToString(flags);
1727    dprintf(fd, "  AudioStreamOut: %p flags %#x (%s)\n", output, flags, flagsAsString.string());
1728}
1729
1730// Thread virtuals
1731
1732void AudioFlinger::PlaybackThread::onFirstRef()
1733{
1734    run(mThreadName, ANDROID_PRIORITY_URGENT_AUDIO);
1735}
1736
1737// ThreadBase virtuals
1738void AudioFlinger::PlaybackThread::preExit()
1739{
1740    ALOGV("  preExit()");
1741    // FIXME this is using hard-coded strings but in the future, this functionality will be
1742    //       converted to use audio HAL extensions required to support tunneling
1743    mOutput->stream->common.set_parameters(&mOutput->stream->common, "exiting=1");
1744}
1745
1746// PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
1747sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
1748        const sp<AudioFlinger::Client>& client,
1749        audio_stream_type_t streamType,
1750        uint32_t sampleRate,
1751        audio_format_t format,
1752        audio_channel_mask_t channelMask,
1753        size_t *pFrameCount,
1754        const sp<IMemory>& sharedBuffer,
1755        audio_session_t sessionId,
1756        IAudioFlinger::track_flags_t *flags,
1757        pid_t tid,
1758        int uid,
1759        status_t *status)
1760{
1761    size_t frameCount = *pFrameCount;
1762    sp<Track> track;
1763    status_t lStatus;
1764
1765    // client expresses a preference for FAST, but we get the final say
1766    if (*flags & IAudioFlinger::TRACK_FAST) {
1767      if (
1768            // PCM data
1769            audio_is_linear_pcm(format) &&
1770            // TODO: extract as a data library function that checks that a computationally
1771            // expensive downmixer is not required: isFastOutputChannelConversion()
1772            (channelMask == mChannelMask ||
1773                    mChannelMask != AUDIO_CHANNEL_OUT_STEREO ||
1774                    (channelMask == AUDIO_CHANNEL_OUT_MONO
1775                            /* && mChannelMask == AUDIO_CHANNEL_OUT_STEREO */)) &&
1776            // hardware sample rate
1777            (sampleRate == mSampleRate) &&
1778            // normal mixer has an associated fast mixer
1779            hasFastMixer() &&
1780            // there are sufficient fast track slots available
1781            (mFastTrackAvailMask != 0)
1782            // FIXME test that MixerThread for this fast track has a capable output HAL
1783            // FIXME add a permission test also?
1784        ) {
1785        // static tracks can have any nonzero framecount, streaming tracks check against minimum.
1786        if (sharedBuffer == 0) {
1787            // read the fast track multiplier property the first time it is needed
1788            int ok = pthread_once(&sFastTrackMultiplierOnce, sFastTrackMultiplierInit);
1789            if (ok != 0) {
1790                ALOGE("%s pthread_once failed: %d", __func__, ok);
1791            }
1792            frameCount = max(frameCount, mFrameCount * sFastTrackMultiplier); // incl framecount 0
1793        }
1794        ALOGV("AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%zu mFrameCount=%zu",
1795                frameCount, mFrameCount);
1796      } else {
1797        ALOGV("AUDIO_OUTPUT_FLAG_FAST denied: sharedBuffer=%p frameCount=%zu "
1798                "mFrameCount=%zu format=%#x mFormat=%#x isLinear=%d channelMask=%#x "
1799                "sampleRate=%u mSampleRate=%u "
1800                "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
1801                sharedBuffer.get(), frameCount, mFrameCount, format, mFormat,
1802                audio_is_linear_pcm(format),
1803                channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
1804        *flags &= ~IAudioFlinger::TRACK_FAST;
1805      }
1806    }
1807    // For normal PCM streaming tracks, update minimum frame count.
1808    // For compatibility with AudioTrack calculation, buffer depth is forced
1809    // to be at least 2 x the normal mixer frame count and cover audio hardware latency.
1810    // This is probably too conservative, but legacy application code may depend on it.
1811    // If you change this calculation, also review the start threshold which is related.
1812    if (!(*flags & IAudioFlinger::TRACK_FAST)
1813            && audio_has_proportional_frames(format) && sharedBuffer == 0) {
1814        // this must match AudioTrack.cpp calculateMinFrameCount().
1815        // TODO: Move to a common library
1816        uint32_t latencyMs = mOutput->stream->get_latency(mOutput->stream);
1817        uint32_t minBufCount = latencyMs / ((1000 * mNormalFrameCount) / mSampleRate);
1818        if (minBufCount < 2) {
1819            minBufCount = 2;
1820        }
1821        // For normal mixing tracks, if speed is > 1.0f (normal), AudioTrack
1822        // or the client should compute and pass in a larger buffer request.
1823        size_t minFrameCount =
1824                minBufCount * sourceFramesNeededWithTimestretch(
1825                        sampleRate, mNormalFrameCount,
1826                        mSampleRate, AUDIO_TIMESTRETCH_SPEED_NORMAL /*speed*/);
1827        if (frameCount < minFrameCount) { // including frameCount == 0
1828            frameCount = minFrameCount;
1829        }
1830    }
1831    *pFrameCount = frameCount;
1832
1833    switch (mType) {
1834
1835    case DIRECT:
1836        if (audio_is_linear_pcm(format)) { // TODO maybe use audio_has_proportional_frames()?
1837            if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
1838                ALOGE("createTrack_l() Bad parameter: sampleRate %u format %#x, channelMask 0x%08x "
1839                        "for output %p with format %#x",
1840                        sampleRate, format, channelMask, mOutput, mFormat);
1841                lStatus = BAD_VALUE;
1842                goto Exit;
1843            }
1844        }
1845        break;
1846
1847    case OFFLOAD:
1848        if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
1849            ALOGE("createTrack_l() Bad parameter: sampleRate %d format %#x, channelMask 0x%08x \""
1850                    "for output %p with format %#x",
1851                    sampleRate, format, channelMask, mOutput, mFormat);
1852            lStatus = BAD_VALUE;
1853            goto Exit;
1854        }
1855        break;
1856
1857    default:
1858        if (!audio_is_linear_pcm(format)) {
1859                ALOGE("createTrack_l() Bad parameter: format %#x \""
1860                        "for output %p with format %#x",
1861                        format, mOutput, mFormat);
1862                lStatus = BAD_VALUE;
1863                goto Exit;
1864        }
1865        if (sampleRate > mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
1866            ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
1867            lStatus = BAD_VALUE;
1868            goto Exit;
1869        }
1870        break;
1871
1872    }
1873
1874    lStatus = initCheck();
1875    if (lStatus != NO_ERROR) {
1876        ALOGE("createTrack_l() audio driver not initialized");
1877        goto Exit;
1878    }
1879
1880    { // scope for mLock
1881        Mutex::Autolock _l(mLock);
1882
1883        // all tracks in same audio session must share the same routing strategy otherwise
1884        // conflicts will happen when tracks are moved from one output to another by audio policy
1885        // manager
1886        uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
1887        for (size_t i = 0; i < mTracks.size(); ++i) {
1888            sp<Track> t = mTracks[i];
1889            if (t != 0 && t->isExternalTrack()) {
1890                uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
1891                if (sessionId == t->sessionId() && strategy != actual) {
1892                    ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
1893                            strategy, actual);
1894                    lStatus = BAD_VALUE;
1895                    goto Exit;
1896                }
1897            }
1898        }
1899
1900        track = new Track(this, client, streamType, sampleRate, format,
1901                          channelMask, frameCount, NULL, sharedBuffer,
1902                          sessionId, uid, *flags, TrackBase::TYPE_DEFAULT);
1903
1904        lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
1905        if (lStatus != NO_ERROR) {
1906            ALOGE("createTrack_l() initCheck failed %d; no control block?", lStatus);
1907            // track must be cleared from the caller as the caller has the AF lock
1908            goto Exit;
1909        }
1910        mTracks.add(track);
1911
1912        sp<EffectChain> chain = getEffectChain_l(sessionId);
1913        if (chain != 0) {
1914            ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
1915            track->setMainBuffer(chain->inBuffer());
1916            chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
1917            chain->incTrackCnt();
1918        }
1919
1920        if ((*flags & IAudioFlinger::TRACK_FAST) && (tid != -1)) {
1921            pid_t callingPid = IPCThreadState::self()->getCallingPid();
1922            // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
1923            // so ask activity manager to do this on our behalf
1924            sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp);
1925        }
1926    }
1927
1928    lStatus = NO_ERROR;
1929
1930Exit:
1931    *status = lStatus;
1932    return track;
1933}
1934
1935uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
1936{
1937    return latency;
1938}
1939
1940uint32_t AudioFlinger::PlaybackThread::latency() const
1941{
1942    Mutex::Autolock _l(mLock);
1943    return latency_l();
1944}
1945uint32_t AudioFlinger::PlaybackThread::latency_l() const
1946{
1947    if (initCheck() == NO_ERROR) {
1948        return correctLatency_l(mOutput->stream->get_latency(mOutput->stream));
1949    } else {
1950        return 0;
1951    }
1952}
1953
1954void AudioFlinger::PlaybackThread::setMasterVolume(float value)
1955{
1956    Mutex::Autolock _l(mLock);
1957    // Don't apply master volume in SW if our HAL can do it for us.
1958    if (mOutput && mOutput->audioHwDev &&
1959        mOutput->audioHwDev->canSetMasterVolume()) {
1960        mMasterVolume = 1.0;
1961    } else {
1962        mMasterVolume = value;
1963    }
1964}
1965
1966void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
1967{
1968    Mutex::Autolock _l(mLock);
1969    // Don't apply master mute in SW if our HAL can do it for us.
1970    if (mOutput && mOutput->audioHwDev &&
1971        mOutput->audioHwDev->canSetMasterMute()) {
1972        mMasterMute = false;
1973    } else {
1974        mMasterMute = muted;
1975    }
1976}
1977
1978void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
1979{
1980    Mutex::Autolock _l(mLock);
1981    mStreamTypes[stream].volume = value;
1982    broadcast_l();
1983}
1984
1985void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
1986{
1987    Mutex::Autolock _l(mLock);
1988    mStreamTypes[stream].mute = muted;
1989    broadcast_l();
1990}
1991
1992float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
1993{
1994    Mutex::Autolock _l(mLock);
1995    return mStreamTypes[stream].volume;
1996}
1997
1998// addTrack_l() must be called with ThreadBase::mLock held
1999status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
2000{
2001    status_t status = ALREADY_EXISTS;
2002
2003    if (mActiveTracks.indexOf(track) < 0) {
2004        // the track is newly added, make sure it fills up all its
2005        // buffers before playing. This is to ensure the client will
2006        // effectively get the latency it requested.
2007        if (track->isExternalTrack()) {
2008            TrackBase::track_state state = track->mState;
2009            mLock.unlock();
2010            status = AudioSystem::startOutput(mId, track->streamType(),
2011                                              track->sessionId());
2012            mLock.lock();
2013            // abort track was stopped/paused while we released the lock
2014            if (state != track->mState) {
2015                if (status == NO_ERROR) {
2016                    mLock.unlock();
2017                    AudioSystem::stopOutput(mId, track->streamType(),
2018                                            track->sessionId());
2019                    mLock.lock();
2020                }
2021                return INVALID_OPERATION;
2022            }
2023            // abort if start is rejected by audio policy manager
2024            if (status != NO_ERROR) {
2025                return PERMISSION_DENIED;
2026            }
2027#ifdef ADD_BATTERY_DATA
2028            // to track the speaker usage
2029            addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
2030#endif
2031        }
2032
2033        // set retry count for buffer fill
2034        if (track->isOffloaded()) {
2035            if (track->isStopping_1()) {
2036                track->mRetryCount = kMaxTrackStopRetriesOffload;
2037            } else {
2038                track->mRetryCount = kMaxTrackStartupRetriesOffload;
2039            }
2040            track->mFillingUpStatus = mStandby ? Track::FS_FILLING : Track::FS_FILLED;
2041        } else {
2042            track->mRetryCount = kMaxTrackStartupRetries;
2043            track->mFillingUpStatus =
2044                    track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
2045        }
2046
2047        track->mResetDone = false;
2048        track->mPresentationCompleteFrames = 0;
2049        mActiveTracks.add(track);
2050        mWakeLockUids.add(track->uid());
2051        mActiveTracksGeneration++;
2052        mLatestActiveTrack = track;
2053        sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2054        if (chain != 0) {
2055            ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
2056                    track->sessionId());
2057            chain->incActiveTrackCnt();
2058        }
2059
2060        status = NO_ERROR;
2061    }
2062
2063    onAddNewTrack_l();
2064    return status;
2065}
2066
2067bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
2068{
2069    track->terminate();
2070    // active tracks are removed by threadLoop()
2071    bool trackActive = (mActiveTracks.indexOf(track) >= 0);
2072    track->mState = TrackBase::STOPPED;
2073    if (!trackActive) {
2074        removeTrack_l(track);
2075    } else if (track->isFastTrack() || track->isOffloaded() || track->isDirect()) {
2076        track->mState = TrackBase::STOPPING_1;
2077    }
2078
2079    return trackActive;
2080}
2081
2082void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
2083{
2084    track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
2085    mTracks.remove(track);
2086    deleteTrackName_l(track->name());
2087    // redundant as track is about to be destroyed, for dumpsys only
2088    track->mName = -1;
2089    if (track->isFastTrack()) {
2090        int index = track->mFastIndex;
2091        ALOG_ASSERT(0 < index && index < (int)FastMixerState::sMaxFastTracks);
2092        ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
2093        mFastTrackAvailMask |= 1 << index;
2094        // redundant as track is about to be destroyed, for dumpsys only
2095        track->mFastIndex = -1;
2096    }
2097    sp<EffectChain> chain = getEffectChain_l(track->sessionId());
2098    if (chain != 0) {
2099        chain->decTrackCnt();
2100    }
2101}
2102
2103void AudioFlinger::PlaybackThread::broadcast_l()
2104{
2105    // Thread could be blocked waiting for async
2106    // so signal it to handle state changes immediately
2107    // If threadLoop is currently unlocked a signal of mWaitWorkCV will
2108    // be lost so we also flag to prevent it blocking on mWaitWorkCV
2109    mSignalPending = true;
2110    mWaitWorkCV.broadcast();
2111}
2112
2113String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
2114{
2115    Mutex::Autolock _l(mLock);
2116    if (initCheck() != NO_ERROR) {
2117        return String8();
2118    }
2119
2120    char *s = mOutput->stream->common.get_parameters(&mOutput->stream->common, keys.string());
2121    const String8 out_s8(s);
2122    free(s);
2123    return out_s8;
2124}
2125
2126void AudioFlinger::PlaybackThread::ioConfigChanged(audio_io_config_event event, pid_t pid) {
2127    sp<AudioIoDescriptor> desc = new AudioIoDescriptor();
2128    ALOGV("PlaybackThread::ioConfigChanged, thread %p, event %d", this, event);
2129
2130    desc->mIoHandle = mId;
2131
2132    switch (event) {
2133    case AUDIO_OUTPUT_OPENED:
2134    case AUDIO_OUTPUT_CONFIG_CHANGED:
2135        desc->mPatch = mPatch;
2136        desc->mChannelMask = mChannelMask;
2137        desc->mSamplingRate = mSampleRate;
2138        desc->mFormat = mFormat;
2139        desc->mFrameCount = mNormalFrameCount; // FIXME see
2140                                             // AudioFlinger::frameCount(audio_io_handle_t)
2141        desc->mFrameCountHAL = mFrameCount;
2142        desc->mLatency = latency_l();
2143        break;
2144
2145    case AUDIO_OUTPUT_CLOSED:
2146    default:
2147        break;
2148    }
2149    mAudioFlinger->ioConfigChanged(event, desc, pid);
2150}
2151
2152void AudioFlinger::PlaybackThread::writeCallback()
2153{
2154    ALOG_ASSERT(mCallbackThread != 0);
2155    mCallbackThread->resetWriteBlocked();
2156}
2157
2158void AudioFlinger::PlaybackThread::drainCallback()
2159{
2160    ALOG_ASSERT(mCallbackThread != 0);
2161    mCallbackThread->resetDraining();
2162}
2163
2164void AudioFlinger::PlaybackThread::resetWriteBlocked(uint32_t sequence)
2165{
2166    Mutex::Autolock _l(mLock);
2167    // reject out of sequence requests
2168    if ((mWriteAckSequence & 1) && (sequence == mWriteAckSequence)) {
2169        mWriteAckSequence &= ~1;
2170        mWaitWorkCV.signal();
2171    }
2172}
2173
2174void AudioFlinger::PlaybackThread::resetDraining(uint32_t sequence)
2175{
2176    Mutex::Autolock _l(mLock);
2177    // reject out of sequence requests
2178    if ((mDrainSequence & 1) && (sequence == mDrainSequence)) {
2179        mDrainSequence &= ~1;
2180        mWaitWorkCV.signal();
2181    }
2182}
2183
2184// static
2185int AudioFlinger::PlaybackThread::asyncCallback(stream_callback_event_t event,
2186                                                void *param __unused,
2187                                                void *cookie)
2188{
2189    AudioFlinger::PlaybackThread *me = (AudioFlinger::PlaybackThread *)cookie;
2190    ALOGV("asyncCallback() event %d", event);
2191    switch (event) {
2192    case STREAM_CBK_EVENT_WRITE_READY:
2193        me->writeCallback();
2194        break;
2195    case STREAM_CBK_EVENT_DRAIN_READY:
2196        me->drainCallback();
2197        break;
2198    default:
2199        ALOGW("asyncCallback() unknown event %d", event);
2200        break;
2201    }
2202    return 0;
2203}
2204
2205void AudioFlinger::PlaybackThread::readOutputParameters_l()
2206{
2207    // unfortunately we have no way of recovering from errors here, hence the LOG_ALWAYS_FATAL
2208    mSampleRate = mOutput->getSampleRate();
2209    mChannelMask = mOutput->getChannelMask();
2210    if (!audio_is_output_channel(mChannelMask)) {
2211        LOG_ALWAYS_FATAL("HAL channel mask %#x not valid for output", mChannelMask);
2212    }
2213    if ((mType == MIXER || mType == DUPLICATING)
2214            && !isValidPcmSinkChannelMask(mChannelMask)) {
2215        LOG_ALWAYS_FATAL("HAL channel mask %#x not supported for mixed output",
2216                mChannelMask);
2217    }
2218    mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
2219
2220    // Get actual HAL format.
2221    mHALFormat = mOutput->stream->common.get_format(&mOutput->stream->common);
2222    // Get format from the shim, which will be different than the HAL format
2223    // if playing compressed audio over HDMI passthrough.
2224    mFormat = mOutput->getFormat();
2225    if (!audio_is_valid_format(mFormat)) {
2226        LOG_ALWAYS_FATAL("HAL format %#x not valid for output", mFormat);
2227    }
2228    if ((mType == MIXER || mType == DUPLICATING)
2229            && !isValidPcmSinkFormat(mFormat)) {
2230        LOG_FATAL("HAL format %#x not supported for mixed output",
2231                mFormat);
2232    }
2233    mFrameSize = mOutput->getFrameSize();
2234    mBufferSize = mOutput->stream->common.get_buffer_size(&mOutput->stream->common);
2235    mFrameCount = mBufferSize / mFrameSize;
2236    if (mFrameCount & 15) {
2237        ALOGW("HAL output buffer size is %zu frames but AudioMixer requires multiples of 16 frames",
2238                mFrameCount);
2239    }
2240
2241    if ((mOutput->flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING) &&
2242            (mOutput->stream->set_callback != NULL)) {
2243        if (mOutput->stream->set_callback(mOutput->stream,
2244                                      AudioFlinger::PlaybackThread::asyncCallback, this) == 0) {
2245            mUseAsyncWrite = true;
2246            mCallbackThread = new AudioFlinger::AsyncCallbackThread(this);
2247        }
2248    }
2249
2250    mHwSupportsPause = false;
2251    if (mOutput->flags & AUDIO_OUTPUT_FLAG_DIRECT) {
2252        if (mOutput->stream->pause != NULL) {
2253            if (mOutput->stream->resume != NULL) {
2254                mHwSupportsPause = true;
2255            } else {
2256                ALOGW("direct output implements pause but not resume");
2257            }
2258        } else if (mOutput->stream->resume != NULL) {
2259            ALOGW("direct output implements resume but not pause");
2260        }
2261    }
2262    if (!mHwSupportsPause && mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC) {
2263        LOG_ALWAYS_FATAL("HW_AV_SYNC requested but HAL does not implement pause and resume");
2264    }
2265
2266    if (mType == DUPLICATING && mMixerBufferEnabled && mEffectBufferEnabled) {
2267        // For best precision, we use float instead of the associated output
2268        // device format (typically PCM 16 bit).
2269
2270        mFormat = AUDIO_FORMAT_PCM_FLOAT;
2271        mFrameSize = mChannelCount * audio_bytes_per_sample(mFormat);
2272        mBufferSize = mFrameSize * mFrameCount;
2273
2274        // TODO: We currently use the associated output device channel mask and sample rate.
2275        // (1) Perhaps use the ORed channel mask of all downstream MixerThreads
2276        // (if a valid mask) to avoid premature downmix.
2277        // (2) Perhaps use the maximum sample rate of all downstream MixerThreads
2278        // instead of the output device sample rate to avoid loss of high frequency information.
2279        // This may need to be updated as MixerThread/OutputTracks are added and not here.
2280    }
2281
2282    // Calculate size of normal sink buffer relative to the HAL output buffer size
2283    double multiplier = 1.0;
2284    if (mType == MIXER && (kUseFastMixer == FastMixer_Static ||
2285            kUseFastMixer == FastMixer_Dynamic)) {
2286        size_t minNormalFrameCount = (kMinNormalSinkBufferSizeMs * mSampleRate) / 1000;
2287        size_t maxNormalFrameCount = (kMaxNormalSinkBufferSizeMs * mSampleRate) / 1000;
2288        // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
2289        minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
2290        maxNormalFrameCount = maxNormalFrameCount & ~15;
2291        if (maxNormalFrameCount < minNormalFrameCount) {
2292            maxNormalFrameCount = minNormalFrameCount;
2293        }
2294        multiplier = (double) minNormalFrameCount / (double) mFrameCount;
2295        if (multiplier <= 1.0) {
2296            multiplier = 1.0;
2297        } else if (multiplier <= 2.0) {
2298            if (2 * mFrameCount <= maxNormalFrameCount) {
2299                multiplier = 2.0;
2300            } else {
2301                multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
2302            }
2303        } else {
2304            // prefer an even multiplier, for compatibility with doubling of fast tracks due to HAL
2305            // SRC (it would be unusual for the normal sink buffer size to not be a multiple of fast
2306            // track, but we sometimes have to do this to satisfy the maximum frame count
2307            // constraint)
2308            // FIXME this rounding up should not be done if no HAL SRC
2309            uint32_t truncMult = (uint32_t) multiplier;
2310            if ((truncMult & 1)) {
2311                if ((truncMult + 1) * mFrameCount <= maxNormalFrameCount) {
2312                    ++truncMult;
2313                }
2314            }
2315            multiplier = (double) truncMult;
2316        }
2317    }
2318    mNormalFrameCount = multiplier * mFrameCount;
2319    // round up to nearest 16 frames to satisfy AudioMixer
2320    if (mType == MIXER || mType == DUPLICATING) {
2321        mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
2322    }
2323    ALOGI("HAL output buffer size %zu frames, normal sink buffer size %zu frames", mFrameCount,
2324            mNormalFrameCount);
2325
2326    // Check if we want to throttle the processing to no more than 2x normal rate
2327    mThreadThrottle = property_get_bool("af.thread.throttle", true /* default_value */);
2328    mThreadThrottleTimeMs = 0;
2329    mThreadThrottleEndMs = 0;
2330    mHalfBufferMs = mNormalFrameCount * 1000 / (2 * mSampleRate);
2331
2332    // mSinkBuffer is the sink buffer.  Size is always multiple-of-16 frames.
2333    // Originally this was int16_t[] array, need to remove legacy implications.
2334    free(mSinkBuffer);
2335    mSinkBuffer = NULL;
2336    // For sink buffer size, we use the frame size from the downstream sink to avoid problems
2337    // with non PCM formats for compressed music, e.g. AAC, and Offload threads.
2338    const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
2339    (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
2340
2341    // We resize the mMixerBuffer according to the requirements of the sink buffer which
2342    // drives the output.
2343    free(mMixerBuffer);
2344    mMixerBuffer = NULL;
2345    if (mMixerBufferEnabled) {
2346        mMixerBufferFormat = AUDIO_FORMAT_PCM_FLOAT; // also valid: AUDIO_FORMAT_PCM_16_BIT.
2347        mMixerBufferSize = mNormalFrameCount * mChannelCount
2348                * audio_bytes_per_sample(mMixerBufferFormat);
2349        (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
2350    }
2351    free(mEffectBuffer);
2352    mEffectBuffer = NULL;
2353    if (mEffectBufferEnabled) {
2354        mEffectBufferFormat = AUDIO_FORMAT_PCM_16_BIT; // Note: Effects support 16b only
2355        mEffectBufferSize = mNormalFrameCount * mChannelCount
2356                * audio_bytes_per_sample(mEffectBufferFormat);
2357        (void)posix_memalign(&mEffectBuffer, 32, mEffectBufferSize);
2358    }
2359
2360    // force reconfiguration of effect chains and engines to take new buffer size and audio
2361    // parameters into account
2362    // Note that mLock is not held when readOutputParameters_l() is called from the constructor
2363    // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
2364    // matter.
2365    // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
2366    Vector< sp<EffectChain> > effectChains = mEffectChains;
2367    for (size_t i = 0; i < effectChains.size(); i ++) {
2368        mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(), this, this, false);
2369    }
2370}
2371
2372
2373status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
2374{
2375    if (halFrames == NULL || dspFrames == NULL) {
2376        return BAD_VALUE;
2377    }
2378    Mutex::Autolock _l(mLock);
2379    if (initCheck() != NO_ERROR) {
2380        return INVALID_OPERATION;
2381    }
2382    int64_t framesWritten = mBytesWritten / mFrameSize;
2383    *halFrames = framesWritten;
2384
2385    if (isSuspended()) {
2386        // return an estimation of rendered frames when the output is suspended
2387        size_t latencyFrames = (latency_l() * mSampleRate) / 1000;
2388        *dspFrames = (uint32_t)
2389                (framesWritten >= (int64_t)latencyFrames ? framesWritten - latencyFrames : 0);
2390        return NO_ERROR;
2391    } else {
2392        status_t status;
2393        uint32_t frames;
2394        status = mOutput->getRenderPosition(&frames);
2395        *dspFrames = (size_t)frames;
2396        return status;
2397    }
2398}
2399
2400uint32_t AudioFlinger::PlaybackThread::hasAudioSession(audio_session_t sessionId) const
2401{
2402    Mutex::Autolock _l(mLock);
2403    uint32_t result = 0;
2404    if (getEffectChain_l(sessionId) != 0) {
2405        result = EFFECT_SESSION;
2406    }
2407
2408    for (size_t i = 0; i < mTracks.size(); ++i) {
2409        sp<Track> track = mTracks[i];
2410        if (sessionId == track->sessionId() && !track->isInvalid()) {
2411            result |= TRACK_SESSION;
2412            break;
2413        }
2414    }
2415
2416    return result;
2417}
2418
2419uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(audio_session_t sessionId)
2420{
2421    // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
2422    // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
2423    if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
2424        return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
2425    }
2426    for (size_t i = 0; i < mTracks.size(); i++) {
2427        sp<Track> track = mTracks[i];
2428        if (sessionId == track->sessionId() && !track->isInvalid()) {
2429            return AudioSystem::getStrategyForStream(track->streamType());
2430        }
2431    }
2432    return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
2433}
2434
2435
2436AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
2437{
2438    Mutex::Autolock _l(mLock);
2439    return mOutput;
2440}
2441
2442AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
2443{
2444    Mutex::Autolock _l(mLock);
2445    AudioStreamOut *output = mOutput;
2446    mOutput = NULL;
2447    // FIXME FastMixer might also have a raw ptr to mOutputSink;
2448    //       must push a NULL and wait for ack
2449    mOutputSink.clear();
2450    mPipeSink.clear();
2451    mNormalSink.clear();
2452    return output;
2453}
2454
2455// this method must always be called either with ThreadBase mLock held or inside the thread loop
2456audio_stream_t* AudioFlinger::PlaybackThread::stream() const
2457{
2458    if (mOutput == NULL) {
2459        return NULL;
2460    }
2461    return &mOutput->stream->common;
2462}
2463
2464uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
2465{
2466    return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
2467}
2468
2469status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
2470{
2471    if (!isValidSyncEvent(event)) {
2472        return BAD_VALUE;
2473    }
2474
2475    Mutex::Autolock _l(mLock);
2476
2477    for (size_t i = 0; i < mTracks.size(); ++i) {
2478        sp<Track> track = mTracks[i];
2479        if (event->triggerSession() == track->sessionId()) {
2480            (void) track->setSyncEvent(event);
2481            return NO_ERROR;
2482        }
2483    }
2484
2485    return NAME_NOT_FOUND;
2486}
2487
2488bool AudioFlinger::PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event) const
2489{
2490    return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
2491}
2492
2493void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
2494        const Vector< sp<Track> >& tracksToRemove)
2495{
2496    size_t count = tracksToRemove.size();
2497    if (count > 0) {
2498        for (size_t i = 0 ; i < count ; i++) {
2499            const sp<Track>& track = tracksToRemove.itemAt(i);
2500            if (track->isExternalTrack()) {
2501                AudioSystem::stopOutput(mId, track->streamType(),
2502                                        track->sessionId());
2503#ifdef ADD_BATTERY_DATA
2504                // to track the speaker usage
2505                addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
2506#endif
2507                if (track->isTerminated()) {
2508                    AudioSystem::releaseOutput(mId, track->streamType(),
2509                                               track->sessionId());
2510                }
2511            }
2512        }
2513    }
2514}
2515
2516void AudioFlinger::PlaybackThread::checkSilentMode_l()
2517{
2518    if (!mMasterMute) {
2519        char value[PROPERTY_VALUE_MAX];
2520        if (mOutDevice == AUDIO_DEVICE_OUT_REMOTE_SUBMIX) {
2521            ALOGD("ro.audio.silent will be ignored for threads on AUDIO_DEVICE_OUT_REMOTE_SUBMIX");
2522            return;
2523        }
2524        if (property_get("ro.audio.silent", value, "0") > 0) {
2525            char *endptr;
2526            unsigned long ul = strtoul(value, &endptr, 0);
2527            if (*endptr == '\0' && ul != 0) {
2528                ALOGD("Silence is golden");
2529                // The setprop command will not allow a property to be changed after
2530                // the first time it is set, so we don't have to worry about un-muting.
2531                setMasterMute_l(true);
2532            }
2533        }
2534    }
2535}
2536
2537// shared by MIXER and DIRECT, overridden by DUPLICATING
2538ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
2539{
2540    mInWrite = true;
2541    ssize_t bytesWritten;
2542    const size_t offset = mCurrentWriteLength - mBytesRemaining;
2543
2544    // If an NBAIO sink is present, use it to write the normal mixer's submix
2545    if (mNormalSink != 0) {
2546
2547        const size_t count = mBytesRemaining / mFrameSize;
2548
2549        ATRACE_BEGIN("write");
2550        // update the setpoint when AudioFlinger::mScreenState changes
2551        uint32_t screenState = AudioFlinger::mScreenState;
2552        if (screenState != mScreenState) {
2553            mScreenState = screenState;
2554            MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
2555            if (pipe != NULL) {
2556                pipe->setAvgFrames((mScreenState & 1) ?
2557                        (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
2558            }
2559        }
2560        ssize_t framesWritten = mNormalSink->write((char *)mSinkBuffer + offset, count);
2561        ATRACE_END();
2562        if (framesWritten > 0) {
2563            bytesWritten = framesWritten * mFrameSize;
2564        } else {
2565            bytesWritten = framesWritten;
2566        }
2567    // otherwise use the HAL / AudioStreamOut directly
2568    } else {
2569        // Direct output and offload threads
2570
2571        if (mUseAsyncWrite) {
2572            ALOGW_IF(mWriteAckSequence & 1, "threadLoop_write(): out of sequence write request");
2573            mWriteAckSequence += 2;
2574            mWriteAckSequence |= 1;
2575            ALOG_ASSERT(mCallbackThread != 0);
2576            mCallbackThread->setWriteBlocked(mWriteAckSequence);
2577        }
2578        // FIXME We should have an implementation of timestamps for direct output threads.
2579        // They are used e.g for multichannel PCM playback over HDMI.
2580        bytesWritten = mOutput->write((char *)mSinkBuffer + offset, mBytesRemaining);
2581
2582        if (mUseAsyncWrite &&
2583                ((bytesWritten < 0) || (bytesWritten == (ssize_t)mBytesRemaining))) {
2584            // do not wait for async callback in case of error of full write
2585            mWriteAckSequence &= ~1;
2586            ALOG_ASSERT(mCallbackThread != 0);
2587            mCallbackThread->setWriteBlocked(mWriteAckSequence);
2588        }
2589    }
2590
2591    mNumWrites++;
2592    mInWrite = false;
2593    mStandby = false;
2594    return bytesWritten;
2595}
2596
2597void AudioFlinger::PlaybackThread::threadLoop_drain()
2598{
2599    if (mOutput->stream->drain) {
2600        ALOGV("draining %s", (mMixerStatus == MIXER_DRAIN_TRACK) ? "early" : "full");
2601        if (mUseAsyncWrite) {
2602            ALOGW_IF(mDrainSequence & 1, "threadLoop_drain(): out of sequence drain request");
2603            mDrainSequence |= 1;
2604            ALOG_ASSERT(mCallbackThread != 0);
2605            mCallbackThread->setDraining(mDrainSequence);
2606        }
2607        mOutput->stream->drain(mOutput->stream,
2608            (mMixerStatus == MIXER_DRAIN_TRACK) ? AUDIO_DRAIN_EARLY_NOTIFY
2609                                                : AUDIO_DRAIN_ALL);
2610    }
2611}
2612
2613void AudioFlinger::PlaybackThread::threadLoop_exit()
2614{
2615    {
2616        Mutex::Autolock _l(mLock);
2617        for (size_t i = 0; i < mTracks.size(); i++) {
2618            sp<Track> track = mTracks[i];
2619            track->invalidate();
2620        }
2621    }
2622}
2623
2624/*
2625The derived values that are cached:
2626 - mSinkBufferSize from frame count * frame size
2627 - mActiveSleepTimeUs from activeSleepTimeUs()
2628 - mIdleSleepTimeUs from idleSleepTimeUs()
2629 - mStandbyDelayNs from mActiveSleepTimeUs (DIRECT only) or forced to at least
2630   kDefaultStandbyTimeInNsecs when connected to an A2DP device.
2631 - maxPeriod from frame count and sample rate (MIXER only)
2632
2633The parameters that affect these derived values are:
2634 - frame count
2635 - frame size
2636 - sample rate
2637 - device type: A2DP or not
2638 - device latency
2639 - format: PCM or not
2640 - active sleep time
2641 - idle sleep time
2642*/
2643
2644void AudioFlinger::PlaybackThread::cacheParameters_l()
2645{
2646    mSinkBufferSize = mNormalFrameCount * mFrameSize;
2647    mActiveSleepTimeUs = activeSleepTimeUs();
2648    mIdleSleepTimeUs = idleSleepTimeUs();
2649
2650    // make sure standby delay is not too short when connected to an A2DP sink to avoid
2651    // truncating audio when going to standby.
2652    mStandbyDelayNs = AudioFlinger::mStandbyTimeInNsecs;
2653    if ((mOutDevice & AUDIO_DEVICE_OUT_ALL_A2DP) != 0) {
2654        if (mStandbyDelayNs < kDefaultStandbyTimeInNsecs) {
2655            mStandbyDelayNs = kDefaultStandbyTimeInNsecs;
2656        }
2657    }
2658}
2659
2660bool AudioFlinger::PlaybackThread::invalidateTracks_l(audio_stream_type_t streamType)
2661{
2662    ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %zu",
2663            this,  streamType, mTracks.size());
2664    bool trackMatch = false;
2665    size_t size = mTracks.size();
2666    for (size_t i = 0; i < size; i++) {
2667        sp<Track> t = mTracks[i];
2668        if (t->streamType() == streamType && t->isExternalTrack()) {
2669            t->invalidate();
2670            trackMatch = true;
2671        }
2672    }
2673    return trackMatch;
2674}
2675
2676void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
2677{
2678    Mutex::Autolock _l(mLock);
2679    invalidateTracks_l(streamType);
2680}
2681
2682status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
2683{
2684    audio_session_t session = chain->sessionId();
2685    int16_t* buffer = reinterpret_cast<int16_t*>(mEffectBufferEnabled
2686            ? mEffectBuffer : mSinkBuffer);
2687    bool ownsBuffer = false;
2688
2689    ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
2690    if (session > AUDIO_SESSION_OUTPUT_MIX) {
2691        // Only one effect chain can be present in direct output thread and it uses
2692        // the sink buffer as input
2693        if (mType != DIRECT) {
2694            size_t numSamples = mNormalFrameCount * mChannelCount;
2695            buffer = new int16_t[numSamples];
2696            memset(buffer, 0, numSamples * sizeof(int16_t));
2697            ALOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session);
2698            ownsBuffer = true;
2699        }
2700
2701        // Attach all tracks with same session ID to this chain.
2702        for (size_t i = 0; i < mTracks.size(); ++i) {
2703            sp<Track> track = mTracks[i];
2704            if (session == track->sessionId()) {
2705                ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(),
2706                        buffer);
2707                track->setMainBuffer(buffer);
2708                chain->incTrackCnt();
2709            }
2710        }
2711
2712        // indicate all active tracks in the chain
2713        for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
2714            sp<Track> track = mActiveTracks[i].promote();
2715            if (track == 0) {
2716                continue;
2717            }
2718            if (session == track->sessionId()) {
2719                ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
2720                chain->incActiveTrackCnt();
2721            }
2722        }
2723    }
2724    chain->setThread(this);
2725    chain->setInBuffer(buffer, ownsBuffer);
2726    chain->setOutBuffer(reinterpret_cast<int16_t*>(mEffectBufferEnabled
2727            ? mEffectBuffer : mSinkBuffer));
2728    // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect
2729    // chains list in order to be processed last as it contains output stage effects.
2730    // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
2731    // session AUDIO_SESSION_OUTPUT_STAGE to be processed
2732    // after track specific effects and before output stage.
2733    // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
2734    // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX.
2735    // Effect chain for other sessions are inserted at beginning of effect
2736    // chains list to be processed before output mix effects. Relative order between other
2737    // sessions is not important.
2738    static_assert(AUDIO_SESSION_OUTPUT_MIX == 0 &&
2739            AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX,
2740            "audio_session_t constants misdefined");
2741    size_t size = mEffectChains.size();
2742    size_t i = 0;
2743    for (i = 0; i < size; i++) {
2744        if (mEffectChains[i]->sessionId() < session) {
2745            break;
2746        }
2747    }
2748    mEffectChains.insertAt(chain, i);
2749    checkSuspendOnAddEffectChain_l(chain);
2750
2751    return NO_ERROR;
2752}
2753
2754size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
2755{
2756    audio_session_t session = chain->sessionId();
2757
2758    ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
2759
2760    for (size_t i = 0; i < mEffectChains.size(); i++) {
2761        if (chain == mEffectChains[i]) {
2762            mEffectChains.removeAt(i);
2763            // detach all active tracks from the chain
2764            for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
2765                sp<Track> track = mActiveTracks[i].promote();
2766                if (track == 0) {
2767                    continue;
2768                }
2769                if (session == track->sessionId()) {
2770                    ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
2771                            chain.get(), session);
2772                    chain->decActiveTrackCnt();
2773                }
2774            }
2775
2776            // detach all tracks with same session ID from this chain
2777            for (size_t i = 0; i < mTracks.size(); ++i) {
2778                sp<Track> track = mTracks[i];
2779                if (session == track->sessionId()) {
2780                    track->setMainBuffer(reinterpret_cast<int16_t*>(mSinkBuffer));
2781                    chain->decTrackCnt();
2782                }
2783            }
2784            break;
2785        }
2786    }
2787    return mEffectChains.size();
2788}
2789
2790status_t AudioFlinger::PlaybackThread::attachAuxEffect(
2791        const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
2792{
2793    Mutex::Autolock _l(mLock);
2794    return attachAuxEffect_l(track, EffectId);
2795}
2796
2797status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
2798        const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
2799{
2800    status_t status = NO_ERROR;
2801
2802    if (EffectId == 0) {
2803        track->setAuxBuffer(0, NULL);
2804    } else {
2805        // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
2806        sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
2807        if (effect != 0) {
2808            if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
2809                track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
2810            } else {
2811                status = INVALID_OPERATION;
2812            }
2813        } else {
2814            status = BAD_VALUE;
2815        }
2816    }
2817    return status;
2818}
2819
2820void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
2821{
2822    for (size_t i = 0; i < mTracks.size(); ++i) {
2823        sp<Track> track = mTracks[i];
2824        if (track->auxEffectId() == effectId) {
2825            attachAuxEffect_l(track, 0);
2826        }
2827    }
2828}
2829
2830bool AudioFlinger::PlaybackThread::threadLoop()
2831{
2832    Vector< sp<Track> > tracksToRemove;
2833
2834    mStandbyTimeNs = systemTime();
2835    nsecs_t lastWriteFinished = -1; // time last server write completed
2836    int64_t lastFramesWritten = -1; // track changes in timestamp server frames written
2837
2838    // MIXER
2839    nsecs_t lastWarning = 0;
2840
2841    // DUPLICATING
2842    // FIXME could this be made local to while loop?
2843    writeFrames = 0;
2844
2845    int lastGeneration = 0;
2846
2847    cacheParameters_l();
2848    mSleepTimeUs = mIdleSleepTimeUs;
2849
2850    if (mType == MIXER) {
2851        sleepTimeShift = 0;
2852    }
2853
2854    CpuStats cpuStats;
2855    const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
2856
2857    acquireWakeLock();
2858
2859    // mNBLogWriter->log can only be called while thread mutex mLock is held.
2860    // So if you need to log when mutex is unlocked, set logString to a non-NULL string,
2861    // and then that string will be logged at the next convenient opportunity.
2862    const char *logString = NULL;
2863
2864    checkSilentMode_l();
2865
2866    while (!exitPending())
2867    {
2868        cpuStats.sample(myName);
2869
2870        Vector< sp<EffectChain> > effectChains;
2871
2872        { // scope for mLock
2873
2874            Mutex::Autolock _l(mLock);
2875
2876            processConfigEvents_l();
2877
2878            if (logString != NULL) {
2879                mNBLogWriter->logTimestamp();
2880                mNBLogWriter->log(logString);
2881                logString = NULL;
2882            }
2883
2884            // Gather the framesReleased counters for all active tracks,
2885            // and associate with the sink frames written out.  We need
2886            // this to convert the sink timestamp to the track timestamp.
2887            bool kernelLocationUpdate = false;
2888            if (mNormalSink != 0) {
2889                // Note: The DuplicatingThread may not have a mNormalSink.
2890                // We always fetch the timestamp here because often the downstream
2891                // sink will block while writing.
2892                ExtendedTimestamp timestamp; // use private copy to fetch
2893                (void) mNormalSink->getTimestamp(timestamp);
2894
2895                // We keep track of the last valid kernel position in case we are in underrun
2896                // and the normal mixer period is the same as the fast mixer period, or there
2897                // is some error from the HAL.
2898                if (mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
2899                    mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
2900                            mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
2901                    mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL_LASTKERNELOK] =
2902                            mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
2903
2904                    mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
2905                            mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER];
2906                    mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER_LASTKERNELOK] =
2907                            mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER];
2908                }
2909
2910                if (timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] >= 0) {
2911                    kernelLocationUpdate = true;
2912                } else {
2913                    ALOGV("getTimestamp error - no valid kernel position");
2914                }
2915
2916                // copy over kernel info
2917                mTimestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL] =
2918                        timestamp.mPosition[ExtendedTimestamp::LOCATION_KERNEL];
2919                mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL] =
2920                        timestamp.mTimeNs[ExtendedTimestamp::LOCATION_KERNEL];
2921            }
2922            // mFramesWritten for non-offloaded tracks are contiguous
2923            // even after standby() is called. This is useful for the track frame
2924            // to sink frame mapping.
2925            bool serverLocationUpdate = false;
2926            if (mFramesWritten != lastFramesWritten) {
2927                serverLocationUpdate = true;
2928                lastFramesWritten = mFramesWritten;
2929            }
2930            // Only update timestamps if there is a meaningful change.
2931            // Either the kernel timestamp must be valid or we have written something.
2932            if (kernelLocationUpdate || serverLocationUpdate) {
2933                if (serverLocationUpdate) {
2934                    // use the time before we called the HAL write - it is a bit more accurate
2935                    // to when the server last read data than the current time here.
2936                    //
2937                    // If we haven't written anything, mLastWriteTime will be -1
2938                    // and we use systemTime().
2939                    mTimestamp.mPosition[ExtendedTimestamp::LOCATION_SERVER] = mFramesWritten;
2940                    mTimestamp.mTimeNs[ExtendedTimestamp::LOCATION_SERVER] = mLastWriteTime == -1
2941                            ? systemTime() : mLastWriteTime;
2942                }
2943                const size_t size = mActiveTracks.size();
2944                for (size_t i = 0; i < size; ++i) {
2945                    sp<Track> t = mActiveTracks[i].promote();
2946                    if (t != 0 && !t->isFastTrack()) {
2947                        t->updateTrackFrameInfo(
2948                                t->mAudioTrackServerProxy->framesReleased(),
2949                                mFramesWritten,
2950                                mTimestamp);
2951                    }
2952                }
2953            }
2954
2955            saveOutputTracks();
2956            if (mSignalPending) {
2957                // A signal was raised while we were unlocked
2958                mSignalPending = false;
2959            } else if (waitingAsyncCallback_l()) {
2960                if (exitPending()) {
2961                    break;
2962                }
2963                bool released = false;
2964                if (!keepWakeLock()) {
2965                    releaseWakeLock_l();
2966                    released = true;
2967                }
2968                mWakeLockUids.clear();
2969                mActiveTracksGeneration++;
2970                ALOGV("wait async completion");
2971                mWaitWorkCV.wait(mLock);
2972                ALOGV("async completion/wake");
2973                if (released) {
2974                    acquireWakeLock_l();
2975                }
2976                mStandbyTimeNs = systemTime() + mStandbyDelayNs;
2977                mSleepTimeUs = 0;
2978
2979                continue;
2980            }
2981            if ((!mActiveTracks.size() && systemTime() > mStandbyTimeNs) ||
2982                                   isSuspended()) {
2983                // put audio hardware into standby after short delay
2984                if (shouldStandby_l()) {
2985
2986                    threadLoop_standby();
2987
2988                    mStandby = true;
2989                }
2990
2991                if (!mActiveTracks.size() && mConfigEvents.isEmpty()) {
2992                    // we're about to wait, flush the binder command buffer
2993                    IPCThreadState::self()->flushCommands();
2994
2995                    clearOutputTracks();
2996
2997                    if (exitPending()) {
2998                        break;
2999                    }
3000
3001                    releaseWakeLock_l();
3002                    mWakeLockUids.clear();
3003                    mActiveTracksGeneration++;
3004                    // wait until we have something to do...
3005                    ALOGV("%s going to sleep", myName.string());
3006                    mWaitWorkCV.wait(mLock);
3007                    ALOGV("%s waking up", myName.string());
3008                    acquireWakeLock_l();
3009
3010                    mMixerStatus = MIXER_IDLE;
3011                    mMixerStatusIgnoringFastTracks = MIXER_IDLE;
3012                    mBytesWritten = 0;
3013                    mBytesRemaining = 0;
3014                    checkSilentMode_l();
3015
3016                    mStandbyTimeNs = systemTime() + mStandbyDelayNs;
3017                    mSleepTimeUs = mIdleSleepTimeUs;
3018                    if (mType == MIXER) {
3019                        sleepTimeShift = 0;
3020                    }
3021
3022                    continue;
3023                }
3024            }
3025            // mMixerStatusIgnoringFastTracks is also updated internally
3026            mMixerStatus = prepareTracks_l(&tracksToRemove);
3027
3028            // compare with previously applied list
3029            if (lastGeneration != mActiveTracksGeneration) {
3030                // update wakelock
3031                updateWakeLockUids_l(mWakeLockUids);
3032                lastGeneration = mActiveTracksGeneration;
3033            }
3034
3035            // prevent any changes in effect chain list and in each effect chain
3036            // during mixing and effect process as the audio buffers could be deleted
3037            // or modified if an effect is created or deleted
3038            lockEffectChains_l(effectChains);
3039        } // mLock scope ends
3040
3041        if (mBytesRemaining == 0) {
3042            mCurrentWriteLength = 0;
3043            if (mMixerStatus == MIXER_TRACKS_READY) {
3044                // threadLoop_mix() sets mCurrentWriteLength
3045                threadLoop_mix();
3046            } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
3047                        && (mMixerStatus != MIXER_DRAIN_ALL)) {
3048                // threadLoop_sleepTime sets mSleepTimeUs to 0 if data
3049                // must be written to HAL
3050                threadLoop_sleepTime();
3051                if (mSleepTimeUs == 0) {
3052                    mCurrentWriteLength = mSinkBufferSize;
3053                }
3054            }
3055            // Either threadLoop_mix() or threadLoop_sleepTime() should have set
3056            // mMixerBuffer with data if mMixerBufferValid is true and mSleepTimeUs == 0.
3057            // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
3058            // or mSinkBuffer (if there are no effects).
3059            //
3060            // This is done pre-effects computation; if effects change to
3061            // support higher precision, this needs to move.
3062            //
3063            // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
3064            // TODO use mSleepTimeUs == 0 as an additional condition.
3065            if (mMixerBufferValid) {
3066                void *buffer = mEffectBufferValid ? mEffectBuffer : mSinkBuffer;
3067                audio_format_t format = mEffectBufferValid ? mEffectBufferFormat : mFormat;
3068
3069                // mono blend occurs for mixer threads only (not direct or offloaded)
3070                // and is handled here if we're going directly to the sink.
3071                if (requireMonoBlend() && !mEffectBufferValid) {
3072                    mono_blend(mMixerBuffer, mMixerBufferFormat, mChannelCount, mNormalFrameCount,
3073                               true /*limit*/);
3074                }
3075
3076                memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
3077                        mNormalFrameCount * mChannelCount);
3078            }
3079
3080            mBytesRemaining = mCurrentWriteLength;
3081            if (isSuspended()) {
3082                mSleepTimeUs = suspendSleepTimeUs();
3083                // simulate write to HAL when suspended
3084                mBytesWritten += mSinkBufferSize;
3085                mFramesWritten += mSinkBufferSize / mFrameSize;
3086                mBytesRemaining = 0;
3087            }
3088
3089            // only process effects if we're going to write
3090            if (mSleepTimeUs == 0 && mType != OFFLOAD) {
3091                for (size_t i = 0; i < effectChains.size(); i ++) {
3092                    effectChains[i]->process_l();
3093                }
3094            }
3095        }
3096        // Process effect chains for offloaded thread even if no audio
3097        // was read from audio track: process only updates effect state
3098        // and thus does have to be synchronized with audio writes but may have
3099        // to be called while waiting for async write callback
3100        if (mType == OFFLOAD) {
3101            for (size_t i = 0; i < effectChains.size(); i ++) {
3102                effectChains[i]->process_l();
3103            }
3104        }
3105
3106        // Only if the Effects buffer is enabled and there is data in the
3107        // Effects buffer (buffer valid), we need to
3108        // copy into the sink buffer.
3109        // TODO use mSleepTimeUs == 0 as an additional condition.
3110        if (mEffectBufferValid) {
3111            //ALOGV("writing effect buffer to sink buffer format %#x", mFormat);
3112
3113            if (requireMonoBlend()) {
3114                mono_blend(mEffectBuffer, mEffectBufferFormat, mChannelCount, mNormalFrameCount,
3115                           true /*limit*/);
3116            }
3117
3118            memcpy_by_audio_format(mSinkBuffer, mFormat, mEffectBuffer, mEffectBufferFormat,
3119                    mNormalFrameCount * mChannelCount);
3120        }
3121
3122        // enable changes in effect chain
3123        unlockEffectChains(effectChains);
3124
3125        if (!waitingAsyncCallback()) {
3126            // mSleepTimeUs == 0 means we must write to audio hardware
3127            if (mSleepTimeUs == 0) {
3128                ssize_t ret = 0;
3129                // We save lastWriteFinished here, as previousLastWriteFinished,
3130                // for throttling. On thread start, previousLastWriteFinished will be
3131                // set to -1, which properly results in no throttling after the first write.
3132                nsecs_t previousLastWriteFinished = lastWriteFinished;
3133                nsecs_t delta = 0;
3134                if (mBytesRemaining) {
3135                    // FIXME rewrite to reduce number of system calls
3136                    mLastWriteTime = systemTime();  // also used for dumpsys
3137                    ret = threadLoop_write();
3138                    lastWriteFinished = systemTime();
3139                    delta = lastWriteFinished - mLastWriteTime;
3140                    if (ret < 0) {
3141                        mBytesRemaining = 0;
3142                    } else {
3143                        mBytesWritten += ret;
3144                        mBytesRemaining -= ret;
3145                        mFramesWritten += ret / mFrameSize;
3146                    }
3147                } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
3148                        (mMixerStatus == MIXER_DRAIN_ALL)) {
3149                    threadLoop_drain();
3150                }
3151                if (mType == MIXER && !mStandby) {
3152                    // write blocked detection
3153                    if (delta > maxPeriod) {
3154                        mNumDelayedWrites++;
3155                        if ((lastWriteFinished - lastWarning) > kWarningThrottleNs) {
3156                            ATRACE_NAME("underrun");
3157                            ALOGW("write blocked for %llu msecs, %d delayed writes, thread %p",
3158                                    (unsigned long long) ns2ms(delta), mNumDelayedWrites, this);
3159                            lastWarning = lastWriteFinished;
3160                        }
3161                    }
3162
3163                    if (mThreadThrottle
3164                            && mMixerStatus == MIXER_TRACKS_READY // we are mixing (active tracks)
3165                            && ret > 0) {                         // we wrote something
3166                        // Limit MixerThread data processing to no more than twice the
3167                        // expected processing rate.
3168                        //
3169                        // This helps prevent underruns with NuPlayer and other applications
3170                        // which may set up buffers that are close to the minimum size, or use
3171                        // deep buffers, and rely on a double-buffering sleep strategy to fill.
3172                        //
3173                        // The throttle smooths out sudden large data drains from the device,
3174                        // e.g. when it comes out of standby, which often causes problems with
3175                        // (1) mixer threads without a fast mixer (which has its own warm-up)
3176                        // (2) minimum buffer sized tracks (even if the track is full,
3177                        //     the app won't fill fast enough to handle the sudden draw).
3178
3179                        // it's OK if deltaMs is an overestimate.
3180                        const int32_t deltaMs =
3181                                (lastWriteFinished - previousLastWriteFinished) / 1000000;
3182                        const int32_t throttleMs = mHalfBufferMs - deltaMs;
3183                        if ((signed)mHalfBufferMs >= throttleMs && throttleMs > 0) {
3184                            usleep(throttleMs * 1000);
3185                            // notify of throttle start on verbose log
3186                            ALOGV_IF(mThreadThrottleEndMs == mThreadThrottleTimeMs,
3187                                    "mixer(%p) throttle begin:"
3188                                    " ret(%zd) deltaMs(%d) requires sleep %d ms",
3189                                    this, ret, deltaMs, throttleMs);
3190                            mThreadThrottleTimeMs += throttleMs;
3191                        } else {
3192                            uint32_t diff = mThreadThrottleTimeMs - mThreadThrottleEndMs;
3193                            if (diff > 0) {
3194                                // notify of throttle end on debug log
3195                                // but prevent spamming for bluetooth
3196                                ALOGD_IF(!audio_is_a2dp_out_device(outDevice()),
3197                                        "mixer(%p) throttle end: throttle time(%u)", this, diff);
3198                                mThreadThrottleEndMs = mThreadThrottleTimeMs;
3199                            }
3200                        }
3201                    }
3202                }
3203
3204            } else {
3205                ATRACE_BEGIN("sleep");
3206                Mutex::Autolock _l(mLock);
3207                if (!mSignalPending && mConfigEvents.isEmpty() && !exitPending()) {
3208                    mWaitWorkCV.waitRelative(mLock, microseconds((nsecs_t)mSleepTimeUs));
3209                }
3210                ATRACE_END();
3211            }
3212        }
3213
3214        // Finally let go of removed track(s), without the lock held
3215        // since we can't guarantee the destructors won't acquire that
3216        // same lock.  This will also mutate and push a new fast mixer state.
3217        threadLoop_removeTracks(tracksToRemove);
3218        tracksToRemove.clear();
3219
3220        // FIXME I don't understand the need for this here;
3221        //       it was in the original code but maybe the
3222        //       assignment in saveOutputTracks() makes this unnecessary?
3223        clearOutputTracks();
3224
3225        // Effect chains will be actually deleted here if they were removed from
3226        // mEffectChains list during mixing or effects processing
3227        effectChains.clear();
3228
3229        // FIXME Note that the above .clear() is no longer necessary since effectChains
3230        // is now local to this block, but will keep it for now (at least until merge done).
3231    }
3232
3233    threadLoop_exit();
3234
3235    if (!mStandby) {
3236        threadLoop_standby();
3237        mStandby = true;
3238    }
3239
3240    releaseWakeLock();
3241    mWakeLockUids.clear();
3242    mActiveTracksGeneration++;
3243
3244    ALOGV("Thread %p type %d exiting", this, mType);
3245    return false;
3246}
3247
3248// removeTracks_l() must be called with ThreadBase::mLock held
3249void AudioFlinger::PlaybackThread::removeTracks_l(const Vector< sp<Track> >& tracksToRemove)
3250{
3251    size_t count = tracksToRemove.size();
3252    if (count > 0) {
3253        for (size_t i=0 ; i<count ; i++) {
3254            const sp<Track>& track = tracksToRemove.itemAt(i);
3255            mActiveTracks.remove(track);
3256            mWakeLockUids.remove(track->uid());
3257            mActiveTracksGeneration++;
3258            ALOGV("removeTracks_l removing track on session %d", track->sessionId());
3259            sp<EffectChain> chain = getEffectChain_l(track->sessionId());
3260            if (chain != 0) {
3261                ALOGV("stopping track on chain %p for session Id: %d", chain.get(),
3262                        track->sessionId());
3263                chain->decActiveTrackCnt();
3264            }
3265            if (track->isTerminated()) {
3266                removeTrack_l(track);
3267            }
3268        }
3269    }
3270
3271}
3272
3273status_t AudioFlinger::PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
3274{
3275    if (mNormalSink != 0) {
3276        ExtendedTimestamp ets;
3277        status_t status = mNormalSink->getTimestamp(ets);
3278        if (status == NO_ERROR) {
3279            status = ets.getBestTimestamp(&timestamp);
3280        }
3281        return status;
3282    }
3283    if ((mType == OFFLOAD || mType == DIRECT)
3284            && mOutput != NULL && mOutput->stream->get_presentation_position) {
3285        uint64_t position64;
3286        int ret = mOutput->getPresentationPosition(&position64, &timestamp.mTime);
3287        if (ret == 0) {
3288            timestamp.mPosition = (uint32_t)position64;
3289            return NO_ERROR;
3290        }
3291    }
3292    return INVALID_OPERATION;
3293}
3294
3295status_t AudioFlinger::MixerThread::createAudioPatch_l(const struct audio_patch *patch,
3296                                                          audio_patch_handle_t *handle)
3297{
3298    AutoPark<FastMixer> park(mFastMixer);
3299
3300    status_t status = PlaybackThread::createAudioPatch_l(patch, handle);
3301
3302    return status;
3303}
3304
3305status_t AudioFlinger::PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
3306                                                          audio_patch_handle_t *handle)
3307{
3308    status_t status = NO_ERROR;
3309
3310    // store new device and send to effects
3311    audio_devices_t type = AUDIO_DEVICE_NONE;
3312    for (unsigned int i = 0; i < patch->num_sinks; i++) {
3313        type |= patch->sinks[i].ext.device.type;
3314    }
3315
3316#ifdef ADD_BATTERY_DATA
3317    // when changing the audio output device, call addBatteryData to notify
3318    // the change
3319    if (mOutDevice != type) {
3320        uint32_t params = 0;
3321        // check whether speaker is on
3322        if (type & AUDIO_DEVICE_OUT_SPEAKER) {
3323            params |= IMediaPlayerService::kBatteryDataSpeakerOn;
3324        }
3325
3326        audio_devices_t deviceWithoutSpeaker
3327            = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER;
3328        // check if any other device (except speaker) is on
3329        if (type & deviceWithoutSpeaker) {
3330            params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
3331        }
3332
3333        if (params != 0) {
3334            addBatteryData(params);
3335        }
3336    }
3337#endif
3338
3339    for (size_t i = 0; i < mEffectChains.size(); i++) {
3340        mEffectChains[i]->setDevice_l(type);
3341    }
3342
3343    // mPrevOutDevice is the latest device set by createAudioPatch_l(). It is not set when
3344    // the thread is created so that the first patch creation triggers an ioConfigChanged callback
3345    bool configChanged = mPrevOutDevice != type;
3346    mOutDevice = type;
3347    mPatch = *patch;
3348
3349    if (mOutput->audioHwDev->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
3350        audio_hw_device_t *hwDevice = mOutput->audioHwDev->hwDevice();
3351        status = hwDevice->create_audio_patch(hwDevice,
3352                                               patch->num_sources,
3353                                               patch->sources,
3354                                               patch->num_sinks,
3355                                               patch->sinks,
3356                                               handle);
3357    } else {
3358        char *address;
3359        if (strcmp(patch->sinks[0].ext.device.address, "") != 0) {
3360            //FIXME: we only support address on first sink with HAL version < 3.0
3361            address = audio_device_address_to_parameter(
3362                                                        patch->sinks[0].ext.device.type,
3363                                                        patch->sinks[0].ext.device.address);
3364        } else {
3365            address = (char *)calloc(1, 1);
3366        }
3367        AudioParameter param = AudioParameter(String8(address));
3368        free(address);
3369        param.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), (int)type);
3370        status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
3371                param.toString().string());
3372        *handle = AUDIO_PATCH_HANDLE_NONE;
3373    }
3374    if (configChanged) {
3375        mPrevOutDevice = type;
3376        sendIoConfigEvent_l(AUDIO_OUTPUT_CONFIG_CHANGED);
3377    }
3378    return status;
3379}
3380
3381status_t AudioFlinger::MixerThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
3382{
3383    AutoPark<FastMixer> park(mFastMixer);
3384
3385    status_t status = PlaybackThread::releaseAudioPatch_l(handle);
3386
3387    return status;
3388}
3389
3390status_t AudioFlinger::PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
3391{
3392    status_t status = NO_ERROR;
3393
3394    mOutDevice = AUDIO_DEVICE_NONE;
3395
3396    if (mOutput->audioHwDev->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
3397        audio_hw_device_t *hwDevice = mOutput->audioHwDev->hwDevice();
3398        status = hwDevice->release_audio_patch(hwDevice, handle);
3399    } else {
3400        AudioParameter param;
3401        param.addInt(String8(AUDIO_PARAMETER_STREAM_ROUTING), 0);
3402        status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
3403                param.toString().string());
3404    }
3405    return status;
3406}
3407
3408void AudioFlinger::PlaybackThread::addPatchTrack(const sp<PatchTrack>& track)
3409{
3410    Mutex::Autolock _l(mLock);
3411    mTracks.add(track);
3412}
3413
3414void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<PatchTrack>& track)
3415{
3416    Mutex::Autolock _l(mLock);
3417    destroyTrack_l(track);
3418}
3419
3420void AudioFlinger::PlaybackThread::getAudioPortConfig(struct audio_port_config *config)
3421{
3422    ThreadBase::getAudioPortConfig(config);
3423    config->role = AUDIO_PORT_ROLE_SOURCE;
3424    config->ext.mix.hw_module = mOutput->audioHwDev->handle();
3425    config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
3426}
3427
3428// ----------------------------------------------------------------------------
3429
3430AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
3431        audio_io_handle_t id, audio_devices_t device, bool systemReady, type_t type)
3432    :   PlaybackThread(audioFlinger, output, id, device, type, systemReady),
3433        // mAudioMixer below
3434        // mFastMixer below
3435        mFastMixerFutex(0),
3436        mMasterMono(false)
3437        // mOutputSink below
3438        // mPipeSink below
3439        // mNormalSink below
3440{
3441    ALOGV("MixerThread() id=%d device=%#x type=%d", id, device, type);
3442    ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%u, mFormat=%d, mFrameSize=%zu, "
3443            "mFrameCount=%zu, mNormalFrameCount=%zu",
3444            mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
3445            mNormalFrameCount);
3446    mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
3447
3448    if (type == DUPLICATING) {
3449        // The Duplicating thread uses the AudioMixer and delivers data to OutputTracks
3450        // (downstream MixerThreads) in DuplicatingThread::threadLoop_write().
3451        // Do not create or use mFastMixer, mOutputSink, mPipeSink, or mNormalSink.
3452        return;
3453    }
3454    // create an NBAIO sink for the HAL output stream, and negotiate
3455    mOutputSink = new AudioStreamOutSink(output->stream);
3456    size_t numCounterOffers = 0;
3457    const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount, mFormat)};
3458#if !LOG_NDEBUG
3459    ssize_t index =
3460#else
3461    (void)
3462#endif
3463            mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
3464    ALOG_ASSERT(index == 0);
3465
3466    // initialize fast mixer depending on configuration
3467    bool initFastMixer;
3468    switch (kUseFastMixer) {
3469    case FastMixer_Never:
3470        initFastMixer = false;
3471        break;
3472    case FastMixer_Always:
3473        initFastMixer = true;
3474        break;
3475    case FastMixer_Static:
3476    case FastMixer_Dynamic:
3477        initFastMixer = mFrameCount < mNormalFrameCount;
3478        break;
3479    }
3480    if (initFastMixer) {
3481        audio_format_t fastMixerFormat;
3482        if (mMixerBufferEnabled && mEffectBufferEnabled) {
3483            fastMixerFormat = AUDIO_FORMAT_PCM_FLOAT;
3484        } else {
3485            fastMixerFormat = AUDIO_FORMAT_PCM_16_BIT;
3486        }
3487        if (mFormat != fastMixerFormat) {
3488            // change our Sink format to accept our intermediate precision
3489            mFormat = fastMixerFormat;
3490            free(mSinkBuffer);
3491            mFrameSize = mChannelCount * audio_bytes_per_sample(mFormat);
3492            const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
3493            (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
3494        }
3495
3496        // create a MonoPipe to connect our submix to FastMixer
3497        NBAIO_Format format = mOutputSink->format();
3498#ifdef TEE_SINK
3499        NBAIO_Format origformat = format;
3500#endif
3501        // adjust format to match that of the Fast Mixer
3502        ALOGV("format changed from %d to %d", format.mFormat, fastMixerFormat);
3503        format.mFormat = fastMixerFormat;
3504        format.mFrameSize = audio_bytes_per_sample(format.mFormat) * format.mChannelCount;
3505
3506        // This pipe depth compensates for scheduling latency of the normal mixer thread.
3507        // When it wakes up after a maximum latency, it runs a few cycles quickly before
3508        // finally blocking.  Note the pipe implementation rounds up the request to a power of 2.
3509        MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
3510        const NBAIO_Format offers[1] = {format};
3511        size_t numCounterOffers = 0;
3512#if !LOG_NDEBUG || defined(TEE_SINK)
3513