Home | History | Annotate | Download | only in audioflinger
      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 <sys/stat.h>
     27 #include <cutils/properties.h>
     28 #include <media/AudioParameter.h>
     29 #include <media/AudioResamplerPublic.h>
     30 #include <utils/Log.h>
     31 #include <utils/Trace.h>
     32 
     33 #include <private/media/AudioTrackShared.h>
     34 #include <hardware/audio.h>
     35 #include <audio_effects/effect_ns.h>
     36 #include <audio_effects/effect_aec.h>
     37 #include <audio_utils/primitives.h>
     38 #include <audio_utils/format.h>
     39 #include <audio_utils/minifloat.h>
     40 
     41 // NBAIO implementations
     42 #include <media/nbaio/AudioStreamInSource.h>
     43 #include <media/nbaio/AudioStreamOutSink.h>
     44 #include <media/nbaio/MonoPipe.h>
     45 #include <media/nbaio/MonoPipeReader.h>
     46 #include <media/nbaio/Pipe.h>
     47 #include <media/nbaio/PipeReader.h>
     48 #include <media/nbaio/SourceAudioBufferProvider.h>
     49 
     50 #include <powermanager/PowerManager.h>
     51 
     52 #include <common_time/cc_helper.h>
     53 #include <common_time/local_clock.h>
     54 
     55 #include "AudioFlinger.h"
     56 #include "AudioMixer.h"
     57 #include "FastMixer.h"
     58 #include "FastCapture.h"
     59 #include "ServiceUtilities.h"
     60 #include "SchedulingPolicyService.h"
     61 
     62 #ifdef ADD_BATTERY_DATA
     63 #include <media/IMediaPlayerService.h>
     64 #include <media/IMediaDeathNotifier.h>
     65 #endif
     66 
     67 #ifdef DEBUG_CPU_USAGE
     68 #include <cpustats/CentralTendencyStatistics.h>
     69 #include <cpustats/ThreadCpuUsage.h>
     70 #endif
     71 
     72 // ----------------------------------------------------------------------------
     73 
     74 // Note: the following macro is used for extremely verbose logging message.  In
     75 // order to run with ALOG_ASSERT turned on, we need to have LOG_NDEBUG set to
     76 // 0; but one side effect of this is to turn all LOGV's as well.  Some messages
     77 // are so verbose that we want to suppress them even when we have ALOG_ASSERT
     78 // turned on.  Do not uncomment the #def below unless you really know what you
     79 // are doing and want to see all of the extremely verbose messages.
     80 //#define VERY_VERY_VERBOSE_LOGGING
     81 #ifdef VERY_VERY_VERBOSE_LOGGING
     82 #define ALOGVV ALOGV
     83 #else
     84 #define ALOGVV(a...) do { } while(0)
     85 #endif
     86 
     87 #define max(a, b) ((a) > (b) ? (a) : (b))
     88 
     89 namespace android {
     90 
     91 // retry counts for buffer fill timeout
     92 // 50 * ~20msecs = 1 second
     93 static const int8_t kMaxTrackRetries = 50;
     94 static const int8_t kMaxTrackStartupRetries = 50;
     95 // allow less retry attempts on direct output thread.
     96 // direct outputs can be a scarce resource in audio hardware and should
     97 // be released as quickly as possible.
     98 static const int8_t kMaxTrackRetriesDirect = 2;
     99 
    100 // don't warn about blocked writes or record buffer overflows more often than this
    101 static const nsecs_t kWarningThrottleNs = seconds(5);
    102 
    103 // RecordThread loop sleep time upon application overrun or audio HAL read error
    104 static const int kRecordThreadSleepUs = 5000;
    105 
    106 // maximum time to wait in sendConfigEvent_l() for a status to be received
    107 static const nsecs_t kConfigEventTimeoutNs = seconds(2);
    108 
    109 // minimum sleep time for the mixer thread loop when tracks are active but in underrun
    110 static const uint32_t kMinThreadSleepTimeUs = 5000;
    111 // maximum divider applied to the active sleep time in the mixer thread loop
    112 static const uint32_t kMaxThreadSleepTimeShift = 2;
    113 
    114 // minimum normal sink buffer size, expressed in milliseconds rather than frames
    115 static const uint32_t kMinNormalSinkBufferSizeMs = 20;
    116 // maximum normal sink buffer size
    117 static const uint32_t kMaxNormalSinkBufferSizeMs = 24;
    118 
    119 // Offloaded output thread standby delay: allows track transition without going to standby
    120 static const nsecs_t kOffloadStandbyDelayNs = seconds(1);
    121 
    122 // Whether to use fast mixer
    123 static const enum {
    124     FastMixer_Never,    // never initialize or use: for debugging only
    125     FastMixer_Always,   // always initialize and use, even if not needed: for debugging only
    126                         // normal mixer multiplier is 1
    127     FastMixer_Static,   // initialize if needed, then use all the time if initialized,
    128                         // multiplier is calculated based on min & max normal mixer buffer size
    129     FastMixer_Dynamic,  // initialize if needed, then use dynamically depending on track load,
    130                         // multiplier is calculated based on min & max normal mixer buffer size
    131     // FIXME for FastMixer_Dynamic:
    132     //  Supporting this option will require fixing HALs that can't handle large writes.
    133     //  For example, one HAL implementation returns an error from a large write,
    134     //  and another HAL implementation corrupts memory, possibly in the sample rate converter.
    135     //  We could either fix the HAL implementations, or provide a wrapper that breaks
    136     //  up large writes into smaller ones, and the wrapper would need to deal with scheduler.
    137 } kUseFastMixer = FastMixer_Static;
    138 
    139 // Whether to use fast capture
    140 static const enum {
    141     FastCapture_Never,  // never initialize or use: for debugging only
    142     FastCapture_Always, // always initialize and use, even if not needed: for debugging only
    143     FastCapture_Static, // initialize if needed, then use all the time if initialized
    144 } kUseFastCapture = FastCapture_Static;
    145 
    146 // Priorities for requestPriority
    147 static const int kPriorityAudioApp = 2;
    148 static const int kPriorityFastMixer = 3;
    149 static const int kPriorityFastCapture = 3;
    150 
    151 // IAudioFlinger::createTrack() reports back to client the total size of shared memory area
    152 // for the track.  The client then sub-divides this into smaller buffers for its use.
    153 // Currently the client uses N-buffering by default, but doesn't tell us about the value of N.
    154 // So for now we just assume that client is double-buffered for fast tracks.
    155 // FIXME It would be better for client to tell AudioFlinger the value of N,
    156 // so AudioFlinger could allocate the right amount of memory.
    157 // See the client's minBufCount and mNotificationFramesAct calculations for details.
    158 
    159 // This is the default value, if not specified by property.
    160 static const int kFastTrackMultiplier = 2;
    161 
    162 // The minimum and maximum allowed values
    163 static const int kFastTrackMultiplierMin = 1;
    164 static const int kFastTrackMultiplierMax = 2;
    165 
    166 // The actual value to use, which can be specified per-device via property af.fast_track_multiplier.
    167 static int sFastTrackMultiplier = kFastTrackMultiplier;
    168 
    169 // See Thread::readOnlyHeap().
    170 // Initially this heap is used to allocate client buffers for "fast" AudioRecord.
    171 // Eventually it will be the single buffer that FastCapture writes into via HAL read(),
    172 // and that all "fast" AudioRecord clients read from.  In either case, the size can be small.
    173 static const size_t kRecordThreadReadOnlyHeapSize = 0x2000;
    174 
    175 // ----------------------------------------------------------------------------
    176 
    177 static pthread_once_t sFastTrackMultiplierOnce = PTHREAD_ONCE_INIT;
    178 
    179 static void sFastTrackMultiplierInit()
    180 {
    181     char value[PROPERTY_VALUE_MAX];
    182     if (property_get("af.fast_track_multiplier", value, NULL) > 0) {
    183         char *endptr;
    184         unsigned long ul = strtoul(value, &endptr, 0);
    185         if (*endptr == '\0' && kFastTrackMultiplierMin <= ul && ul <= kFastTrackMultiplierMax) {
    186             sFastTrackMultiplier = (int) ul;
    187         }
    188     }
    189 }
    190 
    191 // ----------------------------------------------------------------------------
    192 
    193 #ifdef ADD_BATTERY_DATA
    194 // To collect the amplifier usage
    195 static void addBatteryData(uint32_t params) {
    196     sp<IMediaPlayerService> service = IMediaDeathNotifier::getMediaPlayerService();
    197     if (service == NULL) {
    198         // it already logged
    199         return;
    200     }
    201 
    202     service->addBatteryData(params);
    203 }
    204 #endif
    205 
    206 
    207 // ----------------------------------------------------------------------------
    208 //      CPU Stats
    209 // ----------------------------------------------------------------------------
    210 
    211 class CpuStats {
    212 public:
    213     CpuStats();
    214     void sample(const String8 &title);
    215 #ifdef DEBUG_CPU_USAGE
    216 private:
    217     ThreadCpuUsage mCpuUsage;           // instantaneous thread CPU usage in wall clock ns
    218     CentralTendencyStatistics mWcStats; // statistics on thread CPU usage in wall clock ns
    219 
    220     CentralTendencyStatistics mHzStats; // statistics on thread CPU usage in cycles
    221 
    222     int mCpuNum;                        // thread's current CPU number
    223     int mCpukHz;                        // frequency of thread's current CPU in kHz
    224 #endif
    225 };
    226 
    227 CpuStats::CpuStats()
    228 #ifdef DEBUG_CPU_USAGE
    229     : mCpuNum(-1), mCpukHz(-1)
    230 #endif
    231 {
    232 }
    233 
    234 void CpuStats::sample(const String8 &title
    235 #ifndef DEBUG_CPU_USAGE
    236                 __unused
    237 #endif
    238         ) {
    239 #ifdef DEBUG_CPU_USAGE
    240     // get current thread's delta CPU time in wall clock ns
    241     double wcNs;
    242     bool valid = mCpuUsage.sampleAndEnable(wcNs);
    243 
    244     // record sample for wall clock statistics
    245     if (valid) {
    246         mWcStats.sample(wcNs);
    247     }
    248 
    249     // get the current CPU number
    250     int cpuNum = sched_getcpu();
    251 
    252     // get the current CPU frequency in kHz
    253     int cpukHz = mCpuUsage.getCpukHz(cpuNum);
    254 
    255     // check if either CPU number or frequency changed
    256     if (cpuNum != mCpuNum || cpukHz != mCpukHz) {
    257         mCpuNum = cpuNum;
    258         mCpukHz = cpukHz;
    259         // ignore sample for purposes of cycles
    260         valid = false;
    261     }
    262 
    263     // if no change in CPU number or frequency, then record sample for cycle statistics
    264     if (valid && mCpukHz > 0) {
    265         double cycles = wcNs * cpukHz * 0.000001;
    266         mHzStats.sample(cycles);
    267     }
    268 
    269     unsigned n = mWcStats.n();
    270     // mCpuUsage.elapsed() is expensive, so don't call it every loop
    271     if ((n & 127) == 1) {
    272         long long elapsed = mCpuUsage.elapsed();
    273         if (elapsed >= DEBUG_CPU_USAGE * 1000000000LL) {
    274             double perLoop = elapsed / (double) n;
    275             double perLoop100 = perLoop * 0.01;
    276             double perLoop1k = perLoop * 0.001;
    277             double mean = mWcStats.mean();
    278             double stddev = mWcStats.stddev();
    279             double minimum = mWcStats.minimum();
    280             double maximum = mWcStats.maximum();
    281             double meanCycles = mHzStats.mean();
    282             double stddevCycles = mHzStats.stddev();
    283             double minCycles = mHzStats.minimum();
    284             double maxCycles = mHzStats.maximum();
    285             mCpuUsage.resetElapsed();
    286             mWcStats.reset();
    287             mHzStats.reset();
    288             ALOGD("CPU usage for %s over past %.1f secs\n"
    289                 "  (%u mixer loops at %.1f mean ms per loop):\n"
    290                 "  us per mix loop: mean=%.0f stddev=%.0f min=%.0f max=%.0f\n"
    291                 "  %% of wall: mean=%.1f stddev=%.1f min=%.1f max=%.1f\n"
    292                 "  MHz: mean=%.1f, stddev=%.1f, min=%.1f max=%.1f",
    293                     title.string(),
    294                     elapsed * .000000001, n, perLoop * .000001,
    295                     mean * .001,
    296                     stddev * .001,
    297                     minimum * .001,
    298                     maximum * .001,
    299                     mean / perLoop100,
    300                     stddev / perLoop100,
    301                     minimum / perLoop100,
    302                     maximum / perLoop100,
    303                     meanCycles / perLoop1k,
    304                     stddevCycles / perLoop1k,
    305                     minCycles / perLoop1k,
    306                     maxCycles / perLoop1k);
    307 
    308         }
    309     }
    310 #endif
    311 };
    312 
    313 // ----------------------------------------------------------------------------
    314 //      ThreadBase
    315 // ----------------------------------------------------------------------------
    316 
    317 AudioFlinger::ThreadBase::ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
    318         audio_devices_t outDevice, audio_devices_t inDevice, type_t type)
    319     :   Thread(false /*canCallJava*/),
    320         mType(type),
    321         mAudioFlinger(audioFlinger),
    322         // mSampleRate, mFrameCount, mChannelMask, mChannelCount, mFrameSize, mFormat, mBufferSize
    323         // are set by PlaybackThread::readOutputParameters_l() or
    324         // RecordThread::readInputParameters_l()
    325         //FIXME: mStandby should be true here. Is this some kind of hack?
    326         mStandby(false), mOutDevice(outDevice), mInDevice(inDevice),
    327         mAudioSource(AUDIO_SOURCE_DEFAULT), mId(id),
    328         // mName will be set by concrete (non-virtual) subclass
    329         mDeathRecipient(new PMDeathRecipient(this))
    330 {
    331 }
    332 
    333 AudioFlinger::ThreadBase::~ThreadBase()
    334 {
    335     // mConfigEvents should be empty, but just in case it isn't, free the memory it owns
    336     mConfigEvents.clear();
    337 
    338     // do not lock the mutex in destructor
    339     releaseWakeLock_l();
    340     if (mPowerManager != 0) {
    341         sp<IBinder> binder = mPowerManager->asBinder();
    342         binder->unlinkToDeath(mDeathRecipient);
    343     }
    344 }
    345 
    346 status_t AudioFlinger::ThreadBase::readyToRun()
    347 {
    348     status_t status = initCheck();
    349     if (status == NO_ERROR) {
    350         ALOGI("AudioFlinger's thread %p ready to run", this);
    351     } else {
    352         ALOGE("No working audio driver found.");
    353     }
    354     return status;
    355 }
    356 
    357 void AudioFlinger::ThreadBase::exit()
    358 {
    359     ALOGV("ThreadBase::exit");
    360     // do any cleanup required for exit to succeed
    361     preExit();
    362     {
    363         // This lock prevents the following race in thread (uniprocessor for illustration):
    364         //  if (!exitPending()) {
    365         //      // context switch from here to exit()
    366         //      // exit() calls requestExit(), what exitPending() observes
    367         //      // exit() calls signal(), which is dropped since no waiters
    368         //      // context switch back from exit() to here
    369         //      mWaitWorkCV.wait(...);
    370         //      // now thread is hung
    371         //  }
    372         AutoMutex lock(mLock);
    373         requestExit();
    374         mWaitWorkCV.broadcast();
    375     }
    376     // When Thread::requestExitAndWait is made virtual and this method is renamed to
    377     // "virtual status_t requestExitAndWait()", replace by "return Thread::requestExitAndWait();"
    378     requestExitAndWait();
    379 }
    380 
    381 status_t AudioFlinger::ThreadBase::setParameters(const String8& keyValuePairs)
    382 {
    383     status_t status;
    384 
    385     ALOGV("ThreadBase::setParameters() %s", keyValuePairs.string());
    386     Mutex::Autolock _l(mLock);
    387 
    388     return sendSetParameterConfigEvent_l(keyValuePairs);
    389 }
    390 
    391 // sendConfigEvent_l() must be called with ThreadBase::mLock held
    392 // Can temporarily release the lock if waiting for a reply from processConfigEvents_l().
    393 status_t AudioFlinger::ThreadBase::sendConfigEvent_l(sp<ConfigEvent>& event)
    394 {
    395     status_t status = NO_ERROR;
    396 
    397     mConfigEvents.add(event);
    398     ALOGV("sendConfigEvent_l() num events %d event %d", mConfigEvents.size(), event->mType);
    399     mWaitWorkCV.signal();
    400     mLock.unlock();
    401     {
    402         Mutex::Autolock _l(event->mLock);
    403         while (event->mWaitStatus) {
    404             if (event->mCond.waitRelative(event->mLock, kConfigEventTimeoutNs) != NO_ERROR) {
    405                 event->mStatus = TIMED_OUT;
    406                 event->mWaitStatus = false;
    407             }
    408         }
    409         status = event->mStatus;
    410     }
    411     mLock.lock();
    412     return status;
    413 }
    414 
    415 void AudioFlinger::ThreadBase::sendIoConfigEvent(int event, int param)
    416 {
    417     Mutex::Autolock _l(mLock);
    418     sendIoConfigEvent_l(event, param);
    419 }
    420 
    421 // sendIoConfigEvent_l() must be called with ThreadBase::mLock held
    422 void AudioFlinger::ThreadBase::sendIoConfigEvent_l(int event, int param)
    423 {
    424     sp<ConfigEvent> configEvent = (ConfigEvent *)new IoConfigEvent(event, param);
    425     sendConfigEvent_l(configEvent);
    426 }
    427 
    428 // sendPrioConfigEvent_l() must be called with ThreadBase::mLock held
    429 void AudioFlinger::ThreadBase::sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio)
    430 {
    431     sp<ConfigEvent> configEvent = (ConfigEvent *)new PrioConfigEvent(pid, tid, prio);
    432     sendConfigEvent_l(configEvent);
    433 }
    434 
    435 // sendSetParameterConfigEvent_l() must be called with ThreadBase::mLock held
    436 status_t AudioFlinger::ThreadBase::sendSetParameterConfigEvent_l(const String8& keyValuePair)
    437 {
    438     sp<ConfigEvent> configEvent = (ConfigEvent *)new SetParameterConfigEvent(keyValuePair);
    439     return sendConfigEvent_l(configEvent);
    440 }
    441 
    442 status_t AudioFlinger::ThreadBase::sendCreateAudioPatchConfigEvent(
    443                                                         const struct audio_patch *patch,
    444                                                         audio_patch_handle_t *handle)
    445 {
    446     Mutex::Autolock _l(mLock);
    447     sp<ConfigEvent> configEvent = (ConfigEvent *)new CreateAudioPatchConfigEvent(*patch, *handle);
    448     status_t status = sendConfigEvent_l(configEvent);
    449     if (status == NO_ERROR) {
    450         CreateAudioPatchConfigEventData *data =
    451                                         (CreateAudioPatchConfigEventData *)configEvent->mData.get();
    452         *handle = data->mHandle;
    453     }
    454     return status;
    455 }
    456 
    457 status_t AudioFlinger::ThreadBase::sendReleaseAudioPatchConfigEvent(
    458                                                                 const audio_patch_handle_t handle)
    459 {
    460     Mutex::Autolock _l(mLock);
    461     sp<ConfigEvent> configEvent = (ConfigEvent *)new ReleaseAudioPatchConfigEvent(handle);
    462     return sendConfigEvent_l(configEvent);
    463 }
    464 
    465 
    466 // post condition: mConfigEvents.isEmpty()
    467 void AudioFlinger::ThreadBase::processConfigEvents_l()
    468 {
    469     bool configChanged = false;
    470 
    471     while (!mConfigEvents.isEmpty()) {
    472         ALOGV("processConfigEvents_l() remaining events %d", mConfigEvents.size());
    473         sp<ConfigEvent> event = mConfigEvents[0];
    474         mConfigEvents.removeAt(0);
    475         switch (event->mType) {
    476         case CFG_EVENT_PRIO: {
    477             PrioConfigEventData *data = (PrioConfigEventData *)event->mData.get();
    478             // FIXME Need to understand why this has to be done asynchronously
    479             int err = requestPriority(data->mPid, data->mTid, data->mPrio,
    480                     true /*asynchronous*/);
    481             if (err != 0) {
    482                 ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
    483                       data->mPrio, data->mPid, data->mTid, err);
    484             }
    485         } break;
    486         case CFG_EVENT_IO: {
    487             IoConfigEventData *data = (IoConfigEventData *)event->mData.get();
    488             audioConfigChanged(data->mEvent, data->mParam);
    489         } break;
    490         case CFG_EVENT_SET_PARAMETER: {
    491             SetParameterConfigEventData *data = (SetParameterConfigEventData *)event->mData.get();
    492             if (checkForNewParameter_l(data->mKeyValuePairs, event->mStatus)) {
    493                 configChanged = true;
    494             }
    495         } break;
    496         case CFG_EVENT_CREATE_AUDIO_PATCH: {
    497             CreateAudioPatchConfigEventData *data =
    498                                             (CreateAudioPatchConfigEventData *)event->mData.get();
    499             event->mStatus = createAudioPatch_l(&data->mPatch, &data->mHandle);
    500         } break;
    501         case CFG_EVENT_RELEASE_AUDIO_PATCH: {
    502             ReleaseAudioPatchConfigEventData *data =
    503                                             (ReleaseAudioPatchConfigEventData *)event->mData.get();
    504             event->mStatus = releaseAudioPatch_l(data->mHandle);
    505         } break;
    506         default:
    507             ALOG_ASSERT(false, "processConfigEvents_l() unknown event type %d", event->mType);
    508             break;
    509         }
    510         {
    511             Mutex::Autolock _l(event->mLock);
    512             if (event->mWaitStatus) {
    513                 event->mWaitStatus = false;
    514                 event->mCond.signal();
    515             }
    516         }
    517         ALOGV_IF(mConfigEvents.isEmpty(), "processConfigEvents_l() DONE thread %p", this);
    518     }
    519 
    520     if (configChanged) {
    521         cacheParameters_l();
    522     }
    523 }
    524 
    525 String8 channelMaskToString(audio_channel_mask_t mask, bool output) {
    526     String8 s;
    527     if (output) {
    528         if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT) s.append("front-left, ");
    529         if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT) s.append("front-right, ");
    530         if (mask & AUDIO_CHANNEL_OUT_FRONT_CENTER) s.append("front-center, ");
    531         if (mask & AUDIO_CHANNEL_OUT_LOW_FREQUENCY) s.append("low freq, ");
    532         if (mask & AUDIO_CHANNEL_OUT_BACK_LEFT) s.append("back-left, ");
    533         if (mask & AUDIO_CHANNEL_OUT_BACK_RIGHT) s.append("back-right, ");
    534         if (mask & AUDIO_CHANNEL_OUT_FRONT_LEFT_OF_CENTER) s.append("front-left-of-center, ");
    535         if (mask & AUDIO_CHANNEL_OUT_FRONT_RIGHT_OF_CENTER) s.append("front-right-of-center, ");
    536         if (mask & AUDIO_CHANNEL_OUT_BACK_CENTER) s.append("back-center, ");
    537         if (mask & AUDIO_CHANNEL_OUT_SIDE_LEFT) s.append("side-left, ");
    538         if (mask & AUDIO_CHANNEL_OUT_SIDE_RIGHT) s.append("side-right, ");
    539         if (mask & AUDIO_CHANNEL_OUT_TOP_CENTER) s.append("top-center ,");
    540         if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_LEFT) s.append("top-front-left, ");
    541         if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_CENTER) s.append("top-front-center, ");
    542         if (mask & AUDIO_CHANNEL_OUT_TOP_FRONT_RIGHT) s.append("top-front-right, ");
    543         if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_LEFT) s.append("top-back-left, ");
    544         if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_CENTER) s.append("top-back-center, " );
    545         if (mask & AUDIO_CHANNEL_OUT_TOP_BACK_RIGHT) s.append("top-back-right, " );
    546         if (mask & ~AUDIO_CHANNEL_OUT_ALL) s.append("unknown,  ");
    547     } else {
    548         if (mask & AUDIO_CHANNEL_IN_LEFT) s.append("left, ");
    549         if (mask & AUDIO_CHANNEL_IN_RIGHT) s.append("right, ");
    550         if (mask & AUDIO_CHANNEL_IN_FRONT) s.append("front, ");
    551         if (mask & AUDIO_CHANNEL_IN_BACK) s.append("back, ");
    552         if (mask & AUDIO_CHANNEL_IN_LEFT_PROCESSED) s.append("left-processed, ");
    553         if (mask & AUDIO_CHANNEL_IN_RIGHT_PROCESSED) s.append("right-processed, ");
    554         if (mask & AUDIO_CHANNEL_IN_FRONT_PROCESSED) s.append("front-processed, ");
    555         if (mask & AUDIO_CHANNEL_IN_BACK_PROCESSED) s.append("back-processed, ");
    556         if (mask & AUDIO_CHANNEL_IN_PRESSURE) s.append("pressure, ");
    557         if (mask & AUDIO_CHANNEL_IN_X_AXIS) s.append("X, ");
    558         if (mask & AUDIO_CHANNEL_IN_Y_AXIS) s.append("Y, ");
    559         if (mask & AUDIO_CHANNEL_IN_Z_AXIS) s.append("Z, ");
    560         if (mask & AUDIO_CHANNEL_IN_VOICE_UPLINK) s.append("voice-uplink, ");
    561         if (mask & AUDIO_CHANNEL_IN_VOICE_DNLINK) s.append("voice-dnlink, ");
    562         if (mask & ~AUDIO_CHANNEL_IN_ALL) s.append("unknown,  ");
    563     }
    564     int len = s.length();
    565     if (s.length() > 2) {
    566         char *str = s.lockBuffer(len);
    567         s.unlockBuffer(len - 2);
    568     }
    569     return s;
    570 }
    571 
    572 void AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args __unused)
    573 {
    574     const size_t SIZE = 256;
    575     char buffer[SIZE];
    576     String8 result;
    577 
    578     bool locked = AudioFlinger::dumpTryLock(mLock);
    579     if (!locked) {
    580         dprintf(fd, "thread %p maybe dead locked\n", this);
    581     }
    582 
    583     dprintf(fd, "  I/O handle: %d\n", mId);
    584     dprintf(fd, "  TID: %d\n", getTid());
    585     dprintf(fd, "  Standby: %s\n", mStandby ? "yes" : "no");
    586     dprintf(fd, "  Sample rate: %u\n", mSampleRate);
    587     dprintf(fd, "  HAL frame count: %zu\n", mFrameCount);
    588     dprintf(fd, "  HAL buffer size: %u bytes\n", mBufferSize);
    589     dprintf(fd, "  Channel Count: %u\n", mChannelCount);
    590     dprintf(fd, "  Channel Mask: 0x%08x (%s)\n", mChannelMask,
    591             channelMaskToString(mChannelMask, mType != RECORD).string());
    592     dprintf(fd, "  Format: 0x%x (%s)\n", mHALFormat, formatToString(mHALFormat));
    593     dprintf(fd, "  Frame size: %zu\n", mFrameSize);
    594     dprintf(fd, "  Pending config events:");
    595     size_t numConfig = mConfigEvents.size();
    596     if (numConfig) {
    597         for (size_t i = 0; i < numConfig; i++) {
    598             mConfigEvents[i]->dump(buffer, SIZE);
    599             dprintf(fd, "\n    %s", buffer);
    600         }
    601         dprintf(fd, "\n");
    602     } else {
    603         dprintf(fd, " none\n");
    604     }
    605 
    606     if (locked) {
    607         mLock.unlock();
    608     }
    609 }
    610 
    611 void AudioFlinger::ThreadBase::dumpEffectChains(int fd, const Vector<String16>& args)
    612 {
    613     const size_t SIZE = 256;
    614     char buffer[SIZE];
    615     String8 result;
    616 
    617     size_t numEffectChains = mEffectChains.size();
    618     snprintf(buffer, SIZE, "  %zu Effect Chains\n", numEffectChains);
    619     write(fd, buffer, strlen(buffer));
    620 
    621     for (size_t i = 0; i < numEffectChains; ++i) {
    622         sp<EffectChain> chain = mEffectChains[i];
    623         if (chain != 0) {
    624             chain->dump(fd, args);
    625         }
    626     }
    627 }
    628 
    629 void AudioFlinger::ThreadBase::acquireWakeLock(int uid)
    630 {
    631     Mutex::Autolock _l(mLock);
    632     acquireWakeLock_l(uid);
    633 }
    634 
    635 String16 AudioFlinger::ThreadBase::getWakeLockTag()
    636 {
    637     switch (mType) {
    638         case MIXER:
    639             return String16("AudioMix");
    640         case DIRECT:
    641             return String16("AudioDirectOut");
    642         case DUPLICATING:
    643             return String16("AudioDup");
    644         case RECORD:
    645             return String16("AudioIn");
    646         case OFFLOAD:
    647             return String16("AudioOffload");
    648         default:
    649             ALOG_ASSERT(false);
    650             return String16("AudioUnknown");
    651     }
    652 }
    653 
    654 void AudioFlinger::ThreadBase::acquireWakeLock_l(int uid)
    655 {
    656     getPowerManager_l();
    657     if (mPowerManager != 0) {
    658         sp<IBinder> binder = new BBinder();
    659         status_t status;
    660         if (uid >= 0) {
    661             status = mPowerManager->acquireWakeLockWithUid(POWERMANAGER_PARTIAL_WAKE_LOCK,
    662                     binder,
    663                     getWakeLockTag(),
    664                     String16("media"),
    665                     uid,
    666                     true /* FIXME force oneway contrary to .aidl */);
    667         } else {
    668             status = mPowerManager->acquireWakeLock(POWERMANAGER_PARTIAL_WAKE_LOCK,
    669                     binder,
    670                     getWakeLockTag(),
    671                     String16("media"),
    672                     true /* FIXME force oneway contrary to .aidl */);
    673         }
    674         if (status == NO_ERROR) {
    675             mWakeLockToken = binder;
    676         }
    677         ALOGV("acquireWakeLock_l() %s status %d", mName, status);
    678     }
    679 }
    680 
    681 void AudioFlinger::ThreadBase::releaseWakeLock()
    682 {
    683     Mutex::Autolock _l(mLock);
    684     releaseWakeLock_l();
    685 }
    686 
    687 void AudioFlinger::ThreadBase::releaseWakeLock_l()
    688 {
    689     if (mWakeLockToken != 0) {
    690         ALOGV("releaseWakeLock_l() %s", mName);
    691         if (mPowerManager != 0) {
    692             mPowerManager->releaseWakeLock(mWakeLockToken, 0,
    693                     true /* FIXME force oneway contrary to .aidl */);
    694         }
    695         mWakeLockToken.clear();
    696     }
    697 }
    698 
    699 void AudioFlinger::ThreadBase::updateWakeLockUids(const SortedVector<int> &uids) {
    700     Mutex::Autolock _l(mLock);
    701     updateWakeLockUids_l(uids);
    702 }
    703 
    704 void AudioFlinger::ThreadBase::getPowerManager_l() {
    705 
    706     if (mPowerManager == 0) {
    707         // use checkService() to avoid blocking if power service is not up yet
    708         sp<IBinder> binder =
    709             defaultServiceManager()->checkService(String16("power"));
    710         if (binder == 0) {
    711             ALOGW("Thread %s cannot connect to the power manager service", mName);
    712         } else {
    713             mPowerManager = interface_cast<IPowerManager>(binder);
    714             binder->linkToDeath(mDeathRecipient);
    715         }
    716     }
    717 }
    718 
    719 void AudioFlinger::ThreadBase::updateWakeLockUids_l(const SortedVector<int> &uids) {
    720 
    721     getPowerManager_l();
    722     if (mWakeLockToken == NULL) {
    723         ALOGE("no wake lock to update!");
    724         return;
    725     }
    726     if (mPowerManager != 0) {
    727         sp<IBinder> binder = new BBinder();
    728         status_t status;
    729         status = mPowerManager->updateWakeLockUids(mWakeLockToken, uids.size(), uids.array(),
    730                     true /* FIXME force oneway contrary to .aidl */);
    731         ALOGV("acquireWakeLock_l() %s status %d", mName, status);
    732     }
    733 }
    734 
    735 void AudioFlinger::ThreadBase::clearPowerManager()
    736 {
    737     Mutex::Autolock _l(mLock);
    738     releaseWakeLock_l();
    739     mPowerManager.clear();
    740 }
    741 
    742 void AudioFlinger::ThreadBase::PMDeathRecipient::binderDied(const wp<IBinder>& who __unused)
    743 {
    744     sp<ThreadBase> thread = mThread.promote();
    745     if (thread != 0) {
    746         thread->clearPowerManager();
    747     }
    748     ALOGW("power manager service died !!!");
    749 }
    750 
    751 void AudioFlinger::ThreadBase::setEffectSuspended(
    752         const effect_uuid_t *type, bool suspend, int sessionId)
    753 {
    754     Mutex::Autolock _l(mLock);
    755     setEffectSuspended_l(type, suspend, sessionId);
    756 }
    757 
    758 void AudioFlinger::ThreadBase::setEffectSuspended_l(
    759         const effect_uuid_t *type, bool suspend, int sessionId)
    760 {
    761     sp<EffectChain> chain = getEffectChain_l(sessionId);
    762     if (chain != 0) {
    763         if (type != NULL) {
    764             chain->setEffectSuspended_l(type, suspend);
    765         } else {
    766             chain->setEffectSuspendedAll_l(suspend);
    767         }
    768     }
    769 
    770     updateSuspendedSessions_l(type, suspend, sessionId);
    771 }
    772 
    773 void AudioFlinger::ThreadBase::checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain)
    774 {
    775     ssize_t index = mSuspendedSessions.indexOfKey(chain->sessionId());
    776     if (index < 0) {
    777         return;
    778     }
    779 
    780     const KeyedVector <int, sp<SuspendedSessionDesc> >& sessionEffects =
    781             mSuspendedSessions.valueAt(index);
    782 
    783     for (size_t i = 0; i < sessionEffects.size(); i++) {
    784         sp<SuspendedSessionDesc> desc = sessionEffects.valueAt(i);
    785         for (int j = 0; j < desc->mRefCount; j++) {
    786             if (sessionEffects.keyAt(i) == EffectChain::kKeyForSuspendAll) {
    787                 chain->setEffectSuspendedAll_l(true);
    788             } else {
    789                 ALOGV("checkSuspendOnAddEffectChain_l() suspending effects %08x",
    790                     desc->mType.timeLow);
    791                 chain->setEffectSuspended_l(&desc->mType, true);
    792             }
    793         }
    794     }
    795 }
    796 
    797 void AudioFlinger::ThreadBase::updateSuspendedSessions_l(const effect_uuid_t *type,
    798                                                          bool suspend,
    799                                                          int sessionId)
    800 {
    801     ssize_t index = mSuspendedSessions.indexOfKey(sessionId);
    802 
    803     KeyedVector <int, sp<SuspendedSessionDesc> > sessionEffects;
    804 
    805     if (suspend) {
    806         if (index >= 0) {
    807             sessionEffects = mSuspendedSessions.valueAt(index);
    808         } else {
    809             mSuspendedSessions.add(sessionId, sessionEffects);
    810         }
    811     } else {
    812         if (index < 0) {
    813             return;
    814         }
    815         sessionEffects = mSuspendedSessions.valueAt(index);
    816     }
    817 
    818 
    819     int key = EffectChain::kKeyForSuspendAll;
    820     if (type != NULL) {
    821         key = type->timeLow;
    822     }
    823     index = sessionEffects.indexOfKey(key);
    824 
    825     sp<SuspendedSessionDesc> desc;
    826     if (suspend) {
    827         if (index >= 0) {
    828             desc = sessionEffects.valueAt(index);
    829         } else {
    830             desc = new SuspendedSessionDesc();
    831             if (type != NULL) {
    832                 desc->mType = *type;
    833             }
    834             sessionEffects.add(key, desc);
    835             ALOGV("updateSuspendedSessions_l() suspend adding effect %08x", key);
    836         }
    837         desc->mRefCount++;
    838     } else {
    839         if (index < 0) {
    840             return;
    841         }
    842         desc = sessionEffects.valueAt(index);
    843         if (--desc->mRefCount == 0) {
    844             ALOGV("updateSuspendedSessions_l() restore removing effect %08x", key);
    845             sessionEffects.removeItemsAt(index);
    846             if (sessionEffects.isEmpty()) {
    847                 ALOGV("updateSuspendedSessions_l() restore removing session %d",
    848                                  sessionId);
    849                 mSuspendedSessions.removeItem(sessionId);
    850             }
    851         }
    852     }
    853     if (!sessionEffects.isEmpty()) {
    854         mSuspendedSessions.replaceValueFor(sessionId, sessionEffects);
    855     }
    856 }
    857 
    858 void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
    859                                                             bool enabled,
    860                                                             int sessionId)
    861 {
    862     Mutex::Autolock _l(mLock);
    863     checkSuspendOnEffectEnabled_l(effect, enabled, sessionId);
    864 }
    865 
    866 void AudioFlinger::ThreadBase::checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
    867                                                             bool enabled,
    868                                                             int sessionId)
    869 {
    870     if (mType != RECORD) {
    871         // suspend all effects in AUDIO_SESSION_OUTPUT_MIX when enabling any effect on
    872         // another session. This gives the priority to well behaved effect control panels
    873         // and applications not using global effects.
    874         // Enabling post processing in AUDIO_SESSION_OUTPUT_STAGE session does not affect
    875         // global effects
    876         if ((sessionId != AUDIO_SESSION_OUTPUT_MIX) && (sessionId != AUDIO_SESSION_OUTPUT_STAGE)) {
    877             setEffectSuspended_l(NULL, enabled, AUDIO_SESSION_OUTPUT_MIX);
    878         }
    879     }
    880 
    881     sp<EffectChain> chain = getEffectChain_l(sessionId);
    882     if (chain != 0) {
    883         chain->checkSuspendOnEffectEnabled(effect, enabled);
    884     }
    885 }
    886 
    887 // ThreadBase::createEffect_l() must be called with AudioFlinger::mLock held
    888 sp<AudioFlinger::EffectHandle> AudioFlinger::ThreadBase::createEffect_l(
    889         const sp<AudioFlinger::Client>& client,
    890         const sp<IEffectClient>& effectClient,
    891         int32_t priority,
    892         int sessionId,
    893         effect_descriptor_t *desc,
    894         int *enabled,
    895         status_t *status)
    896 {
    897     sp<EffectModule> effect;
    898     sp<EffectHandle> handle;
    899     status_t lStatus;
    900     sp<EffectChain> chain;
    901     bool chainCreated = false;
    902     bool effectCreated = false;
    903     bool effectRegistered = false;
    904 
    905     lStatus = initCheck();
    906     if (lStatus != NO_ERROR) {
    907         ALOGW("createEffect_l() Audio driver not initialized.");
    908         goto Exit;
    909     }
    910 
    911     // Reject any effect on Direct output threads for now, since the format of
    912     // mSinkBuffer is not guaranteed to be compatible with effect processing (PCM 16 stereo).
    913     if (mType == DIRECT) {
    914         ALOGW("createEffect_l() Cannot add effect %s on Direct output type thread %s",
    915                 desc->name, mName);
    916         lStatus = BAD_VALUE;
    917         goto Exit;
    918     }
    919 
    920     // Reject any effect on mixer or duplicating multichannel sinks.
    921     // TODO: fix both format and multichannel issues with effects.
    922     if ((mType == MIXER || mType == DUPLICATING) && mChannelCount != FCC_2) {
    923         ALOGW("createEffect_l() Cannot add effect %s for multichannel(%d) %s threads",
    924                 desc->name, mChannelCount, mType == MIXER ? "MIXER" : "DUPLICATING");
    925         lStatus = BAD_VALUE;
    926         goto Exit;
    927     }
    928 
    929     // Allow global effects only on offloaded and mixer threads
    930     if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
    931         switch (mType) {
    932         case MIXER:
    933         case OFFLOAD:
    934             break;
    935         case DIRECT:
    936         case DUPLICATING:
    937         case RECORD:
    938         default:
    939             ALOGW("createEffect_l() Cannot add global effect %s on thread %s", desc->name, mName);
    940             lStatus = BAD_VALUE;
    941             goto Exit;
    942         }
    943     }
    944 
    945     // Only Pre processor effects are allowed on input threads and only on input threads
    946     if ((mType == RECORD) != ((desc->flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_PRE_PROC)) {
    947         ALOGW("createEffect_l() effect %s (flags %08x) created on wrong thread type %d",
    948                 desc->name, desc->flags, mType);
    949         lStatus = BAD_VALUE;
    950         goto Exit;
    951     }
    952 
    953     ALOGV("createEffect_l() thread %p effect %s on session %d", this, desc->name, sessionId);
    954 
    955     { // scope for mLock
    956         Mutex::Autolock _l(mLock);
    957 
    958         // check for existing effect chain with the requested audio session
    959         chain = getEffectChain_l(sessionId);
    960         if (chain == 0) {
    961             // create a new chain for this session
    962             ALOGV("createEffect_l() new effect chain for session %d", sessionId);
    963             chain = new EffectChain(this, sessionId);
    964             addEffectChain_l(chain);
    965             chain->setStrategy(getStrategyForSession_l(sessionId));
    966             chainCreated = true;
    967         } else {
    968             effect = chain->getEffectFromDesc_l(desc);
    969         }
    970 
    971         ALOGV("createEffect_l() got effect %p on chain %p", effect.get(), chain.get());
    972 
    973         if (effect == 0) {
    974             int id = mAudioFlinger->nextUniqueId();
    975             // Check CPU and memory usage
    976             lStatus = AudioSystem::registerEffect(desc, mId, chain->strategy(), sessionId, id);
    977             if (lStatus != NO_ERROR) {
    978                 goto Exit;
    979             }
    980             effectRegistered = true;
    981             // create a new effect module if none present in the chain
    982             effect = new EffectModule(this, chain, desc, id, sessionId);
    983             lStatus = effect->status();
    984             if (lStatus != NO_ERROR) {
    985                 goto Exit;
    986             }
    987             effect->setOffloaded(mType == OFFLOAD, mId);
    988 
    989             lStatus = chain->addEffect_l(effect);
    990             if (lStatus != NO_ERROR) {
    991                 goto Exit;
    992             }
    993             effectCreated = true;
    994 
    995             effect->setDevice(mOutDevice);
    996             effect->setDevice(mInDevice);
    997             effect->setMode(mAudioFlinger->getMode());
    998             effect->setAudioSource(mAudioSource);
    999         }
   1000         // create effect handle and connect it to effect module
   1001         handle = new EffectHandle(effect, client, effectClient, priority);
   1002         lStatus = handle->initCheck();
   1003         if (lStatus == OK) {
   1004             lStatus = effect->addHandle(handle.get());
   1005         }
   1006         if (enabled != NULL) {
   1007             *enabled = (int)effect->isEnabled();
   1008         }
   1009     }
   1010 
   1011 Exit:
   1012     if (lStatus != NO_ERROR && lStatus != ALREADY_EXISTS) {
   1013         Mutex::Autolock _l(mLock);
   1014         if (effectCreated) {
   1015             chain->removeEffect_l(effect);
   1016         }
   1017         if (effectRegistered) {
   1018             AudioSystem::unregisterEffect(effect->id());
   1019         }
   1020         if (chainCreated) {
   1021             removeEffectChain_l(chain);
   1022         }
   1023         handle.clear();
   1024     }
   1025 
   1026     *status = lStatus;
   1027     return handle;
   1028 }
   1029 
   1030 sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect(int sessionId, int effectId)
   1031 {
   1032     Mutex::Autolock _l(mLock);
   1033     return getEffect_l(sessionId, effectId);
   1034 }
   1035 
   1036 sp<AudioFlinger::EffectModule> AudioFlinger::ThreadBase::getEffect_l(int sessionId, int effectId)
   1037 {
   1038     sp<EffectChain> chain = getEffectChain_l(sessionId);
   1039     return chain != 0 ? chain->getEffectFromId_l(effectId) : 0;
   1040 }
   1041 
   1042 // PlaybackThread::addEffect_l() must be called with AudioFlinger::mLock and
   1043 // PlaybackThread::mLock held
   1044 status_t AudioFlinger::ThreadBase::addEffect_l(const sp<EffectModule>& effect)
   1045 {
   1046     // check for existing effect chain with the requested audio session
   1047     int sessionId = effect->sessionId();
   1048     sp<EffectChain> chain = getEffectChain_l(sessionId);
   1049     bool chainCreated = false;
   1050 
   1051     ALOGD_IF((mType == OFFLOAD) && !effect->isOffloadable(),
   1052              "addEffect_l() on offloaded thread %p: effect %s does not support offload flags %x",
   1053                     this, effect->desc().name, effect->desc().flags);
   1054 
   1055     if (chain == 0) {
   1056         // create a new chain for this session
   1057         ALOGV("addEffect_l() new effect chain for session %d", sessionId);
   1058         chain = new EffectChain(this, sessionId);
   1059         addEffectChain_l(chain);
   1060         chain->setStrategy(getStrategyForSession_l(sessionId));
   1061         chainCreated = true;
   1062     }
   1063     ALOGV("addEffect_l() %p chain %p effect %p", this, chain.get(), effect.get());
   1064 
   1065     if (chain->getEffectFromId_l(effect->id()) != 0) {
   1066         ALOGW("addEffect_l() %p effect %s already present in chain %p",
   1067                 this, effect->desc().name, chain.get());
   1068         return BAD_VALUE;
   1069     }
   1070 
   1071     effect->setOffloaded(mType == OFFLOAD, mId);
   1072 
   1073     status_t status = chain->addEffect_l(effect);
   1074     if (status != NO_ERROR) {
   1075         if (chainCreated) {
   1076             removeEffectChain_l(chain);
   1077         }
   1078         return status;
   1079     }
   1080 
   1081     effect->setDevice(mOutDevice);
   1082     effect->setDevice(mInDevice);
   1083     effect->setMode(mAudioFlinger->getMode());
   1084     effect->setAudioSource(mAudioSource);
   1085     return NO_ERROR;
   1086 }
   1087 
   1088 void AudioFlinger::ThreadBase::removeEffect_l(const sp<EffectModule>& effect) {
   1089 
   1090     ALOGV("removeEffect_l() %p effect %p", this, effect.get());
   1091     effect_descriptor_t desc = effect->desc();
   1092     if ((desc.flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
   1093         detachAuxEffect_l(effect->id());
   1094     }
   1095 
   1096     sp<EffectChain> chain = effect->chain().promote();
   1097     if (chain != 0) {
   1098         // remove effect chain if removing last effect
   1099         if (chain->removeEffect_l(effect) == 0) {
   1100             removeEffectChain_l(chain);
   1101         }
   1102     } else {
   1103         ALOGW("removeEffect_l() %p cannot promote chain for effect %p", this, effect.get());
   1104     }
   1105 }
   1106 
   1107 void AudioFlinger::ThreadBase::lockEffectChains_l(
   1108         Vector< sp<AudioFlinger::EffectChain> >& effectChains)
   1109 {
   1110     effectChains = mEffectChains;
   1111     for (size_t i = 0; i < mEffectChains.size(); i++) {
   1112         mEffectChains[i]->lock();
   1113     }
   1114 }
   1115 
   1116 void AudioFlinger::ThreadBase::unlockEffectChains(
   1117         const Vector< sp<AudioFlinger::EffectChain> >& effectChains)
   1118 {
   1119     for (size_t i = 0; i < effectChains.size(); i++) {
   1120         effectChains[i]->unlock();
   1121     }
   1122 }
   1123 
   1124 sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain(int sessionId)
   1125 {
   1126     Mutex::Autolock _l(mLock);
   1127     return getEffectChain_l(sessionId);
   1128 }
   1129 
   1130 sp<AudioFlinger::EffectChain> AudioFlinger::ThreadBase::getEffectChain_l(int sessionId) const
   1131 {
   1132     size_t size = mEffectChains.size();
   1133     for (size_t i = 0; i < size; i++) {
   1134         if (mEffectChains[i]->sessionId() == sessionId) {
   1135             return mEffectChains[i];
   1136         }
   1137     }
   1138     return 0;
   1139 }
   1140 
   1141 void AudioFlinger::ThreadBase::setMode(audio_mode_t mode)
   1142 {
   1143     Mutex::Autolock _l(mLock);
   1144     size_t size = mEffectChains.size();
   1145     for (size_t i = 0; i < size; i++) {
   1146         mEffectChains[i]->setMode_l(mode);
   1147     }
   1148 }
   1149 
   1150 void AudioFlinger::ThreadBase::getAudioPortConfig(struct audio_port_config *config)
   1151 {
   1152     config->type = AUDIO_PORT_TYPE_MIX;
   1153     config->ext.mix.handle = mId;
   1154     config->sample_rate = mSampleRate;
   1155     config->format = mFormat;
   1156     config->channel_mask = mChannelMask;
   1157     config->config_mask = AUDIO_PORT_CONFIG_SAMPLE_RATE|AUDIO_PORT_CONFIG_CHANNEL_MASK|
   1158                             AUDIO_PORT_CONFIG_FORMAT;
   1159 }
   1160 
   1161 
   1162 // ----------------------------------------------------------------------------
   1163 //      Playback
   1164 // ----------------------------------------------------------------------------
   1165 
   1166 AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger,
   1167                                              AudioStreamOut* output,
   1168                                              audio_io_handle_t id,
   1169                                              audio_devices_t device,
   1170                                              type_t type)
   1171     :   ThreadBase(audioFlinger, id, device, AUDIO_DEVICE_NONE, type),
   1172         mNormalFrameCount(0), mSinkBuffer(NULL),
   1173         mMixerBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
   1174         mMixerBuffer(NULL),
   1175         mMixerBufferSize(0),
   1176         mMixerBufferFormat(AUDIO_FORMAT_INVALID),
   1177         mMixerBufferValid(false),
   1178         mEffectBufferEnabled(AudioFlinger::kEnableExtendedPrecision),
   1179         mEffectBuffer(NULL),
   1180         mEffectBufferSize(0),
   1181         mEffectBufferFormat(AUDIO_FORMAT_INVALID),
   1182         mEffectBufferValid(false),
   1183         mSuspended(0), mBytesWritten(0),
   1184         mActiveTracksGeneration(0),
   1185         // mStreamTypes[] initialized in constructor body
   1186         mOutput(output),
   1187         mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),
   1188         mMixerStatus(MIXER_IDLE),
   1189         mMixerStatusIgnoringFastTracks(MIXER_IDLE),
   1190         standbyDelay(AudioFlinger::mStandbyTimeInNsecs),
   1191         mBytesRemaining(0),
   1192         mCurrentWriteLength(0),
   1193         mUseAsyncWrite(false),
   1194         mWriteAckSequence(0),
   1195         mDrainSequence(0),
   1196         mSignalPending(false),
   1197         mScreenState(AudioFlinger::mScreenState),
   1198         // index 0 is reserved for normal mixer's submix
   1199         mFastTrackAvailMask(((1 << FastMixerState::kMaxFastTracks) - 1) & ~1),
   1200         // mLatchD, mLatchQ,
   1201         mLatchDValid(false), mLatchQValid(false)
   1202 {
   1203     snprintf(mName, kNameLength, "AudioOut_%X", id);
   1204     mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mName);
   1205 
   1206     // Assumes constructor is called by AudioFlinger with it's mLock held, but
   1207     // it would be safer to explicitly pass initial masterVolume/masterMute as
   1208     // parameter.
   1209     //
   1210     // If the HAL we are using has support for master volume or master mute,
   1211     // then do not attenuate or mute during mixing (just leave the volume at 1.0
   1212     // and the mute set to false).
   1213     mMasterVolume = audioFlinger->masterVolume_l();
   1214     mMasterMute = audioFlinger->masterMute_l();
   1215     if (mOutput && mOutput->audioHwDev) {
   1216         if (mOutput->audioHwDev->canSetMasterVolume()) {
   1217             mMasterVolume = 1.0;
   1218         }
   1219 
   1220         if (mOutput->audioHwDev->canSetMasterMute()) {
   1221             mMasterMute = false;
   1222         }
   1223     }
   1224 
   1225     readOutputParameters_l();
   1226 
   1227     // mStreamTypes[AUDIO_STREAM_CNT] is initialized by stream_type_t default constructor
   1228     // There is no AUDIO_STREAM_MIN, and ++ operator does not compile
   1229     for (audio_stream_type_t stream = AUDIO_STREAM_MIN; stream < AUDIO_STREAM_CNT;
   1230             stream = (audio_stream_type_t) (stream + 1)) {
   1231         mStreamTypes[stream].volume = mAudioFlinger->streamVolume_l(stream);
   1232         mStreamTypes[stream].mute = mAudioFlinger->streamMute_l(stream);
   1233     }
   1234     // mStreamTypes[AUDIO_STREAM_CNT] exists but isn't explicitly initialized here,
   1235     // because mAudioFlinger doesn't have one to copy from
   1236 }
   1237 
   1238 AudioFlinger::PlaybackThread::~PlaybackThread()
   1239 {
   1240     mAudioFlinger->unregisterWriter(mNBLogWriter);
   1241     free(mSinkBuffer);
   1242     free(mMixerBuffer);
   1243     free(mEffectBuffer);
   1244 }
   1245 
   1246 void AudioFlinger::PlaybackThread::dump(int fd, const Vector<String16>& args)
   1247 {
   1248     dumpInternals(fd, args);
   1249     dumpTracks(fd, args);
   1250     dumpEffectChains(fd, args);
   1251 }
   1252 
   1253 void AudioFlinger::PlaybackThread::dumpTracks(int fd, const Vector<String16>& args __unused)
   1254 {
   1255     const size_t SIZE = 256;
   1256     char buffer[SIZE];
   1257     String8 result;
   1258 
   1259     result.appendFormat("  Stream volumes in dB: ");
   1260     for (int i = 0; i < AUDIO_STREAM_CNT; ++i) {
   1261         const stream_type_t *st = &mStreamTypes[i];
   1262         if (i > 0) {
   1263             result.appendFormat(", ");
   1264         }
   1265         result.appendFormat("%d:%.2g", i, 20.0 * log10(st->volume));
   1266         if (st->mute) {
   1267             result.append("M");
   1268         }
   1269     }
   1270     result.append("\n");
   1271     write(fd, result.string(), result.length());
   1272     result.clear();
   1273 
   1274     // These values are "raw"; they will wrap around.  See prepareTracks_l() for a better way.
   1275     FastTrackUnderruns underruns = getFastTrackUnderruns(0);
   1276     dprintf(fd, "  Normal mixer raw underrun counters: partial=%u empty=%u\n",
   1277             underruns.mBitFields.mPartial, underruns.mBitFields.mEmpty);
   1278 
   1279     size_t numtracks = mTracks.size();
   1280     size_t numactive = mActiveTracks.size();
   1281     dprintf(fd, "  %d Tracks", numtracks);
   1282     size_t numactiveseen = 0;
   1283     if (numtracks) {
   1284         dprintf(fd, " of which %d are active\n", numactive);
   1285         Track::appendDumpHeader(result);
   1286         for (size_t i = 0; i < numtracks; ++i) {
   1287             sp<Track> track = mTracks[i];
   1288             if (track != 0) {
   1289                 bool active = mActiveTracks.indexOf(track) >= 0;
   1290                 if (active) {
   1291                     numactiveseen++;
   1292                 }
   1293                 track->dump(buffer, SIZE, active);
   1294                 result.append(buffer);
   1295             }
   1296         }
   1297     } else {
   1298         result.append("\n");
   1299     }
   1300     if (numactiveseen != numactive) {
   1301         // some tracks in the active list were not in the tracks list
   1302         snprintf(buffer, SIZE, "  The following tracks are in the active list but"
   1303                 " not in the track list\n");
   1304         result.append(buffer);
   1305         Track::appendDumpHeader(result);
   1306         for (size_t i = 0; i < numactive; ++i) {
   1307             sp<Track> track = mActiveTracks[i].promote();
   1308             if (track != 0 && mTracks.indexOf(track) < 0) {
   1309                 track->dump(buffer, SIZE, true);
   1310                 result.append(buffer);
   1311             }
   1312         }
   1313     }
   1314 
   1315     write(fd, result.string(), result.size());
   1316 }
   1317 
   1318 void AudioFlinger::PlaybackThread::dumpInternals(int fd, const Vector<String16>& args)
   1319 {
   1320     dprintf(fd, "\nOutput thread %p:\n", this);
   1321     dprintf(fd, "  Normal frame count: %zu\n", mNormalFrameCount);
   1322     dprintf(fd, "  Last write occurred (msecs): %llu\n", ns2ms(systemTime() - mLastWriteTime));
   1323     dprintf(fd, "  Total writes: %d\n", mNumWrites);
   1324     dprintf(fd, "  Delayed writes: %d\n", mNumDelayedWrites);
   1325     dprintf(fd, "  Blocked in write: %s\n", mInWrite ? "yes" : "no");
   1326     dprintf(fd, "  Suspend count: %d\n", mSuspended);
   1327     dprintf(fd, "  Sink buffer : %p\n", mSinkBuffer);
   1328     dprintf(fd, "  Mixer buffer: %p\n", mMixerBuffer);
   1329     dprintf(fd, "  Effect buffer: %p\n", mEffectBuffer);
   1330     dprintf(fd, "  Fast track availMask=%#x\n", mFastTrackAvailMask);
   1331 
   1332     dumpBase(fd, args);
   1333 }
   1334 
   1335 // Thread virtuals
   1336 
   1337 void AudioFlinger::PlaybackThread::onFirstRef()
   1338 {
   1339     run(mName, ANDROID_PRIORITY_URGENT_AUDIO);
   1340 }
   1341 
   1342 // ThreadBase virtuals
   1343 void AudioFlinger::PlaybackThread::preExit()
   1344 {
   1345     ALOGV("  preExit()");
   1346     // FIXME this is using hard-coded strings but in the future, this functionality will be
   1347     //       converted to use audio HAL extensions required to support tunneling
   1348     mOutput->stream->common.set_parameters(&mOutput->stream->common, "exiting=1");
   1349 }
   1350 
   1351 // PlaybackThread::createTrack_l() must be called with AudioFlinger::mLock held
   1352 sp<AudioFlinger::PlaybackThread::Track> AudioFlinger::PlaybackThread::createTrack_l(
   1353         const sp<AudioFlinger::Client>& client,
   1354         audio_stream_type_t streamType,
   1355         uint32_t sampleRate,
   1356         audio_format_t format,
   1357         audio_channel_mask_t channelMask,
   1358         size_t *pFrameCount,
   1359         const sp<IMemory>& sharedBuffer,
   1360         int sessionId,
   1361         IAudioFlinger::track_flags_t *flags,
   1362         pid_t tid,
   1363         int uid,
   1364         status_t *status)
   1365 {
   1366     size_t frameCount = *pFrameCount;
   1367     sp<Track> track;
   1368     status_t lStatus;
   1369 
   1370     bool isTimed = (*flags & IAudioFlinger::TRACK_TIMED) != 0;
   1371 
   1372     // client expresses a preference for FAST, but we get the final say
   1373     if (*flags & IAudioFlinger::TRACK_FAST) {
   1374       if (
   1375             // not timed
   1376             (!isTimed) &&
   1377             // either of these use cases:
   1378             (
   1379               // use case 1: shared buffer with any frame count
   1380               (
   1381                 (sharedBuffer != 0)
   1382               ) ||
   1383               // use case 2: callback handler and frame count is default or at least as large as HAL
   1384               (
   1385                 (tid != -1) &&
   1386                 ((frameCount == 0) ||
   1387                 (frameCount >= mFrameCount))
   1388               )
   1389             ) &&
   1390             // PCM data
   1391             audio_is_linear_pcm(format) &&
   1392             // identical channel mask to sink, or mono in and stereo sink
   1393             (channelMask == mChannelMask ||
   1394                     (channelMask == AUDIO_CHANNEL_OUT_MONO &&
   1395                             mChannelMask == AUDIO_CHANNEL_OUT_STEREO)) &&
   1396             // hardware sample rate
   1397             (sampleRate == mSampleRate) &&
   1398             // normal mixer has an associated fast mixer
   1399             hasFastMixer() &&
   1400             // there are sufficient fast track slots available
   1401             (mFastTrackAvailMask != 0)
   1402             // FIXME test that MixerThread for this fast track has a capable output HAL
   1403             // FIXME add a permission test also?
   1404         ) {
   1405         // if frameCount not specified, then it defaults to fast mixer (HAL) frame count
   1406         if (frameCount == 0) {
   1407             // read the fast track multiplier property the first time it is needed
   1408             int ok = pthread_once(&sFastTrackMultiplierOnce, sFastTrackMultiplierInit);
   1409             if (ok != 0) {
   1410                 ALOGE("%s pthread_once failed: %d", __func__, ok);
   1411             }
   1412             frameCount = mFrameCount * sFastTrackMultiplier;
   1413         }
   1414         ALOGV("AUDIO_OUTPUT_FLAG_FAST accepted: frameCount=%d mFrameCount=%d",
   1415                 frameCount, mFrameCount);
   1416       } else {
   1417         ALOGV("AUDIO_OUTPUT_FLAG_FAST denied: isTimed=%d sharedBuffer=%p frameCount=%d "
   1418                 "mFrameCount=%d format=%#x mFormat=%#x isLinear=%d channelMask=%#x "
   1419                 "sampleRate=%u mSampleRate=%u "
   1420                 "hasFastMixer=%d tid=%d fastTrackAvailMask=%#x",
   1421                 isTimed, sharedBuffer.get(), frameCount, mFrameCount, format, mFormat,
   1422                 audio_is_linear_pcm(format),
   1423                 channelMask, sampleRate, mSampleRate, hasFastMixer(), tid, mFastTrackAvailMask);
   1424         *flags &= ~IAudioFlinger::TRACK_FAST;
   1425         // For compatibility with AudioTrack calculation, buffer depth is forced
   1426         // to be at least 2 x the normal mixer frame count and cover audio hardware latency.
   1427         // This is probably too conservative, but legacy application code may depend on it.
   1428         // If you change this calculation, also review the start threshold which is related.
   1429         uint32_t latencyMs = mOutput->stream->get_latency(mOutput->stream);
   1430         uint32_t minBufCount = latencyMs / ((1000 * mNormalFrameCount) / mSampleRate);
   1431         if (minBufCount < 2) {
   1432             minBufCount = 2;
   1433         }
   1434         size_t minFrameCount = mNormalFrameCount * minBufCount;
   1435         if (frameCount < minFrameCount) {
   1436             frameCount = minFrameCount;
   1437         }
   1438       }
   1439     }
   1440     *pFrameCount = frameCount;
   1441 
   1442     switch (mType) {
   1443 
   1444     case DIRECT:
   1445         if (audio_is_linear_pcm(format)) {
   1446             if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
   1447                 ALOGE("createTrack_l() Bad parameter: sampleRate %u format %#x, channelMask 0x%08x "
   1448                         "for output %p with format %#x",
   1449                         sampleRate, format, channelMask, mOutput, mFormat);
   1450                 lStatus = BAD_VALUE;
   1451                 goto Exit;
   1452             }
   1453         }
   1454         break;
   1455 
   1456     case OFFLOAD:
   1457         if (sampleRate != mSampleRate || format != mFormat || channelMask != mChannelMask) {
   1458             ALOGE("createTrack_l() Bad parameter: sampleRate %d format %#x, channelMask 0x%08x \""
   1459                     "for output %p with format %#x",
   1460                     sampleRate, format, channelMask, mOutput, mFormat);
   1461             lStatus = BAD_VALUE;
   1462             goto Exit;
   1463         }
   1464         break;
   1465 
   1466     default:
   1467         if (!audio_is_linear_pcm(format)) {
   1468                 ALOGE("createTrack_l() Bad parameter: format %#x \""
   1469                         "for output %p with format %#x",
   1470                         format, mOutput, mFormat);
   1471                 lStatus = BAD_VALUE;
   1472                 goto Exit;
   1473         }
   1474         if (sampleRate > mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX) {
   1475             ALOGE("Sample rate out of range: %u mSampleRate %u", sampleRate, mSampleRate);
   1476             lStatus = BAD_VALUE;
   1477             goto Exit;
   1478         }
   1479         break;
   1480 
   1481     }
   1482 
   1483     lStatus = initCheck();
   1484     if (lStatus != NO_ERROR) {
   1485         ALOGE("createTrack_l() audio driver not initialized");
   1486         goto Exit;
   1487     }
   1488 
   1489     { // scope for mLock
   1490         Mutex::Autolock _l(mLock);
   1491 
   1492         // all tracks in same audio session must share the same routing strategy otherwise
   1493         // conflicts will happen when tracks are moved from one output to another by audio policy
   1494         // manager
   1495         uint32_t strategy = AudioSystem::getStrategyForStream(streamType);
   1496         for (size_t i = 0; i < mTracks.size(); ++i) {
   1497             sp<Track> t = mTracks[i];
   1498             if (t != 0 && t->isExternalTrack()) {
   1499                 uint32_t actual = AudioSystem::getStrategyForStream(t->streamType());
   1500                 if (sessionId == t->sessionId() && strategy != actual) {
   1501                     ALOGE("createTrack_l() mismatched strategy; expected %u but found %u",
   1502                             strategy, actual);
   1503                     lStatus = BAD_VALUE;
   1504                     goto Exit;
   1505                 }
   1506             }
   1507         }
   1508 
   1509         if (!isTimed) {
   1510             track = new Track(this, client, streamType, sampleRate, format,
   1511                               channelMask, frameCount, NULL, sharedBuffer,
   1512                               sessionId, uid, *flags, TrackBase::TYPE_DEFAULT);
   1513         } else {
   1514             track = TimedTrack::create(this, client, streamType, sampleRate, format,
   1515                     channelMask, frameCount, sharedBuffer, sessionId, uid);
   1516         }
   1517 
   1518         // new Track always returns non-NULL,
   1519         // but TimedTrack::create() is a factory that could fail by returning NULL
   1520         lStatus = track != 0 ? track->initCheck() : (status_t) NO_MEMORY;
   1521         if (lStatus != NO_ERROR) {
   1522             ALOGE("createTrack_l() initCheck failed %d; no control block?", lStatus);
   1523             // track must be cleared from the caller as the caller has the AF lock
   1524             goto Exit;
   1525         }
   1526         mTracks.add(track);
   1527 
   1528         sp<EffectChain> chain = getEffectChain_l(sessionId);
   1529         if (chain != 0) {
   1530             ALOGV("createTrack_l() setting main buffer %p", chain->inBuffer());
   1531             track->setMainBuffer(chain->inBuffer());
   1532             chain->setStrategy(AudioSystem::getStrategyForStream(track->streamType()));
   1533             chain->incTrackCnt();
   1534         }
   1535 
   1536         if ((*flags & IAudioFlinger::TRACK_FAST) && (tid != -1)) {
   1537             pid_t callingPid = IPCThreadState::self()->getCallingPid();
   1538             // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
   1539             // so ask activity manager to do this on our behalf
   1540             sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp);
   1541         }
   1542     }
   1543 
   1544     lStatus = NO_ERROR;
   1545 
   1546 Exit:
   1547     *status = lStatus;
   1548     return track;
   1549 }
   1550 
   1551 uint32_t AudioFlinger::PlaybackThread::correctLatency_l(uint32_t latency) const
   1552 {
   1553     return latency;
   1554 }
   1555 
   1556 uint32_t AudioFlinger::PlaybackThread::latency() const
   1557 {
   1558     Mutex::Autolock _l(mLock);
   1559     return latency_l();
   1560 }
   1561 uint32_t AudioFlinger::PlaybackThread::latency_l() const
   1562 {
   1563     if (initCheck() == NO_ERROR) {
   1564         return correctLatency_l(mOutput->stream->get_latency(mOutput->stream));
   1565     } else {
   1566         return 0;
   1567     }
   1568 }
   1569 
   1570 void AudioFlinger::PlaybackThread::setMasterVolume(float value)
   1571 {
   1572     Mutex::Autolock _l(mLock);
   1573     // Don't apply master volume in SW if our HAL can do it for us.
   1574     if (mOutput && mOutput->audioHwDev &&
   1575         mOutput->audioHwDev->canSetMasterVolume()) {
   1576         mMasterVolume = 1.0;
   1577     } else {
   1578         mMasterVolume = value;
   1579     }
   1580 }
   1581 
   1582 void AudioFlinger::PlaybackThread::setMasterMute(bool muted)
   1583 {
   1584     Mutex::Autolock _l(mLock);
   1585     // Don't apply master mute in SW if our HAL can do it for us.
   1586     if (mOutput && mOutput->audioHwDev &&
   1587         mOutput->audioHwDev->canSetMasterMute()) {
   1588         mMasterMute = false;
   1589     } else {
   1590         mMasterMute = muted;
   1591     }
   1592 }
   1593 
   1594 void AudioFlinger::PlaybackThread::setStreamVolume(audio_stream_type_t stream, float value)
   1595 {
   1596     Mutex::Autolock _l(mLock);
   1597     mStreamTypes[stream].volume = value;
   1598     broadcast_l();
   1599 }
   1600 
   1601 void AudioFlinger::PlaybackThread::setStreamMute(audio_stream_type_t stream, bool muted)
   1602 {
   1603     Mutex::Autolock _l(mLock);
   1604     mStreamTypes[stream].mute = muted;
   1605     broadcast_l();
   1606 }
   1607 
   1608 float AudioFlinger::PlaybackThread::streamVolume(audio_stream_type_t stream) const
   1609 {
   1610     Mutex::Autolock _l(mLock);
   1611     return mStreamTypes[stream].volume;
   1612 }
   1613 
   1614 // addTrack_l() must be called with ThreadBase::mLock held
   1615 status_t AudioFlinger::PlaybackThread::addTrack_l(const sp<Track>& track)
   1616 {
   1617     status_t status = ALREADY_EXISTS;
   1618 
   1619     // set retry count for buffer fill
   1620     track->mRetryCount = kMaxTrackStartupRetries;
   1621     if (mActiveTracks.indexOf(track) < 0) {
   1622         // the track is newly added, make sure it fills up all its
   1623         // buffers before playing. This is to ensure the client will
   1624         // effectively get the latency it requested.
   1625         if (track->isExternalTrack()) {
   1626             TrackBase::track_state state = track->mState;
   1627             mLock.unlock();
   1628             status = AudioSystem::startOutput(mId, track->streamType(), track->sessionId());
   1629             mLock.lock();
   1630             // abort track was stopped/paused while we released the lock
   1631             if (state != track->mState) {
   1632                 if (status == NO_ERROR) {
   1633                     mLock.unlock();
   1634                     AudioSystem::stopOutput(mId, track->streamType(), track->sessionId());
   1635                     mLock.lock();
   1636                 }
   1637                 return INVALID_OPERATION;
   1638             }
   1639             // abort if start is rejected by audio policy manager
   1640             if (status != NO_ERROR) {
   1641                 return PERMISSION_DENIED;
   1642             }
   1643 #ifdef ADD_BATTERY_DATA
   1644             // to track the speaker usage
   1645             addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStart);
   1646 #endif
   1647         }
   1648 
   1649         track->mFillingUpStatus = track->sharedBuffer() != 0 ? Track::FS_FILLED : Track::FS_FILLING;
   1650         track->mResetDone = false;
   1651         track->mPresentationCompleteFrames = 0;
   1652         mActiveTracks.add(track);
   1653         mWakeLockUids.add(track->uid());
   1654         mActiveTracksGeneration++;
   1655         mLatestActiveTrack = track;
   1656         sp<EffectChain> chain = getEffectChain_l(track->sessionId());
   1657         if (chain != 0) {
   1658             ALOGV("addTrack_l() starting track on chain %p for session %d", chain.get(),
   1659                     track->sessionId());
   1660             chain->incActiveTrackCnt();
   1661         }
   1662 
   1663         status = NO_ERROR;
   1664     }
   1665 
   1666     onAddNewTrack_l();
   1667     return status;
   1668 }
   1669 
   1670 bool AudioFlinger::PlaybackThread::destroyTrack_l(const sp<Track>& track)
   1671 {
   1672     track->terminate();
   1673     // active tracks are removed by threadLoop()
   1674     bool trackActive = (mActiveTracks.indexOf(track) >= 0);
   1675     track->mState = TrackBase::STOPPED;
   1676     if (!trackActive) {
   1677         removeTrack_l(track);
   1678     } else if (track->isFastTrack() || track->isOffloaded() || track->isDirect()) {
   1679         track->mState = TrackBase::STOPPING_1;
   1680     }
   1681 
   1682     return trackActive;
   1683 }
   1684 
   1685 void AudioFlinger::PlaybackThread::removeTrack_l(const sp<Track>& track)
   1686 {
   1687     track->triggerEvents(AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE);
   1688     mTracks.remove(track);
   1689     deleteTrackName_l(track->name());
   1690     // redundant as track is about to be destroyed, for dumpsys only
   1691     track->mName = -1;
   1692     if (track->isFastTrack()) {
   1693         int index = track->mFastIndex;
   1694         ALOG_ASSERT(0 < index && index < (int)FastMixerState::kMaxFastTracks);
   1695         ALOG_ASSERT(!(mFastTrackAvailMask & (1 << index)));
   1696         mFastTrackAvailMask |= 1 << index;
   1697         // redundant as track is about to be destroyed, for dumpsys only
   1698         track->mFastIndex = -1;
   1699     }
   1700     sp<EffectChain> chain = getEffectChain_l(track->sessionId());
   1701     if (chain != 0) {
   1702         chain->decTrackCnt();
   1703     }
   1704 }
   1705 
   1706 void AudioFlinger::PlaybackThread::broadcast_l()
   1707 {
   1708     // Thread could be blocked waiting for async
   1709     // so signal it to handle state changes immediately
   1710     // If threadLoop is currently unlocked a signal of mWaitWorkCV will
   1711     // be lost so we also flag to prevent it blocking on mWaitWorkCV
   1712     mSignalPending = true;
   1713     mWaitWorkCV.broadcast();
   1714 }
   1715 
   1716 String8 AudioFlinger::PlaybackThread::getParameters(const String8& keys)
   1717 {
   1718     Mutex::Autolock _l(mLock);
   1719     if (initCheck() != NO_ERROR) {
   1720         return String8();
   1721     }
   1722 
   1723     char *s = mOutput->stream->common.get_parameters(&mOutput->stream->common, keys.string());
   1724     const String8 out_s8(s);
   1725     free(s);
   1726     return out_s8;
   1727 }
   1728 
   1729 void AudioFlinger::PlaybackThread::audioConfigChanged(int event, int param) {
   1730     AudioSystem::OutputDescriptor desc;
   1731     void *param2 = NULL;
   1732 
   1733     ALOGV("PlaybackThread::audioConfigChanged, thread %p, event %d, param %d", this, event,
   1734             param);
   1735 
   1736     switch (event) {
   1737     case AudioSystem::OUTPUT_OPENED:
   1738     case AudioSystem::OUTPUT_CONFIG_CHANGED:
   1739         desc.channelMask = mChannelMask;
   1740         desc.samplingRate = mSampleRate;
   1741         desc.format = mFormat;
   1742         desc.frameCount = mNormalFrameCount; // FIXME see
   1743                                              // AudioFlinger::frameCount(audio_io_handle_t)
   1744         desc.latency = latency_l();
   1745         param2 = &desc;
   1746         break;
   1747 
   1748     case AudioSystem::STREAM_CONFIG_CHANGED:
   1749         param2 = &param;
   1750     case AudioSystem::OUTPUT_CLOSED:
   1751     default:
   1752         break;
   1753     }
   1754     mAudioFlinger->audioConfigChanged(event, mId, param2);
   1755 }
   1756 
   1757 void AudioFlinger::PlaybackThread::writeCallback()
   1758 {
   1759     ALOG_ASSERT(mCallbackThread != 0);
   1760     mCallbackThread->resetWriteBlocked();
   1761 }
   1762 
   1763 void AudioFlinger::PlaybackThread::drainCallback()
   1764 {
   1765     ALOG_ASSERT(mCallbackThread != 0);
   1766     mCallbackThread->resetDraining();
   1767 }
   1768 
   1769 void AudioFlinger::PlaybackThread::resetWriteBlocked(uint32_t sequence)
   1770 {
   1771     Mutex::Autolock _l(mLock);
   1772     // reject out of sequence requests
   1773     if ((mWriteAckSequence & 1) && (sequence == mWriteAckSequence)) {
   1774         mWriteAckSequence &= ~1;
   1775         mWaitWorkCV.signal();
   1776     }
   1777 }
   1778 
   1779 void AudioFlinger::PlaybackThread::resetDraining(uint32_t sequence)
   1780 {
   1781     Mutex::Autolock _l(mLock);
   1782     // reject out of sequence requests
   1783     if ((mDrainSequence & 1) && (sequence == mDrainSequence)) {
   1784         mDrainSequence &= ~1;
   1785         mWaitWorkCV.signal();
   1786     }
   1787 }
   1788 
   1789 // static
   1790 int AudioFlinger::PlaybackThread::asyncCallback(stream_callback_event_t event,
   1791                                                 void *param __unused,
   1792                                                 void *cookie)
   1793 {
   1794     AudioFlinger::PlaybackThread *me = (AudioFlinger::PlaybackThread *)cookie;
   1795     ALOGV("asyncCallback() event %d", event);
   1796     switch (event) {
   1797     case STREAM_CBK_EVENT_WRITE_READY:
   1798         me->writeCallback();
   1799         break;
   1800     case STREAM_CBK_EVENT_DRAIN_READY:
   1801         me->drainCallback();
   1802         break;
   1803     default:
   1804         ALOGW("asyncCallback() unknown event %d", event);
   1805         break;
   1806     }
   1807     return 0;
   1808 }
   1809 
   1810 void AudioFlinger::PlaybackThread::readOutputParameters_l()
   1811 {
   1812     // unfortunately we have no way of recovering from errors here, hence the LOG_ALWAYS_FATAL
   1813     mSampleRate = mOutput->stream->common.get_sample_rate(&mOutput->stream->common);
   1814     mChannelMask = mOutput->stream->common.get_channels(&mOutput->stream->common);
   1815     if (!audio_is_output_channel(mChannelMask)) {
   1816         LOG_ALWAYS_FATAL("HAL channel mask %#x not valid for output", mChannelMask);
   1817     }
   1818     if ((mType == MIXER || mType == DUPLICATING)
   1819             && !isValidPcmSinkChannelMask(mChannelMask)) {
   1820         LOG_ALWAYS_FATAL("HAL channel mask %#x not supported for mixed output",
   1821                 mChannelMask);
   1822     }
   1823     mChannelCount = audio_channel_count_from_out_mask(mChannelMask);
   1824     mHALFormat = mOutput->stream->common.get_format(&mOutput->stream->common);
   1825     mFormat = mHALFormat;
   1826     if (!audio_is_valid_format(mFormat)) {
   1827         LOG_ALWAYS_FATAL("HAL format %#x not valid for output", mFormat);
   1828     }
   1829     if ((mType == MIXER || mType == DUPLICATING)
   1830             && !isValidPcmSinkFormat(mFormat)) {
   1831         LOG_FATAL("HAL format %#x not supported for mixed output",
   1832                 mFormat);
   1833     }
   1834     mFrameSize = audio_stream_out_frame_size(mOutput->stream);
   1835     mBufferSize = mOutput->stream->common.get_buffer_size(&mOutput->stream->common);
   1836     mFrameCount = mBufferSize / mFrameSize;
   1837     if (mFrameCount & 15) {
   1838         ALOGW("HAL output buffer size is %u frames but AudioMixer requires multiples of 16 frames",
   1839                 mFrameCount);
   1840     }
   1841 
   1842     if ((mOutput->flags & AUDIO_OUTPUT_FLAG_NON_BLOCKING) &&
   1843             (mOutput->stream->set_callback != NULL)) {
   1844         if (mOutput->stream->set_callback(mOutput->stream,
   1845                                       AudioFlinger::PlaybackThread::asyncCallback, this) == 0) {
   1846             mUseAsyncWrite = true;
   1847             mCallbackThread = new AudioFlinger::AsyncCallbackThread(this);
   1848         }
   1849     }
   1850 
   1851     // Calculate size of normal sink buffer relative to the HAL output buffer size
   1852     double multiplier = 1.0;
   1853     if (mType == MIXER && (kUseFastMixer == FastMixer_Static ||
   1854             kUseFastMixer == FastMixer_Dynamic)) {
   1855         size_t minNormalFrameCount = (kMinNormalSinkBufferSizeMs * mSampleRate) / 1000;
   1856         size_t maxNormalFrameCount = (kMaxNormalSinkBufferSizeMs * mSampleRate) / 1000;
   1857         // round up minimum and round down maximum to nearest 16 frames to satisfy AudioMixer
   1858         minNormalFrameCount = (minNormalFrameCount + 15) & ~15;
   1859         maxNormalFrameCount = maxNormalFrameCount & ~15;
   1860         if (maxNormalFrameCount < minNormalFrameCount) {
   1861             maxNormalFrameCount = minNormalFrameCount;
   1862         }
   1863         multiplier = (double) minNormalFrameCount / (double) mFrameCount;
   1864         if (multiplier <= 1.0) {
   1865             multiplier = 1.0;
   1866         } else if (multiplier <= 2.0) {
   1867             if (2 * mFrameCount <= maxNormalFrameCount) {
   1868                 multiplier = 2.0;
   1869             } else {
   1870                 multiplier = (double) maxNormalFrameCount / (double) mFrameCount;
   1871             }
   1872         } else {
   1873             // prefer an even multiplier, for compatibility with doubling of fast tracks due to HAL
   1874             // SRC (it would be unusual for the normal sink buffer size to not be a multiple of fast
   1875             // track, but we sometimes have to do this to satisfy the maximum frame count
   1876             // constraint)
   1877             // FIXME this rounding up should not be done if no HAL SRC
   1878             uint32_t truncMult = (uint32_t) multiplier;
   1879             if ((truncMult & 1)) {
   1880                 if ((truncMult + 1) * mFrameCount <= maxNormalFrameCount) {
   1881                     ++truncMult;
   1882                 }
   1883             }
   1884             multiplier = (double) truncMult;
   1885         }
   1886     }
   1887     mNormalFrameCount = multiplier * mFrameCount;
   1888     // round up to nearest 16 frames to satisfy AudioMixer
   1889     if (mType == MIXER || mType == DUPLICATING) {
   1890         mNormalFrameCount = (mNormalFrameCount + 15) & ~15;
   1891     }
   1892     ALOGI("HAL output buffer size %u frames, normal sink buffer size %u frames", mFrameCount,
   1893             mNormalFrameCount);
   1894 
   1895     // mSinkBuffer is the sink buffer.  Size is always multiple-of-16 frames.
   1896     // Originally this was int16_t[] array, need to remove legacy implications.
   1897     free(mSinkBuffer);
   1898     mSinkBuffer = NULL;
   1899     // For sink buffer size, we use the frame size from the downstream sink to avoid problems
   1900     // with non PCM formats for compressed music, e.g. AAC, and Offload threads.
   1901     const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
   1902     (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
   1903 
   1904     // We resize the mMixerBuffer according to the requirements of the sink buffer which
   1905     // drives the output.
   1906     free(mMixerBuffer);
   1907     mMixerBuffer = NULL;
   1908     if (mMixerBufferEnabled) {
   1909         mMixerBufferFormat = AUDIO_FORMAT_PCM_FLOAT; // also valid: AUDIO_FORMAT_PCM_16_BIT.
   1910         mMixerBufferSize = mNormalFrameCount * mChannelCount
   1911                 * audio_bytes_per_sample(mMixerBufferFormat);
   1912         (void)posix_memalign(&mMixerBuffer, 32, mMixerBufferSize);
   1913     }
   1914     free(mEffectBuffer);
   1915     mEffectBuffer = NULL;
   1916     if (mEffectBufferEnabled) {
   1917         mEffectBufferFormat = AUDIO_FORMAT_PCM_16_BIT; // Note: Effects support 16b only
   1918         mEffectBufferSize = mNormalFrameCount * mChannelCount
   1919                 * audio_bytes_per_sample(mEffectBufferFormat);
   1920         (void)posix_memalign(&mEffectBuffer, 32, mEffectBufferSize);
   1921     }
   1922 
   1923     // force reconfiguration of effect chains and engines to take new buffer size and audio
   1924     // parameters into account
   1925     // Note that mLock is not held when readOutputParameters_l() is called from the constructor
   1926     // but in this case nothing is done below as no audio sessions have effect yet so it doesn't
   1927     // matter.
   1928     // create a copy of mEffectChains as calling moveEffectChain_l() can reorder some effect chains
   1929     Vector< sp<EffectChain> > effectChains = mEffectChains;
   1930     for (size_t i = 0; i < effectChains.size(); i ++) {
   1931         mAudioFlinger->moveEffectChain_l(effectChains[i]->sessionId(), this, this, false);
   1932     }
   1933 }
   1934 
   1935 
   1936 status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames)
   1937 {
   1938     if (halFrames == NULL || dspFrames == NULL) {
   1939         return BAD_VALUE;
   1940     }
   1941     Mutex::Autolock _l(mLock);
   1942     if (initCheck() != NO_ERROR) {
   1943         return INVALID_OPERATION;
   1944     }
   1945     size_t framesWritten = mBytesWritten / mFrameSize;
   1946     *halFrames = framesWritten;
   1947 
   1948     if (isSuspended()) {
   1949         // return an estimation of rendered frames when the output is suspended
   1950         size_t latencyFrames = (latency_l() * mSampleRate) / 1000;
   1951         *dspFrames = framesWritten >= latencyFrames ? framesWritten - latencyFrames : 0;
   1952         return NO_ERROR;
   1953     } else {
   1954         status_t status;
   1955         uint32_t frames;
   1956         status = mOutput->stream->get_render_position(mOutput->stream, &frames);
   1957         *dspFrames = (size_t)frames;
   1958         return status;
   1959     }
   1960 }
   1961 
   1962 uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId) const
   1963 {
   1964     Mutex::Autolock _l(mLock);
   1965     uint32_t result = 0;
   1966     if (getEffectChain_l(sessionId) != 0) {
   1967         result = EFFECT_SESSION;
   1968     }
   1969 
   1970     for (size_t i = 0; i < mTracks.size(); ++i) {
   1971         sp<Track> track = mTracks[i];
   1972         if (sessionId == track->sessionId() && !track->isInvalid()) {
   1973             result |= TRACK_SESSION;
   1974             break;
   1975         }
   1976     }
   1977 
   1978     return result;
   1979 }
   1980 
   1981 uint32_t AudioFlinger::PlaybackThread::getStrategyForSession_l(int sessionId)
   1982 {
   1983     // session AUDIO_SESSION_OUTPUT_MIX is placed in same strategy as MUSIC stream so that
   1984     // it is moved to correct output by audio policy manager when A2DP is connected or disconnected
   1985     if (sessionId == AUDIO_SESSION_OUTPUT_MIX) {
   1986         return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
   1987     }
   1988     for (size_t i = 0; i < mTracks.size(); i++) {
   1989         sp<Track> track = mTracks[i];
   1990         if (sessionId == track->sessionId() && !track->isInvalid()) {
   1991             return AudioSystem::getStrategyForStream(track->streamType());
   1992         }
   1993     }
   1994     return AudioSystem::getStrategyForStream(AUDIO_STREAM_MUSIC);
   1995 }
   1996 
   1997 
   1998 AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::getOutput() const
   1999 {
   2000     Mutex::Autolock _l(mLock);
   2001     return mOutput;
   2002 }
   2003 
   2004 AudioFlinger::AudioStreamOut* AudioFlinger::PlaybackThread::clearOutput()
   2005 {
   2006     Mutex::Autolock _l(mLock);
   2007     AudioStreamOut *output = mOutput;
   2008     mOutput = NULL;
   2009     // FIXME FastMixer might also have a raw ptr to mOutputSink;
   2010     //       must push a NULL and wait for ack
   2011     mOutputSink.clear();
   2012     mPipeSink.clear();
   2013     mNormalSink.clear();
   2014     return output;
   2015 }
   2016 
   2017 // this method must always be called either with ThreadBase mLock held or inside the thread loop
   2018 audio_stream_t* AudioFlinger::PlaybackThread::stream() const
   2019 {
   2020     if (mOutput == NULL) {
   2021         return NULL;
   2022     }
   2023     return &mOutput->stream->common;
   2024 }
   2025 
   2026 uint32_t AudioFlinger::PlaybackThread::activeSleepTimeUs() const
   2027 {
   2028     return (uint32_t)((uint32_t)((mNormalFrameCount * 1000) / mSampleRate) * 1000);
   2029 }
   2030 
   2031 status_t AudioFlinger::PlaybackThread::setSyncEvent(const sp<SyncEvent>& event)
   2032 {
   2033     if (!isValidSyncEvent(event)) {
   2034         return BAD_VALUE;
   2035     }
   2036 
   2037     Mutex::Autolock _l(mLock);
   2038 
   2039     for (size_t i = 0; i < mTracks.size(); ++i) {
   2040         sp<Track> track = mTracks[i];
   2041         if (event->triggerSession() == track->sessionId()) {
   2042             (void) track->setSyncEvent(event);
   2043             return NO_ERROR;
   2044         }
   2045     }
   2046 
   2047     return NAME_NOT_FOUND;
   2048 }
   2049 
   2050 bool AudioFlinger::PlaybackThread::isValidSyncEvent(const sp<SyncEvent>& event) const
   2051 {
   2052     return event->type() == AudioSystem::SYNC_EVENT_PRESENTATION_COMPLETE;
   2053 }
   2054 
   2055 void AudioFlinger::PlaybackThread::threadLoop_removeTracks(
   2056         const Vector< sp<Track> >& tracksToRemove)
   2057 {
   2058     size_t count = tracksToRemove.size();
   2059     if (count > 0) {
   2060         for (size_t i = 0 ; i < count ; i++) {
   2061             const sp<Track>& track = tracksToRemove.itemAt(i);
   2062             if (track->isExternalTrack()) {
   2063                 AudioSystem::stopOutput(mId, track->streamType(), track->sessionId());
   2064 #ifdef ADD_BATTERY_DATA
   2065                 // to track the speaker usage
   2066                 addBatteryData(IMediaPlayerService::kBatteryDataAudioFlingerStop);
   2067 #endif
   2068                 if (track->isTerminated()) {
   2069                     AudioSystem::releaseOutput(mId);
   2070                 }
   2071             }
   2072         }
   2073     }
   2074 }
   2075 
   2076 void AudioFlinger::PlaybackThread::checkSilentMode_l()
   2077 {
   2078     if (!mMasterMute) {
   2079         char value[PROPERTY_VALUE_MAX];
   2080         if (property_get("ro.audio.silent", value, "0") > 0) {
   2081             char *endptr;
   2082             unsigned long ul = strtoul(value, &endptr, 0);
   2083             if (*endptr == '\0' && ul != 0) {
   2084                 ALOGD("Silence is golden");
   2085                 // The setprop command will not allow a property to be changed after
   2086                 // the first time it is set, so we don't have to worry about un-muting.
   2087                 setMasterMute_l(true);
   2088             }
   2089         }
   2090     }
   2091 }
   2092 
   2093 // shared by MIXER and DIRECT, overridden by DUPLICATING
   2094 ssize_t AudioFlinger::PlaybackThread::threadLoop_write()
   2095 {
   2096     // FIXME rewrite to reduce number of system calls
   2097     mLastWriteTime = systemTime();
   2098     mInWrite = true;
   2099     ssize_t bytesWritten;
   2100     const size_t offset = mCurrentWriteLength - mBytesRemaining;
   2101 
   2102     // If an NBAIO sink is present, use it to write the normal mixer's submix
   2103     if (mNormalSink != 0) {
   2104 
   2105         const size_t count = mBytesRemaining / mFrameSize;
   2106 
   2107         ATRACE_BEGIN("write");
   2108         // update the setpoint when AudioFlinger::mScreenState changes
   2109         uint32_t screenState = AudioFlinger::mScreenState;
   2110         if (screenState != mScreenState) {
   2111             mScreenState = screenState;
   2112             MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
   2113             if (pipe != NULL) {
   2114                 pipe->setAvgFrames((mScreenState & 1) ?
   2115                         (pipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
   2116             }
   2117         }
   2118         ssize_t framesWritten = mNormalSink->write((char *)mSinkBuffer + offset, count);
   2119         ATRACE_END();
   2120         if (framesWritten > 0) {
   2121             bytesWritten = framesWritten * mFrameSize;
   2122         } else {
   2123             bytesWritten = framesWritten;
   2124         }
   2125         status_t status = mNormalSink->getTimestamp(mLatchD.mTimestamp);
   2126         if (status == NO_ERROR) {
   2127             size_t totalFramesWritten = mNormalSink->framesWritten();
   2128             if (totalFramesWritten >= mLatchD.mTimestamp.mPosition) {
   2129                 mLatchD.mUnpresentedFrames = totalFramesWritten - mLatchD.mTimestamp.mPosition;
   2130                 // mLatchD.mFramesReleased is set immediately before D is clocked into Q
   2131                 mLatchDValid = true;
   2132             }
   2133         }
   2134     // otherwise use the HAL / AudioStreamOut directly
   2135     } else {
   2136         // Direct output and offload threads
   2137 
   2138         if (mUseAsyncWrite) {
   2139             ALOGW_IF(mWriteAckSequence & 1, "threadLoop_write(): out of sequence write request");
   2140             mWriteAckSequence += 2;
   2141             mWriteAckSequence |= 1;
   2142             ALOG_ASSERT(mCallbackThread != 0);
   2143             mCallbackThread->setWriteBlocked(mWriteAckSequence);
   2144         }
   2145         // FIXME We should have an implementation of timestamps for direct output threads.
   2146         // They are used e.g for multichannel PCM playback over HDMI.
   2147         bytesWritten = mOutput->stream->write(mOutput->stream,
   2148                                                    (char *)mSinkBuffer + offset, mBytesRemaining);
   2149         if (mUseAsyncWrite &&
   2150                 ((bytesWritten < 0) || (bytesWritten == (ssize_t)mBytesRemaining))) {
   2151             // do not wait for async callback in case of error of full write
   2152             mWriteAckSequence &= ~1;
   2153             ALOG_ASSERT(mCallbackThread != 0);
   2154             mCallbackThread->setWriteBlocked(mWriteAckSequence);
   2155         }
   2156     }
   2157 
   2158     mNumWrites++;
   2159     mInWrite = false;
   2160     mStandby = false;
   2161     return bytesWritten;
   2162 }
   2163 
   2164 void AudioFlinger::PlaybackThread::threadLoop_drain()
   2165 {
   2166     if (mOutput->stream->drain) {
   2167         ALOGV("draining %s", (mMixerStatus == MIXER_DRAIN_TRACK) ? "early" : "full");
   2168         if (mUseAsyncWrite) {
   2169             ALOGW_IF(mDrainSequence & 1, "threadLoop_drain(): out of sequence drain request");
   2170             mDrainSequence |= 1;
   2171             ALOG_ASSERT(mCallbackThread != 0);
   2172             mCallbackThread->setDraining(mDrainSequence);
   2173         }
   2174         mOutput->stream->drain(mOutput->stream,
   2175             (mMixerStatus == MIXER_DRAIN_TRACK) ? AUDIO_DRAIN_EARLY_NOTIFY
   2176                                                 : AUDIO_DRAIN_ALL);
   2177     }
   2178 }
   2179 
   2180 void AudioFlinger::PlaybackThread::threadLoop_exit()
   2181 {
   2182     // Default implementation has nothing to do
   2183 }
   2184 
   2185 /*
   2186 The derived values that are cached:
   2187  - mSinkBufferSize from frame count * frame size
   2188  - activeSleepTime from activeSleepTimeUs()
   2189  - idleSleepTime from idleSleepTimeUs()
   2190  - standbyDelay from mActiveSleepTimeUs (DIRECT only)
   2191  - maxPeriod from frame count and sample rate (MIXER only)
   2192 
   2193 The parameters that affect these derived values are:
   2194  - frame count
   2195  - frame size
   2196  - sample rate
   2197  - device type: A2DP or not
   2198  - device latency
   2199  - format: PCM or not
   2200  - active sleep time
   2201  - idle sleep time
   2202 */
   2203 
   2204 void AudioFlinger::PlaybackThread::cacheParameters_l()
   2205 {
   2206     mSinkBufferSize = mNormalFrameCount * mFrameSize;
   2207     activeSleepTime = activeSleepTimeUs();
   2208     idleSleepTime = idleSleepTimeUs();
   2209 }
   2210 
   2211 void AudioFlinger::PlaybackThread::invalidateTracks(audio_stream_type_t streamType)
   2212 {
   2213     ALOGV("MixerThread::invalidateTracks() mixer %p, streamType %d, mTracks.size %d",
   2214             this,  streamType, mTracks.size());
   2215     Mutex::Autolock _l(mLock);
   2216 
   2217     size_t size = mTracks.size();
   2218     for (size_t i = 0; i < size; i++) {
   2219         sp<Track> t = mTracks[i];
   2220         if (t->streamType() == streamType) {
   2221             t->invalidate();
   2222         }
   2223     }
   2224 }
   2225 
   2226 status_t AudioFlinger::PlaybackThread::addEffectChain_l(const sp<EffectChain>& chain)
   2227 {
   2228     int session = chain->sessionId();
   2229     int16_t* buffer = reinterpret_cast<int16_t*>(mEffectBufferEnabled
   2230             ? mEffectBuffer : mSinkBuffer);
   2231     bool ownsBuffer = false;
   2232 
   2233     ALOGV("addEffectChain_l() %p on thread %p for session %d", chain.get(), this, session);
   2234     if (session > 0) {
   2235         // Only one effect chain can be present in direct output thread and it uses
   2236         // the sink buffer as input
   2237         if (mType != DIRECT) {
   2238             size_t numSamples = mNormalFrameCount * mChannelCount;
   2239             buffer = new int16_t[numSamples];
   2240             memset(buffer, 0, numSamples * sizeof(int16_t));
   2241             ALOGV("addEffectChain_l() creating new input buffer %p session %d", buffer, session);
   2242             ownsBuffer = true;
   2243         }
   2244 
   2245         // Attach all tracks with same session ID to this chain.
   2246         for (size_t i = 0; i < mTracks.size(); ++i) {
   2247             sp<Track> track = mTracks[i];
   2248             if (session == track->sessionId()) {
   2249                 ALOGV("addEffectChain_l() track->setMainBuffer track %p buffer %p", track.get(),
   2250                         buffer);
   2251                 track->setMainBuffer(buffer);
   2252                 chain->incTrackCnt();
   2253             }
   2254         }
   2255 
   2256         // indicate all active tracks in the chain
   2257         for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
   2258             sp<Track> track = mActiveTracks[i].promote();
   2259             if (track == 0) {
   2260                 continue;
   2261             }
   2262             if (session == track->sessionId()) {
   2263                 ALOGV("addEffectChain_l() activating track %p on session %d", track.get(), session);
   2264                 chain->incActiveTrackCnt();
   2265             }
   2266         }
   2267     }
   2268     chain->setThread(this);
   2269     chain->setInBuffer(buffer, ownsBuffer);
   2270     chain->setOutBuffer(reinterpret_cast<int16_t*>(mEffectBufferEnabled
   2271             ? mEffectBuffer : mSinkBuffer));
   2272     // Effect chain for session AUDIO_SESSION_OUTPUT_STAGE is inserted at end of effect
   2273     // chains list in order to be processed last as it contains output stage effects
   2274     // Effect chain for session AUDIO_SESSION_OUTPUT_MIX is inserted before
   2275     // session AUDIO_SESSION_OUTPUT_STAGE to be processed
   2276     // after track specific effects and before output stage
   2277     // It is therefore mandatory that AUDIO_SESSION_OUTPUT_MIX == 0 and
   2278     // that AUDIO_SESSION_OUTPUT_STAGE < AUDIO_SESSION_OUTPUT_MIX
   2279     // Effect chain for other sessions are inserted at beginning of effect
   2280     // chains list to be processed before output mix effects. Relative order between other
   2281     // sessions is not important
   2282     size_t size = mEffectChains.size();
   2283     size_t i = 0;
   2284     for (i = 0; i < size; i++) {
   2285         if (mEffectChains[i]->sessionId() < session) {
   2286             break;
   2287         }
   2288     }
   2289     mEffectChains.insertAt(chain, i);
   2290     checkSuspendOnAddEffectChain_l(chain);
   2291 
   2292     return NO_ERROR;
   2293 }
   2294 
   2295 size_t AudioFlinger::PlaybackThread::removeEffectChain_l(const sp<EffectChain>& chain)
   2296 {
   2297     int session = chain->sessionId();
   2298 
   2299     ALOGV("removeEffectChain_l() %p from thread %p for session %d", chain.get(), this, session);
   2300 
   2301     for (size_t i = 0; i < mEffectChains.size(); i++) {
   2302         if (chain == mEffectChains[i]) {
   2303             mEffectChains.removeAt(i);
   2304             // detach all active tracks from the chain
   2305             for (size_t i = 0 ; i < mActiveTracks.size() ; ++i) {
   2306                 sp<Track> track = mActiveTracks[i].promote();
   2307                 if (track == 0) {
   2308                     continue;
   2309                 }
   2310                 if (session == track->sessionId()) {
   2311                     ALOGV("removeEffectChain_l(): stopping track on chain %p for session Id: %d",
   2312                             chain.get(), session);
   2313                     chain->decActiveTrackCnt();
   2314                 }
   2315             }
   2316 
   2317             // detach all tracks with same session ID from this chain
   2318             for (size_t i = 0; i < mTracks.size(); ++i) {
   2319                 sp<Track> track = mTracks[i];
   2320                 if (session == track->sessionId()) {
   2321                     track->setMainBuffer(reinterpret_cast<int16_t*>(mSinkBuffer));
   2322                     chain->decTrackCnt();
   2323                 }
   2324             }
   2325             break;
   2326         }
   2327     }
   2328     return mEffectChains.size();
   2329 }
   2330 
   2331 status_t AudioFlinger::PlaybackThread::attachAuxEffect(
   2332         const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
   2333 {
   2334     Mutex::Autolock _l(mLock);
   2335     return attachAuxEffect_l(track, EffectId);
   2336 }
   2337 
   2338 status_t AudioFlinger::PlaybackThread::attachAuxEffect_l(
   2339         const sp<AudioFlinger::PlaybackThread::Track> track, int EffectId)
   2340 {
   2341     status_t status = NO_ERROR;
   2342 
   2343     if (EffectId == 0) {
   2344         track->setAuxBuffer(0, NULL);
   2345     } else {
   2346         // Auxiliary effects are always in audio session AUDIO_SESSION_OUTPUT_MIX
   2347         sp<EffectModule> effect = getEffect_l(AUDIO_SESSION_OUTPUT_MIX, EffectId);
   2348         if (effect != 0) {
   2349             if ((effect->desc().flags & EFFECT_FLAG_TYPE_MASK) == EFFECT_FLAG_TYPE_AUXILIARY) {
   2350                 track->setAuxBuffer(EffectId, (int32_t *)effect->inBuffer());
   2351             } else {
   2352                 status = INVALID_OPERATION;
   2353             }
   2354         } else {
   2355             status = BAD_VALUE;
   2356         }
   2357     }
   2358     return status;
   2359 }
   2360 
   2361 void AudioFlinger::PlaybackThread::detachAuxEffect_l(int effectId)
   2362 {
   2363     for (size_t i = 0; i < mTracks.size(); ++i) {
   2364         sp<Track> track = mTracks[i];
   2365         if (track->auxEffectId() == effectId) {
   2366             attachAuxEffect_l(track, 0);
   2367         }
   2368     }
   2369 }
   2370 
   2371 bool AudioFlinger::PlaybackThread::threadLoop()
   2372 {
   2373     Vector< sp<Track> > tracksToRemove;
   2374 
   2375     standbyTime = systemTime();
   2376 
   2377     // MIXER
   2378     nsecs_t lastWarning = 0;
   2379 
   2380     // DUPLICATING
   2381     // FIXME could this be made local to while loop?
   2382     writeFrames = 0;
   2383 
   2384     int lastGeneration = 0;
   2385 
   2386     cacheParameters_l();
   2387     sleepTime = idleSleepTime;
   2388 
   2389     if (mType == MIXER) {
   2390         sleepTimeShift = 0;
   2391     }
   2392 
   2393     CpuStats cpuStats;
   2394     const String8 myName(String8::format("thread %p type %d TID %d", this, mType, gettid()));
   2395 
   2396     acquireWakeLock();
   2397 
   2398     // mNBLogWriter->log can only be called while thread mutex mLock is held.
   2399     // So if you need to log when mutex is unlocked, set logString to a non-NULL string,
   2400     // and then that string will be logged at the next convenient opportunity.
   2401     const char *logString = NULL;
   2402 
   2403     checkSilentMode_l();
   2404 
   2405     while (!exitPending())
   2406     {
   2407         cpuStats.sample(myName);
   2408 
   2409         Vector< sp<EffectChain> > effectChains;
   2410 
   2411         { // scope for mLock
   2412 
   2413             Mutex::Autolock _l(mLock);
   2414 
   2415             processConfigEvents_l();
   2416 
   2417             if (logString != NULL) {
   2418                 mNBLogWriter->logTimestamp();
   2419                 mNBLogWriter->log(logString);
   2420                 logString = NULL;
   2421             }
   2422 
   2423             // Gather the framesReleased counters for all active tracks,
   2424             // and latch them atomically with the timestamp.
   2425             // FIXME We're using raw pointers as indices. A unique track ID would be a better index.
   2426             mLatchD.mFramesReleased.clear();
   2427             size_t size = mActiveTracks.size();
   2428             for (size_t i = 0; i < size; i++) {
   2429                 sp<Track> t = mActiveTracks[i].promote();
   2430                 if (t != 0) {
   2431                     mLatchD.mFramesReleased.add(t.get(),
   2432                             t->mAudioTrackServerProxy->framesReleased());
   2433                 }
   2434             }
   2435             if (mLatchDValid) {
   2436                 mLatchQ = mLatchD;
   2437                 mLatchDValid = false;
   2438                 mLatchQValid = true;
   2439             }
   2440 
   2441             saveOutputTracks();
   2442             if (mSignalPending) {
   2443                 // A signal was raised while we were unlocked
   2444                 mSignalPending = false;
   2445             } else if (waitingAsyncCallback_l()) {
   2446                 if (exitPending()) {
   2447                     break;
   2448                 }
   2449                 releaseWakeLock_l();
   2450                 mWakeLockUids.clear();
   2451                 mActiveTracksGeneration++;
   2452                 ALOGV("wait async completion");
   2453                 mWaitWorkCV.wait(mLock);
   2454                 ALOGV("async completion/wake");
   2455                 acquireWakeLock_l();
   2456                 standbyTime = systemTime() + standbyDelay;
   2457                 sleepTime = 0;
   2458 
   2459                 continue;
   2460             }
   2461             if ((!mActiveTracks.size() && systemTime() > standbyTime) ||
   2462                                    isSuspended()) {
   2463                 // put audio hardware into standby after short delay
   2464                 if (shouldStandby_l()) {
   2465 
   2466                     threadLoop_standby();
   2467 
   2468                     mStandby = true;
   2469                 }
   2470 
   2471                 if (!mActiveTracks.size() && mConfigEvents.isEmpty()) {
   2472                     // we're about to wait, flush the binder command buffer
   2473                     IPCThreadState::self()->flushCommands();
   2474 
   2475                     clearOutputTracks();
   2476 
   2477                     if (exitPending()) {
   2478                         break;
   2479                     }
   2480 
   2481                     releaseWakeLock_l();
   2482                     mWakeLockUids.clear();
   2483                     mActiveTracksGeneration++;
   2484                     // wait until we have something to do...
   2485                     ALOGV("%s going to sleep", myName.string());
   2486                     mWaitWorkCV.wait(mLock);
   2487                     ALOGV("%s waking up", myName.string());
   2488                     acquireWakeLock_l();
   2489 
   2490                     mMixerStatus = MIXER_IDLE;
   2491                     mMixerStatusIgnoringFastTracks = MIXER_IDLE;
   2492                     mBytesWritten = 0;
   2493                     mBytesRemaining = 0;
   2494                     checkSilentMode_l();
   2495 
   2496                     standbyTime = systemTime() + standbyDelay;
   2497                     sleepTime = idleSleepTime;
   2498                     if (mType == MIXER) {
   2499                         sleepTimeShift = 0;
   2500                     }
   2501 
   2502                     continue;
   2503                 }
   2504             }
   2505             // mMixerStatusIgnoringFastTracks is also updated internally
   2506             mMixerStatus = prepareTracks_l(&tracksToRemove);
   2507 
   2508             // compare with previously applied list
   2509             if (lastGeneration != mActiveTracksGeneration) {
   2510                 // update wakelock
   2511                 updateWakeLockUids_l(mWakeLockUids);
   2512                 lastGeneration = mActiveTracksGeneration;
   2513             }
   2514 
   2515             // prevent any changes in effect chain list and in each effect chain
   2516             // during mixing and effect process as the audio buffers could be deleted
   2517             // or modified if an effect is created or deleted
   2518             lockEffectChains_l(effectChains);
   2519         } // mLock scope ends
   2520 
   2521         if (mBytesRemaining == 0) {
   2522             mCurrentWriteLength = 0;
   2523             if (mMixerStatus == MIXER_TRACKS_READY) {
   2524                 // threadLoop_mix() sets mCurrentWriteLength
   2525                 threadLoop_mix();
   2526             } else if ((mMixerStatus != MIXER_DRAIN_TRACK)
   2527                         && (mMixerStatus != MIXER_DRAIN_ALL)) {
   2528                 // threadLoop_sleepTime sets sleepTime to 0 if data
   2529                 // must be written to HAL
   2530                 threadLoop_sleepTime();
   2531                 if (sleepTime == 0) {
   2532                     mCurrentWriteLength = mSinkBufferSize;
   2533                 }
   2534             }
   2535             // Either threadLoop_mix() or threadLoop_sleepTime() should have set
   2536             // mMixerBuffer with data if mMixerBufferValid is true and sleepTime == 0.
   2537             // Merge mMixerBuffer data into mEffectBuffer (if any effects are valid)
   2538             // or mSinkBuffer (if there are no effects).
   2539             //
   2540             // This is done pre-effects computation; if effects change to
   2541             // support higher precision, this needs to move.
   2542             //
   2543             // mMixerBufferValid is only set true by MixerThread::prepareTracks_l().
   2544             // TODO use sleepTime == 0 as an additional condition.
   2545             if (mMixerBufferValid) {
   2546                 void *buffer = mEffectBufferValid ? mEffectBuffer : mSinkBuffer;
   2547                 audio_format_t format = mEffectBufferValid ? mEffectBufferFormat : mFormat;
   2548 
   2549                 memcpy_by_audio_format(buffer, format, mMixerBuffer, mMixerBufferFormat,
   2550                         mNormalFrameCount * mChannelCount);
   2551             }
   2552 
   2553             mBytesRemaining = mCurrentWriteLength;
   2554             if (isSuspended()) {
   2555                 sleepTime = suspendSleepTimeUs();
   2556                 // simulate write to HAL when suspended
   2557                 mBytesWritten += mSinkBufferSize;
   2558                 mBytesRemaining = 0;
   2559             }
   2560 
   2561             // only process effects if we're going to write
   2562             if (sleepTime == 0 && mType != OFFLOAD) {
   2563                 for (size_t i = 0; i < effectChains.size(); i ++) {
   2564                     effectChains[i]->process_l();
   2565                 }
   2566             }
   2567         }
   2568         // Process effect chains for offloaded thread even if no audio
   2569         // was read from audio track: process only updates effect state
   2570         // and thus does have to be synchronized with audio writes but may have
   2571         // to be called while waiting for async write callback
   2572         if (mType == OFFLOAD) {
   2573             for (size_t i = 0; i < effectChains.size(); i ++) {
   2574                 effectChains[i]->process_l();
   2575             }
   2576         }
   2577 
   2578         // Only if the Effects buffer is enabled and there is data in the
   2579         // Effects buffer (buffer valid), we need to
   2580         // copy into the sink buffer.
   2581         // TODO use sleepTime == 0 as an additional condition.
   2582         if (mEffectBufferValid) {
   2583             //ALOGV("writing effect buffer to sink buffer format %#x", mFormat);
   2584             memcpy_by_audio_format(mSinkBuffer, mFormat, mEffectBuffer, mEffectBufferFormat,
   2585                     mNormalFrameCount * mChannelCount);
   2586         }
   2587 
   2588         // enable changes in effect chain
   2589         unlockEffectChains(effectChains);
   2590 
   2591         if (!waitingAsyncCallback()) {
   2592             // sleepTime == 0 means we must write to audio hardware
   2593             if (sleepTime == 0) {
   2594                 if (mBytesRemaining) {
   2595                     ssize_t ret = threadLoop_write();
   2596                     if (ret < 0) {
   2597                         mBytesRemaining = 0;
   2598                     } else {
   2599                         mBytesWritten += ret;
   2600                         mBytesRemaining -= ret;
   2601                     }
   2602                 } else if ((mMixerStatus == MIXER_DRAIN_TRACK) ||
   2603                         (mMixerStatus == MIXER_DRAIN_ALL)) {
   2604                     threadLoop_drain();
   2605                 }
   2606                 if (mType == MIXER) {
   2607                     // write blocked detection
   2608                     nsecs_t now = systemTime();
   2609                     nsecs_t delta = now - mLastWriteTime;
   2610                     if (!mStandby && delta > maxPeriod) {
   2611                         mNumDelayedWrites++;
   2612                         if ((now - lastWarning) > kWarningThrottleNs) {
   2613                             ATRACE_NAME("underrun");
   2614                             ALOGW("write blocked for %llu msecs, %d delayed writes, thread %p",
   2615                                     ns2ms(delta), mNumDelayedWrites, this);
   2616                             lastWarning = now;
   2617                         }
   2618                     }
   2619                 }
   2620 
   2621             } else {
   2622                 usleep(sleepTime);
   2623             }
   2624         }
   2625 
   2626         // Finally let go of removed track(s), without the lock held
   2627         // since we can't guarantee the destructors won't acquire that
   2628         // same lock.  This will also mutate and push a new fast mixer state.
   2629         threadLoop_removeTracks(tracksToRemove);
   2630         tracksToRemove.clear();
   2631 
   2632         // FIXME I don't understand the need for this here;
   2633         //       it was in the original code but maybe the
   2634         //       assignment in saveOutputTracks() makes this unnecessary?
   2635         clearOutputTracks();
   2636 
   2637         // Effect chains will be actually deleted here if they were removed from
   2638         // mEffectChains list during mixing or effects processing
   2639         effectChains.clear();
   2640 
   2641         // FIXME Note that the above .clear() is no longer necessary since effectChains
   2642         // is now local to this block, but will keep it for now (at least until merge done).
   2643     }
   2644 
   2645     threadLoop_exit();
   2646 
   2647     if (!mStandby) {
   2648         threadLoop_standby();
   2649         mStandby = true;
   2650     }
   2651 
   2652     releaseWakeLock();
   2653     mWakeLockUids.clear();
   2654     mActiveTracksGeneration++;
   2655 
   2656     ALOGV("Thread %p type %d exiting", this, mType);
   2657     return false;
   2658 }
   2659 
   2660 // removeTracks_l() must be called with ThreadBase::mLock held
   2661 void AudioFlinger::PlaybackThread::removeTracks_l(const Vector< sp<Track> >& tracksToRemove)
   2662 {
   2663     size_t count = tracksToRemove.size();
   2664     if (count > 0) {
   2665         for (size_t i=0 ; i<count ; i++) {
   2666             const sp<Track>& track = tracksToRemove.itemAt(i);
   2667             mActiveTracks.remove(track);
   2668             mWakeLockUids.remove(track->uid());
   2669             mActiveTracksGeneration++;
   2670             ALOGV("removeTracks_l removing track on session %d", track->sessionId());
   2671             sp<EffectChain> chain = getEffectChain_l(track->sessionId());
   2672             if (chain != 0) {
   2673                 ALOGV("stopping track on chain %p for session Id: %d", chain.get(),
   2674                         track->sessionId());
   2675                 chain->decActiveTrackCnt();
   2676             }
   2677             if (track->isTerminated()) {
   2678                 removeTrack_l(track);
   2679             }
   2680         }
   2681     }
   2682 
   2683 }
   2684 
   2685 status_t AudioFlinger::PlaybackThread::getTimestamp_l(AudioTimestamp& timestamp)
   2686 {
   2687     if (mNormalSink != 0) {
   2688         return mNormalSink->getTimestamp(timestamp);
   2689     }
   2690     if ((mType == OFFLOAD || mType == DIRECT) && mOutput->stream->get_presentation_position) {
   2691         uint64_t position64;
   2692         int ret = mOutput->stream->get_presentation_position(
   2693                                                 mOutput->stream, &position64, &timestamp.mTime);
   2694         if (ret == 0) {
   2695             timestamp.mPosition = (uint32_t)position64;
   2696             return NO_ERROR;
   2697         }
   2698     }
   2699     return INVALID_OPERATION;
   2700 }
   2701 
   2702 status_t AudioFlinger::PlaybackThread::createAudioPatch_l(const struct audio_patch *patch,
   2703                                                           audio_patch_handle_t *handle)
   2704 {
   2705     status_t status = NO_ERROR;
   2706     if (mOutput->audioHwDev->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
   2707         // store new device and send to effects
   2708         audio_devices_t type = AUDIO_DEVICE_NONE;
   2709         for (unsigned int i = 0; i < patch->num_sinks; i++) {
   2710             type |= patch->sinks[i].ext.device.type;
   2711         }
   2712         mOutDevice = type;
   2713         for (size_t i = 0; i < mEffectChains.size(); i++) {
   2714             mEffectChains[i]->setDevice_l(mOutDevice);
   2715         }
   2716 
   2717         audio_hw_device_t *hwDevice = mOutput->audioHwDev->hwDevice();
   2718         status = hwDevice->create_audio_patch(hwDevice,
   2719                                                patch->num_sources,
   2720                                                patch->sources,
   2721                                                patch->num_sinks,
   2722                                                patch->sinks,
   2723                                                handle);
   2724     } else {
   2725         ALOG_ASSERT(false, "createAudioPatch_l() called on a pre 3.0 HAL");
   2726     }
   2727     return status;
   2728 }
   2729 
   2730 status_t AudioFlinger::PlaybackThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
   2731 {
   2732     status_t status = NO_ERROR;
   2733     if (mOutput->audioHwDev->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
   2734         audio_hw_device_t *hwDevice = mOutput->audioHwDev->hwDevice();
   2735         status = hwDevice->release_audio_patch(hwDevice, handle);
   2736     } else {
   2737         ALOG_ASSERT(false, "releaseAudioPatch_l() called on a pre 3.0 HAL");
   2738     }
   2739     return status;
   2740 }
   2741 
   2742 void AudioFlinger::PlaybackThread::addPatchTrack(const sp<PatchTrack>& track)
   2743 {
   2744     Mutex::Autolock _l(mLock);
   2745     mTracks.add(track);
   2746 }
   2747 
   2748 void AudioFlinger::PlaybackThread::deletePatchTrack(const sp<PatchTrack>& track)
   2749 {
   2750     Mutex::Autolock _l(mLock);
   2751     destroyTrack_l(track);
   2752 }
   2753 
   2754 void AudioFlinger::PlaybackThread::getAudioPortConfig(struct audio_port_config *config)
   2755 {
   2756     ThreadBase::getAudioPortConfig(config);
   2757     config->role = AUDIO_PORT_ROLE_SOURCE;
   2758     config->ext.mix.hw_module = mOutput->audioHwDev->handle();
   2759     config->ext.mix.usecase.stream = AUDIO_STREAM_DEFAULT;
   2760 }
   2761 
   2762 // ----------------------------------------------------------------------------
   2763 
   2764 AudioFlinger::MixerThread::MixerThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
   2765         audio_io_handle_t id, audio_devices_t device, type_t type)
   2766     :   PlaybackThread(audioFlinger, output, id, device, type),
   2767         // mAudioMixer below
   2768         // mFastMixer below
   2769         mFastMixerFutex(0)
   2770         // mOutputSink below
   2771         // mPipeSink below
   2772         // mNormalSink below
   2773 {
   2774     ALOGV("MixerThread() id=%d device=%#x type=%d", id, device, type);
   2775     ALOGV("mSampleRate=%u, mChannelMask=%#x, mChannelCount=%u, mFormat=%d, mFrameSize=%u, "
   2776             "mFrameCount=%d, mNormalFrameCount=%d",
   2777             mSampleRate, mChannelMask, mChannelCount, mFormat, mFrameSize, mFrameCount,
   2778             mNormalFrameCount);
   2779     mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
   2780 
   2781     // create an NBAIO sink for the HAL output stream, and negotiate
   2782     mOutputSink = new AudioStreamOutSink(output->stream);
   2783     size_t numCounterOffers = 0;
   2784     const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount, mFormat)};
   2785     ssize_t index = mOutputSink->negotiate(offers, 1, NULL, numCounterOffers);
   2786     ALOG_ASSERT(index == 0);
   2787 
   2788     // initialize fast mixer depending on configuration
   2789     bool initFastMixer;
   2790     switch (kUseFastMixer) {
   2791     case FastMixer_Never:
   2792         initFastMixer = false;
   2793         break;
   2794     case FastMixer_Always:
   2795         initFastMixer = true;
   2796         break;
   2797     case FastMixer_Static:
   2798     case FastMixer_Dynamic:
   2799         initFastMixer = mFrameCount < mNormalFrameCount;
   2800         break;
   2801     }
   2802     if (initFastMixer) {
   2803         audio_format_t fastMixerFormat;
   2804         if (mMixerBufferEnabled && mEffectBufferEnabled) {
   2805             fastMixerFormat = AUDIO_FORMAT_PCM_FLOAT;
   2806         } else {
   2807             fastMixerFormat = AUDIO_FORMAT_PCM_16_BIT;
   2808         }
   2809         if (mFormat != fastMixerFormat) {
   2810             // change our Sink format to accept our intermediate precision
   2811             mFormat = fastMixerFormat;
   2812             free(mSinkBuffer);
   2813             mFrameSize = mChannelCount * audio_bytes_per_sample(mFormat);
   2814             const size_t sinkBufferSize = mNormalFrameCount * mFrameSize;
   2815             (void)posix_memalign(&mSinkBuffer, 32, sinkBufferSize);
   2816         }
   2817 
   2818         // create a MonoPipe to connect our submix to FastMixer
   2819         NBAIO_Format format = mOutputSink->format();
   2820         NBAIO_Format origformat = format;
   2821         // adjust format to match that of the Fast Mixer
   2822         format.mFormat = fastMixerFormat;
   2823         format.mFrameSize = audio_bytes_per_sample(format.mFormat) * format.mChannelCount;
   2824 
   2825         // This pipe depth compensates for scheduling latency of the normal mixer thread.
   2826         // When it wakes up after a maximum latency, it runs a few cycles quickly before
   2827         // finally blocking.  Note the pipe implementation rounds up the request to a power of 2.
   2828         MonoPipe *monoPipe = new MonoPipe(mNormalFrameCount * 4, format, true /*writeCanBlock*/);
   2829         const NBAIO_Format offers[1] = {format};
   2830         size_t numCounterOffers = 0;
   2831         ssize_t index = monoPipe->negotiate(offers, 1, NULL, numCounterOffers);
   2832         ALOG_ASSERT(index == 0);
   2833         monoPipe->setAvgFrames((mScreenState & 1) ?
   2834                 (monoPipe->maxFrames() * 7) / 8 : mNormalFrameCount * 2);
   2835         mPipeSink = monoPipe;
   2836 
   2837 #ifdef TEE_SINK
   2838         if (mTeeSinkOutputEnabled) {
   2839             // create a Pipe to archive a copy of FastMixer's output for dumpsys
   2840             Pipe *teeSink = new Pipe(mTeeSinkOutputFrames, origformat);
   2841             const NBAIO_Format offers2[1] = {origformat};
   2842             numCounterOffers = 0;
   2843             index = teeSink->negotiate(offers2, 1, NULL, numCounterOffers);
   2844             ALOG_ASSERT(index == 0);
   2845             mTeeSink = teeSink;
   2846             PipeReader *teeSource = new PipeReader(*teeSink);
   2847             numCounterOffers = 0;
   2848             index = teeSource->negotiate(offers2, 1, NULL, numCounterOffers);
   2849             ALOG_ASSERT(index == 0);
   2850             mTeeSource = teeSource;
   2851         }
   2852 #endif
   2853 
   2854         // create fast mixer and configure it initially with just one fast track for our submix
   2855         mFastMixer = new FastMixer();
   2856         FastMixerStateQueue *sq = mFastMixer->sq();
   2857 #ifdef STATE_QUEUE_DUMP
   2858         sq->setObserverDump(&mStateQueueObserverDump);
   2859         sq->setMutatorDump(&mStateQueueMutatorDump);
   2860 #endif
   2861         FastMixerState *state = sq->begin();
   2862         FastTrack *fastTrack = &state->mFastTracks[0];
   2863         // wrap the source side of the MonoPipe to make it an AudioBufferProvider
   2864         fastTrack->mBufferProvider = new SourceAudioBufferProvider(new MonoPipeReader(monoPipe));
   2865         fastTrack->mVolumeProvider = NULL;
   2866         fastTrack->mChannelMask = mChannelMask; // mPipeSink channel mask for audio to FastMixer
   2867         fastTrack->mFormat = mFormat; // mPipeSink format for audio to FastMixer
   2868         fastTrack->mGeneration++;
   2869         state->mFastTracksGen++;
   2870         state->mTrackMask = 1;
   2871         // fast mixer will use the HAL output sink
   2872         state->mOutputSink = mOutputSink.get();
   2873         state->mOutputSinkGen++;
   2874         state->mFrameCount = mFrameCount;
   2875         state->mCommand = FastMixerState::COLD_IDLE;
   2876         // already done in constructor initialization list
   2877         //mFastMixerFutex = 0;
   2878         state->mColdFutexAddr = &mFastMixerFutex;
   2879         state->mColdGen++;
   2880         state->mDumpState = &mFastMixerDumpState;
   2881 #ifdef TEE_SINK
   2882         state->mTeeSink = mTeeSink.get();
   2883 #endif
   2884         mFastMixerNBLogWriter = audioFlinger->newWriter_l(kFastMixerLogSize, "FastMixer");
   2885         state->mNBLogWriter = mFastMixerNBLogWriter.get();
   2886         sq->end();
   2887         sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
   2888 
   2889         // start the fast mixer
   2890         mFastMixer->run("FastMixer", PRIORITY_URGENT_AUDIO);
   2891         pid_t tid = mFastMixer->getTid();
   2892         int err = requestPriority(getpid_cached, tid, kPriorityFastMixer);
   2893         if (err != 0) {
   2894             ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
   2895                     kPriorityFastMixer, getpid_cached, tid, err);
   2896         }
   2897 
   2898 #ifdef AUDIO_WATCHDOG
   2899         // create and start the watchdog
   2900         mAudioWatchdog = new AudioWatchdog();
   2901         mAudioWatchdog->setDump(&mAudioWatchdogDump);
   2902         mAudioWatchdog->run("AudioWatchdog", PRIORITY_URGENT_AUDIO);
   2903         tid = mAudioWatchdog->getTid();
   2904         err = requestPriority(getpid_cached, tid, kPriorityFastMixer);
   2905         if (err != 0) {
   2906             ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
   2907                     kPriorityFastMixer, getpid_cached, tid, err);
   2908         }
   2909 #endif
   2910 
   2911     }
   2912 
   2913     switch (kUseFastMixer) {
   2914     case FastMixer_Never:
   2915     case FastMixer_Dynamic:
   2916         mNormalSink = mOutputSink;
   2917         break;
   2918     case FastMixer_Always:
   2919         mNormalSink = mPipeSink;
   2920         break;
   2921     case FastMixer_Static:
   2922         mNormalSink = initFastMixer ? mPipeSink : mOutputSink;
   2923         break;
   2924     }
   2925 }
   2926 
   2927 AudioFlinger::MixerThread::~MixerThread()
   2928 {
   2929     if (mFastMixer != 0) {
   2930         FastMixerStateQueue *sq = mFastMixer->sq();
   2931         FastMixerState *state = sq->begin();
   2932         if (state->mCommand == FastMixerState::COLD_IDLE) {
   2933             int32_t old = android_atomic_inc(&mFastMixerFutex);
   2934             if (old == -1) {
   2935                 (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
   2936             }
   2937         }
   2938         state->mCommand = FastMixerState::EXIT;
   2939         sq->end();
   2940         sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
   2941         mFastMixer->join();
   2942         // Though the fast mixer thread has exited, it's state queue is still valid.
   2943         // We'll use that extract the final state which contains one remaining fast track
   2944         // corresponding to our sub-mix.
   2945         state = sq->begin();
   2946         ALOG_ASSERT(state->mTrackMask == 1);
   2947         FastTrack *fastTrack = &state->mFastTracks[0];
   2948         ALOG_ASSERT(fastTrack->mBufferProvider != NULL);
   2949         delete fastTrack->mBufferProvider;
   2950         sq->end(false /*didModify*/);
   2951         mFastMixer.clear();
   2952 #ifdef AUDIO_WATCHDOG
   2953         if (mAudioWatchdog != 0) {
   2954             mAudioWatchdog->requestExit();
   2955             mAudioWatchdog->requestExitAndWait();
   2956             mAudioWatchdog.clear();
   2957         }
   2958 #endif
   2959     }
   2960     mAudioFlinger->unregisterWriter(mFastMixerNBLogWriter);
   2961     delete mAudioMixer;
   2962 }
   2963 
   2964 
   2965 uint32_t AudioFlinger::MixerThread::correctLatency_l(uint32_t latency) const
   2966 {
   2967     if (mFastMixer != 0) {
   2968         MonoPipe *pipe = (MonoPipe *)mPipeSink.get();
   2969         latency += (pipe->getAvgFrames() * 1000) / mSampleRate;
   2970     }
   2971     return latency;
   2972 }
   2973 
   2974 
   2975 void AudioFlinger::MixerThread::threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove)
   2976 {
   2977     PlaybackThread::threadLoop_removeTracks(tracksToRemove);
   2978 }
   2979 
   2980 ssize_t AudioFlinger::MixerThread::threadLoop_write()
   2981 {
   2982     // FIXME we should only do one push per cycle; confirm this is true
   2983     // Start the fast mixer if it's not already running
   2984     if (mFastMixer != 0) {
   2985         FastMixerStateQueue *sq = mFastMixer->sq();
   2986         FastMixerState *state = sq->begin();
   2987         if (state->mCommand != FastMixerState::MIX_WRITE &&
   2988                 (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)) {
   2989             if (state->mCommand == FastMixerState::COLD_IDLE) {
   2990                 int32_t old = android_atomic_inc(&mFastMixerFutex);
   2991                 if (old == -1) {
   2992                     (void) syscall(__NR_futex, &mFastMixerFutex, FUTEX_WAKE_PRIVATE, 1);
   2993                 }
   2994 #ifdef AUDIO_WATCHDOG
   2995                 if (mAudioWatchdog != 0) {
   2996                     mAudioWatchdog->resume();
   2997                 }
   2998 #endif
   2999             }
   3000             state->mCommand = FastMixerState::MIX_WRITE;
   3001             mFastMixerDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
   3002                     FastMixerDumpState::kSamplingNforLowRamDevice : FastMixerDumpState::kSamplingN);
   3003             sq->end();
   3004             sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
   3005             if (kUseFastMixer == FastMixer_Dynamic) {
   3006                 mNormalSink = mPipeSink;
   3007             }
   3008         } else {
   3009             sq->end(false /*didModify*/);
   3010         }
   3011     }
   3012     return PlaybackThread::threadLoop_write();
   3013 }
   3014 
   3015 void AudioFlinger::MixerThread::threadLoop_standby()
   3016 {
   3017     // Idle the fast mixer if it's currently running
   3018     if (mFastMixer != 0) {
   3019         FastMixerStateQueue *sq = mFastMixer->sq();
   3020         FastMixerState *state = sq->begin();
   3021         if (!(state->mCommand & FastMixerState::IDLE)) {
   3022             state->mCommand = FastMixerState::COLD_IDLE;
   3023             state->mColdFutexAddr = &mFastMixerFutex;
   3024             state->mColdGen++;
   3025             mFastMixerFutex = 0;
   3026             sq->end();
   3027             // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
   3028             sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
   3029             if (kUseFastMixer == FastMixer_Dynamic) {
   3030                 mNormalSink = mOutputSink;
   3031             }
   3032 #ifdef AUDIO_WATCHDOG
   3033             if (mAudioWatchdog != 0) {
   3034                 mAudioWatchdog->pause();
   3035             }
   3036 #endif
   3037         } else {
   3038             sq->end(false /*didModify*/);
   3039         }
   3040     }
   3041     PlaybackThread::threadLoop_standby();
   3042 }
   3043 
   3044 bool AudioFlinger::PlaybackThread::waitingAsyncCallback_l()
   3045 {
   3046     return false;
   3047 }
   3048 
   3049 bool AudioFlinger::PlaybackThread::shouldStandby_l()
   3050 {
   3051     return !mStandby;
   3052 }
   3053 
   3054 bool AudioFlinger::PlaybackThread::waitingAsyncCallback()
   3055 {
   3056     Mutex::Autolock _l(mLock);
   3057     return waitingAsyncCallback_l();
   3058 }
   3059 
   3060 // shared by MIXER and DIRECT, overridden by DUPLICATING
   3061 void AudioFlinger::PlaybackThread::threadLoop_standby()
   3062 {
   3063     ALOGV("Audio hardware entering standby, mixer %p, suspend count %d", this, mSuspended);
   3064     mOutput->stream->common.standby(&mOutput->stream->common);
   3065     if (mUseAsyncWrite != 0) {
   3066         // discard any pending drain or write ack by incrementing sequence
   3067         mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
   3068         mDrainSequence = (mDrainSequence + 2) & ~1;
   3069         ALOG_ASSERT(mCallbackThread != 0);
   3070         mCallbackThread->setWriteBlocked(mWriteAckSequence);
   3071         mCallbackThread->setDraining(mDrainSequence);
   3072     }
   3073 }
   3074 
   3075 void AudioFlinger::PlaybackThread::onAddNewTrack_l()
   3076 {
   3077     ALOGV("signal playback thread");
   3078     broadcast_l();
   3079 }
   3080 
   3081 void AudioFlinger::MixerThread::threadLoop_mix()
   3082 {
   3083     // obtain the presentation timestamp of the next output buffer
   3084     int64_t pts;
   3085     status_t status = INVALID_OPERATION;
   3086 
   3087     if (mNormalSink != 0) {
   3088         status = mNormalSink->getNextWriteTimestamp(&pts);
   3089     } else {
   3090         status = mOutputSink->getNextWriteTimestamp(&pts);
   3091     }
   3092 
   3093     if (status != NO_ERROR) {
   3094         pts = AudioBufferProvider::kInvalidPTS;
   3095     }
   3096 
   3097     // mix buffers...
   3098     mAudioMixer->process(pts);
   3099     mCurrentWriteLength = mSinkBufferSize;
   3100     // increase sleep time progressively when application underrun condition clears.
   3101     // Only increase sleep time if the mixer is ready for two consecutive times to avoid
   3102     // that a steady state of alternating ready/not ready conditions keeps the sleep time
   3103     // such that we would underrun the audio HAL.
   3104     if ((sleepTime == 0) && (sleepTimeShift > 0)) {
   3105         sleepTimeShift--;
   3106     }
   3107     sleepTime = 0;
   3108     standbyTime = systemTime() + standbyDelay;
   3109     //TODO: delay standby when effects have a tail
   3110 
   3111 }
   3112 
   3113 void AudioFlinger::MixerThread::threadLoop_sleepTime()
   3114 {
   3115     // If no tracks are ready, sleep once for the duration of an output
   3116     // buffer size, then write 0s to the output
   3117     if (sleepTime == 0) {
   3118         if (mMixerStatus == MIXER_TRACKS_ENABLED) {
   3119             sleepTime = activeSleepTime >> sleepTimeShift;
   3120             if (sleepTime < kMinThreadSleepTimeUs) {
   3121                 sleepTime = kMinThreadSleepTimeUs;
   3122             }
   3123             // reduce sleep time in case of consecutive application underruns to avoid
   3124             // starving the audio HAL. As activeSleepTimeUs() is larger than a buffer
   3125             // duration we would end up writing less data than needed by the audio HAL if
   3126             // the condition persists.
   3127             if (sleepTimeShift < kMaxThreadSleepTimeShift) {
   3128                 sleepTimeShift++;
   3129             }
   3130         } else {
   3131             sleepTime = idleSleepTime;
   3132         }
   3133     } else if (mBytesWritten != 0 || (mMixerStatus == MIXER_TRACKS_ENABLED)) {
   3134         // clear out mMixerBuffer or mSinkBuffer, to ensure buffers are cleared
   3135         // before effects processing or output.
   3136         if (mMixerBufferValid) {
   3137             memset(mMixerBuffer, 0, mMixerBufferSize);
   3138         } else {
   3139             memset(mSinkBuffer, 0, mSinkBufferSize);
   3140         }
   3141         sleepTime = 0;
   3142         ALOGV_IF(mBytesWritten == 0 && (mMixerStatus == MIXER_TRACKS_ENABLED),
   3143                 "anticipated start");
   3144     }
   3145     // TODO add standby time extension fct of effect tail
   3146 }
   3147 
   3148 // prepareTracks_l() must be called with ThreadBase::mLock held
   3149 AudioFlinger::PlaybackThread::mixer_state AudioFlinger::MixerThread::prepareTracks_l(
   3150         Vector< sp<Track> > *tracksToRemove)
   3151 {
   3152 
   3153     mixer_state mixerStatus = MIXER_IDLE;
   3154     // find out which tracks need to be processed
   3155     size_t count = mActiveTracks.size();
   3156     size_t mixedTracks = 0;
   3157     size_t tracksWithEffect = 0;
   3158     // counts only _active_ fast tracks
   3159     size_t fastTracks = 0;
   3160     uint32_t resetMask = 0; // bit mask of fast tracks that need to be reset
   3161 
   3162     float masterVolume = mMasterVolume;
   3163     bool masterMute = mMasterMute;
   3164 
   3165     if (masterMute) {
   3166         masterVolume = 0;
   3167     }
   3168     // Delegate master volume control to effect in output mix effect chain if needed
   3169     sp<EffectChain> chain = getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX);
   3170     if (chain != 0) {
   3171         uint32_t v = (uint32_t)(masterVolume * (1 << 24));
   3172         chain->setVolume_l(&v, &v);
   3173         masterVolume = (float)((v + (1 << 23)) >> 24);
   3174         chain.clear();
   3175     }
   3176 
   3177     // prepare a new state to push
   3178     FastMixerStateQueue *sq = NULL;
   3179     FastMixerState *state = NULL;
   3180     bool didModify = false;
   3181     FastMixerStateQueue::block_t block = FastMixerStateQueue::BLOCK_UNTIL_PUSHED;
   3182     if (mFastMixer != 0) {
   3183         sq = mFastMixer->sq();
   3184         state = sq->begin();
   3185     }
   3186 
   3187     mMixerBufferValid = false;  // mMixerBuffer has no valid data until appropriate tracks found.
   3188     mEffectBufferValid = false; // mEffectBuffer has no valid data until tracks found.
   3189 
   3190     for (size_t i=0 ; i<count ; i++) {
   3191         const sp<Track> t = mActiveTracks[i].promote();
   3192         if (t == 0) {
   3193             continue;
   3194         }
   3195 
   3196         // this const just means the local variable doesn't change
   3197         Track* const track = t.get();
   3198 
   3199         // process fast tracks
   3200         if (track->isFastTrack()) {
   3201 
   3202             // It's theoretically possible (though unlikely) for a fast track to be created
   3203             // and then removed within the same normal mix cycle.  This is not a problem, as
   3204             // the track never becomes active so it's fast mixer slot is never touched.
   3205             // The converse, of removing an (active) track and then creating a new track
   3206             // at the identical fast mixer slot within the same normal mix cycle,
   3207             // is impossible because the slot isn't marked available until the end of each cycle.
   3208             int j = track->mFastIndex;
   3209             ALOG_ASSERT(0 < j && j < (int)FastMixerState::kMaxFastTracks);
   3210             ALOG_ASSERT(!(mFastTrackAvailMask & (1 << j)));
   3211             FastTrack *fastTrack = &state->mFastTracks[j];
   3212 
   3213             // Determine whether the track is currently in underrun condition,
   3214             // and whether it had a recent underrun.
   3215             FastTrackDump *ftDump = &mFastMixerDumpState.mTracks[j];
   3216             FastTrackUnderruns underruns = ftDump->mUnderruns;
   3217             uint32_t recentFull = (underruns.mBitFields.mFull -
   3218                     track->mObservedUnderruns.mBitFields.mFull) & UNDERRUN_MASK;
   3219             uint32_t recentPartial = (underruns.mBitFields.mPartial -
   3220                     track->mObservedUnderruns.mBitFields.mPartial) & UNDERRUN_MASK;
   3221             uint32_t recentEmpty = (underruns.mBitFields.mEmpty -
   3222                     track->mObservedUnderruns.mBitFields.mEmpty) & UNDERRUN_MASK;
   3223             uint32_t recentUnderruns = recentPartial + recentEmpty;
   3224             track->mObservedUnderruns = underruns;
   3225             // don't count underruns that occur while stopping or pausing
   3226             // or stopped which can occur when flush() is called while active
   3227             if (!(track->isStopping() || track->isPausing() || track->isStopped()) &&
   3228                     recentUnderruns > 0) {
   3229                 // FIXME fast mixer will pull & mix partial buffers, but we count as a full underrun
   3230                 track->mAudioTrackServerProxy->tallyUnderrunFrames(recentUnderruns * mFrameCount);
   3231             }
   3232 
   3233             // This is similar to the state machine for normal tracks,
   3234             // with a few modifications for fast tracks.
   3235             bool isActive = true;
   3236             switch (track->mState) {
   3237             case TrackBase::STOPPING_1:
   3238                 // track stays active in STOPPING_1 state until first underrun
   3239                 if (recentUnderruns > 0 || track->isTerminated()) {
   3240                     track->mState = TrackBase::STOPPING_2;
   3241                 }
   3242                 break;
   3243             case TrackBase::PAUSING:
   3244                 // ramp down is not yet implemented
   3245                 track->setPaused();
   3246                 break;
   3247             case TrackBase::RESUMING:
   3248                 // ramp up is not yet implemented
   3249                 track->mState = TrackBase::ACTIVE;
   3250                 break;
   3251             case TrackBase::ACTIVE:
   3252                 if (recentFull > 0 || recentPartial > 0) {
   3253                     // track has provided at least some frames recently: reset retry count
   3254                     track->mRetryCount = kMaxTrackRetries;
   3255                 }
   3256                 if (recentUnderruns == 0) {
   3257                     // no recent underruns: stay active
   3258                     break;
   3259                 }
   3260                 // there has recently been an underrun of some kind
   3261                 if (track->sharedBuffer() == 0) {
   3262                     // were any of the recent underruns "empty" (no frames available)?
   3263                     if (recentEmpty == 0) {
   3264                         // no, then ignore the partial underruns as they are allowed indefinitely
   3265                         break;
   3266                     }
   3267                     // there has recently been an "empty" underrun: decrement the retry counter
   3268                     if (--(track->mRetryCount) > 0) {
   3269                         break;
   3270                     }
   3271                     // indicate to client process that the track was disabled because of underrun;
   3272                     // it will then automatically call start() when data is available
   3273                     android_atomic_or(CBLK_DISABLED, &track->mCblk->mFlags);
   3274                     // remove from active list, but state remains ACTIVE [confusing but true]
   3275                     isActive = false;
   3276                     break;
   3277                 }
   3278                 // fall through
   3279             case TrackBase::STOPPING_2:
   3280             case TrackBase::PAUSED:
   3281             case TrackBase::STOPPED:
   3282             case TrackBase::FLUSHED:   // flush() while active
   3283                 // Check for presentation complete if track is inactive
   3284                 // We have consumed all the buffers of this track.
   3285                 // This would be incomplete if we auto-paused on underrun
   3286                 {
   3287                     size_t audioHALFrames =
   3288                             (mOutput->stream->get_latency(mOutput->stream)*mSampleRate) / 1000;
   3289                     size_t framesWritten = mBytesWritten / mFrameSize;
   3290                     if (!(mStandby || track->presentationComplete(framesWritten, audioHALFrames))) {
   3291                         // track stays in active list until presentation is complete
   3292                         break;
   3293                     }
   3294                 }
   3295                 if (track->isStopping_2()) {
   3296                     track->mState = TrackBase::STOPPED;
   3297                 }
   3298                 if (track->isStopped()) {
   3299                     // Can't reset directly, as fast mixer is still polling this track
   3300                     //   track->reset();
   3301                     // So instead mark this track as needing to be reset after push with ack
   3302                     resetMask |= 1 << i;
   3303                 }
   3304                 isActive = false;
   3305                 break;
   3306             case TrackBase::IDLE:
   3307             default:
   3308                 LOG_ALWAYS_FATAL("unexpected track state %d", track->mState);
   3309             }
   3310 
   3311             if (isActive) {
   3312                 // was it previously inactive?
   3313                 if (!(state->mTrackMask & (1 << j))) {
   3314                     ExtendedAudioBufferProvider *eabp = track;
   3315                     VolumeProvider *vp = track;
   3316                     fastTrack->mBufferProvider = eabp;
   3317                     fastTrack->mVolumeProvider = vp;
   3318                     fastTrack->mChannelMask = track->mChannelMask;
   3319                     fastTrack->mFormat = track->mFormat;
   3320                     fastTrack->mGeneration++;
   3321                     state->mTrackMask |= 1 << j;
   3322                     didModify = true;
   3323                     // no acknowledgement required for newly active tracks
   3324                 }
   3325                 // cache the combined master volume and stream type volume for fast mixer; this
   3326                 // lacks any synchronization or barrier so VolumeProvider may read a stale value
   3327                 track->mCachedVolume = masterVolume * mStreamTypes[track->streamType()].volume;
   3328                 ++fastTracks;
   3329             } else {
   3330                 // was it previously active?
   3331                 if (state->mTrackMask & (1 << j)) {
   3332                     fastTrack->mBufferProvider = NULL;
   3333                     fastTrack->mGeneration++;
   3334                     state->mTrackMask &= ~(1 << j);
   3335                     didModify = true;
   3336                     // If any fast tracks were removed, we must wait for acknowledgement
   3337                     // because we're about to decrement the last sp<> on those tracks.
   3338                     block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
   3339                 } else {
   3340                     LOG_ALWAYS_FATAL("fast track %d should have been active", j);
   3341                 }
   3342                 tracksToRemove->add(track);
   3343                 // Avoids a misleading display in dumpsys
   3344                 track->mObservedUnderruns.mBitFields.mMostRecent = UNDERRUN_FULL;
   3345             }
   3346             continue;
   3347         }
   3348 
   3349         {   // local variable scope to avoid goto warning
   3350 
   3351         audio_track_cblk_t* cblk = track->cblk();
   3352 
   3353         // The first time a track is added we wait
   3354         // for all its buffers to be filled before processing it
   3355         int name = track->name();
   3356         // make sure that we have enough frames to mix one full buffer.
   3357         // enforce this condition only once to enable draining the buffer in case the client
   3358         // app does not call stop() and relies on underrun to stop:
   3359         // hence the test on (mMixerStatus == MIXER_TRACKS_READY) meaning the track was mixed
   3360         // during last round
   3361         size_t desiredFrames;
   3362         uint32_t sr = track->sampleRate();
   3363         if (sr == mSampleRate) {
   3364             desiredFrames = mNormalFrameCount;
   3365         } else {
   3366             // +1 for rounding and +1 for additional sample needed for interpolation
   3367             desiredFrames = (mNormalFrameCount * sr) / mSampleRate + 1 + 1;
   3368             // add frames already consumed but not yet released by the resampler
   3369             // because mAudioTrackServerProxy->framesReady() will include these frames
   3370             desiredFrames += mAudioMixer->getUnreleasedFrames(track->name());
   3371 #if 0
   3372             // the minimum track buffer size is normally twice the number of frames necessary
   3373             // to fill one buffer and the resampler should not leave more than one buffer worth
   3374             // of unreleased frames after each pass, but just in case...
   3375             ALOG_ASSERT(desiredFrames <= cblk->frameCount_);
   3376 #endif
   3377         }
   3378         uint32_t minFrames = 1;
   3379         if ((track->sharedBuffer() == 0) && !track->isStopped() && !track->isPausing() &&
   3380                 (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY)) {
   3381             minFrames = desiredFrames;
   3382         }
   3383 
   3384         size_t framesReady = track->framesReady();
   3385         if ((framesReady >= minFrames) && track->isReady() &&
   3386                 !track->isPaused() && !track->isTerminated())
   3387         {
   3388             ALOGVV("track %d s=%08x [OK] on thread %p", name, cblk->mServer, this);
   3389 
   3390             mixedTracks++;
   3391 
   3392             // track->mainBuffer() != mSinkBuffer or mMixerBuffer means
   3393             // there is an effect chain connected to the track
   3394             chain.clear();
   3395             if (track->mainBuffer() != mSinkBuffer &&
   3396                     track->mainBuffer() != mMixerBuffer) {
   3397                 if (mEffectBufferEnabled) {
   3398                     mEffectBufferValid = true; // Later can set directly.
   3399                 }
   3400                 chain = getEffectChain_l(track->sessionId());
   3401                 // Delegate volume control to effect in track effect chain if needed
   3402                 if (chain != 0) {
   3403                     tracksWithEffect++;
   3404                 } else {
   3405                     ALOGW("prepareTracks_l(): track %d attached to effect but no chain found on "
   3406                             "session %d",
   3407                             name, track->sessionId());
   3408                 }
   3409             }
   3410 
   3411 
   3412             int param = AudioMixer::VOLUME;
   3413             if (track->mFillingUpStatus == Track::FS_FILLED) {
   3414                 // no ramp for the first volume setting
   3415                 track->mFillingUpStatus = Track::FS_ACTIVE;
   3416                 if (track->mState == TrackBase::RESUMING) {
   3417                     track->mState = TrackBase::ACTIVE;
   3418                     param = AudioMixer::RAMP_VOLUME;
   3419                 }
   3420                 mAudioMixer->setParameter(name, AudioMixer::RESAMPLE, AudioMixer::RESET, NULL);
   3421             // FIXME should not make a decision based on mServer
   3422             } else if (cblk->mServer != 0) {
   3423                 // If the track is stopped before the first frame was mixed,
   3424                 // do not apply ramp
   3425                 param = AudioMixer::RAMP_VOLUME;
   3426             }
   3427 
   3428             // compute volume for this track
   3429             uint32_t vl, vr;       // in U8.24 integer format
   3430             float vlf, vrf, vaf;   // in [0.0, 1.0] float format
   3431             if (track->isPausing() || mStreamTypes[track->streamType()].mute) {
   3432                 vl = vr = 0;
   3433                 vlf = vrf = vaf = 0.;
   3434                 if (track->isPausing()) {
   3435                     track->setPaused();
   3436                 }
   3437             } else {
   3438 
   3439                 // read original volumes with volume control
   3440                 float typeVolume = mStreamTypes[track->streamType()].volume;
   3441                 float v = masterVolume * typeVolume;
   3442                 AudioTrackServerProxy *proxy = track->mAudioTrackServerProxy;
   3443                 gain_minifloat_packed_t vlr = proxy->getVolumeLR();
   3444                 vlf = float_from_gain(gain_minifloat_unpack_left(vlr));
   3445                 vrf = float_from_gain(gain_minifloat_unpack_right(vlr));
   3446                 // track volumes come from shared memory, so can't be trusted and must be clamped
   3447                 if (vlf > GAIN_FLOAT_UNITY) {
   3448                     ALOGV("Track left volume out of range: %.3g", vlf);
   3449                     vlf = GAIN_FLOAT_UNITY;
   3450                 }
   3451                 if (vrf > GAIN_FLOAT_UNITY) {
   3452                     ALOGV("Track right volume out of range: %.3g", vrf);
   3453                     vrf = GAIN_FLOAT_UNITY;
   3454                 }
   3455                 // now apply the master volume and stream type volume
   3456                 vlf *= v;
   3457                 vrf *= v;
   3458                 // assuming master volume and stream type volume each go up to 1.0,
   3459                 // then derive vl and vr as U8.24 versions for the effect chain
   3460                 const float scaleto8_24 = MAX_GAIN_INT * MAX_GAIN_INT;
   3461                 vl = (uint32_t) (scaleto8_24 * vlf);
   3462                 vr = (uint32_t) (scaleto8_24 * vrf);
   3463                 // vl and vr are now in U8.24 format
   3464                 uint16_t sendLevel = proxy->getSendLevel_U4_12();
   3465                 // send level comes from shared memory and so may be corrupt
   3466                 if (sendLevel > MAX_GAIN_INT) {
   3467                     ALOGV("Track send level out of range: %04X", sendLevel);
   3468                     sendLevel = MAX_GAIN_INT;
   3469                 }
   3470                 // vaf is represented as [0.0, 1.0] float by rescaling sendLevel
   3471                 vaf = v * sendLevel * (1. / MAX_GAIN_INT);
   3472             }
   3473 
   3474             // Delegate volume control to effect in track effect chain if needed
   3475             if (chain != 0 && chain->setVolume_l(&vl, &vr)) {
   3476                 // Do not ramp volume if volume is controlled by effect
   3477                 param = AudioMixer::VOLUME;
   3478                 // Update remaining floating point volume levels
   3479                 vlf = (float)vl / (1 << 24);
   3480                 vrf = (float)vr / (1 << 24);
   3481                 track->mHasVolumeController = true;
   3482             } else {
   3483                 // force no volume ramp when volume controller was just disabled or removed
   3484                 // from effect chain to avoid volume spike
   3485                 if (track->mHasVolumeController) {
   3486                     param = AudioMixer::VOLUME;
   3487                 }
   3488                 track->mHasVolumeController = false;
   3489             }
   3490 
   3491             // XXX: these things DON'T need to be done each time
   3492             mAudioMixer->setBufferProvider(name, track);
   3493             mAudioMixer->enable(name);
   3494 
   3495             mAudioMixer->setParameter(name, param, AudioMixer::VOLUME0, &vlf);
   3496             mAudioMixer->setParameter(name, param, AudioMixer::VOLUME1, &vrf);
   3497             mAudioMixer->setParameter(name, param, AudioMixer::AUXLEVEL, &vaf);
   3498             mAudioMixer->setParameter(
   3499                 name,
   3500                 AudioMixer::TRACK,
   3501                 AudioMixer::FORMAT, (void *)track->format());
   3502             mAudioMixer->setParameter(
   3503                 name,
   3504                 AudioMixer::TRACK,
   3505                 AudioMixer::CHANNEL_MASK, (void *)(uintptr_t)track->channelMask());
   3506             mAudioMixer->setParameter(
   3507                 name,
   3508                 AudioMixer::TRACK,
   3509                 AudioMixer::MIXER_CHANNEL_MASK, (void *)(uintptr_t)mChannelMask);
   3510             // limit track sample rate to 2 x output sample rate, which changes at re-configuration
   3511             uint32_t maxSampleRate = mSampleRate * AUDIO_RESAMPLER_DOWN_RATIO_MAX;
   3512             uint32_t reqSampleRate = track->mAudioTrackServerProxy->getSampleRate();
   3513             if (reqSampleRate == 0) {
   3514                 reqSampleRate = mSampleRate;
   3515             } else if (reqSampleRate > maxSampleRate) {
   3516                 reqSampleRate = maxSampleRate;
   3517             }
   3518             mAudioMixer->setParameter(
   3519                 name,
   3520                 AudioMixer::RESAMPLE,
   3521                 AudioMixer::SAMPLE_RATE,
   3522                 (void *)(uintptr_t)reqSampleRate);
   3523             /*
   3524              * Select the appropriate output buffer for the track.
   3525              *
   3526              * Tracks with effects go into their own effects chain buffer
   3527              * and from there into either mEffectBuffer or mSinkBuffer.
   3528              *
   3529              * Other tracks can use mMixerBuffer for higher precision
   3530              * channel accumulation.  If this buffer is enabled
   3531              * (mMixerBufferEnabled true), then selected tracks will accumulate
   3532              * into it.
   3533              *
   3534              */
   3535             if (mMixerBufferEnabled
   3536                     && (track->mainBuffer() == mSinkBuffer
   3537                             || track->mainBuffer() == mMixerBuffer)) {
   3538                 mAudioMixer->setParameter(
   3539                         name,
   3540                         AudioMixer::TRACK,
   3541                         AudioMixer::MIXER_FORMAT, (void *)mMixerBufferFormat);
   3542                 mAudioMixer->setParameter(
   3543                         name,
   3544                         AudioMixer::TRACK,
   3545                         AudioMixer::MAIN_BUFFER, (void *)mMixerBuffer);
   3546                 // TODO: override track->mainBuffer()?
   3547                 mMixerBufferValid = true;
   3548             } else {
   3549                 mAudioMixer->setParameter(
   3550                         name,
   3551                         AudioMixer::TRACK,
   3552                         AudioMixer::MIXER_FORMAT, (void *)AUDIO_FORMAT_PCM_16_BIT);
   3553                 mAudioMixer->setParameter(
   3554                         name,
   3555                         AudioMixer::TRACK,
   3556                         AudioMixer::MAIN_BUFFER, (void *)track->mainBuffer());
   3557             }
   3558             mAudioMixer->setParameter(
   3559                 name,
   3560                 AudioMixer::TRACK,
   3561                 AudioMixer::AUX_BUFFER, (void *)track->auxBuffer());
   3562 
   3563             // reset retry count
   3564             track->mRetryCount = kMaxTrackRetries;
   3565 
   3566             // If one track is ready, set the mixer ready if:
   3567             //  - the mixer was not ready during previous round OR
   3568             //  - no other track is not ready
   3569             if (mMixerStatusIgnoringFastTracks != MIXER_TRACKS_READY ||
   3570                     mixerStatus != MIXER_TRACKS_ENABLED) {
   3571                 mixerStatus = MIXER_TRACKS_READY;
   3572             }
   3573         } else {
   3574             if (framesReady < desiredFrames && !track->isStopped() && !track->isPaused()) {
   3575                 track->mAudioTrackServerProxy->tallyUnderrunFrames(desiredFrames);
   3576             }
   3577             // clear effect chain input buffer if an active track underruns to avoid sending
   3578             // previous audio buffer again to effects
   3579             chain = getEffectChain_l(track->sessionId());
   3580             if (chain != 0) {
   3581                 chain->clearInputBuffer();
   3582             }
   3583 
   3584             ALOGVV("track %d s=%08x [NOT READY] on thread %p", name, cblk->mServer, this);
   3585             if ((track->sharedBuffer() != 0) || track->isTerminated() ||
   3586                     track->isStopped() || track->isPaused()) {
   3587                 // We have consumed all the buffers of this track.
   3588                 // Remove it from the list of active tracks.
   3589                 // TODO: use actual buffer filling status instead of latency when available from
   3590                 // audio HAL
   3591                 size_t audioHALFrames = (latency_l() * mSampleRate) / 1000;
   3592                 size_t framesWritten = mBytesWritten / mFrameSize;
   3593                 if (mStandby || track->presentationComplete(framesWritten, audioHALFrames)) {
   3594                     if (track->isStopped()) {
   3595                         track->reset();
   3596                     }
   3597                     tracksToRemove->add(track);
   3598                 }
   3599             } else {
   3600                 // No buffers for this track. Give it a few chances to
   3601                 // fill a buffer, then remove it from active list.
   3602                 if (--(track->mRetryCount) <= 0) {
   3603                     ALOGI("BUFFER TIMEOUT: remove(%d) from active list on thread %p", name, this);
   3604                     tracksToRemove->add(track);
   3605                     // indicate to client process that the track was disabled because of underrun;
   3606                     // it will then automatically call start() when data is available
   3607                     android_atomic_or(CBLK_DISABLED, &cblk->mFlags);
   3608                 // If one track is not ready, mark the mixer also not ready if:
   3609                 //  - the mixer was ready during previous round OR
   3610                 //  - no other track is ready
   3611                 } else if (mMixerStatusIgnoringFastTracks == MIXER_TRACKS_READY ||
   3612                                 mixerStatus != MIXER_TRACKS_READY) {
   3613                     mixerStatus = MIXER_TRACKS_ENABLED;
   3614                 }
   3615             }
   3616             mAudioMixer->disable(name);
   3617         }
   3618 
   3619         }   // local variable scope to avoid goto warning
   3620 track_is_ready: ;
   3621 
   3622     }
   3623 
   3624     // Push the new FastMixer state if necessary
   3625     bool pauseAudioWatchdog = false;
   3626     if (didModify) {
   3627         state->mFastTracksGen++;
   3628         // if the fast mixer was active, but now there are no fast tracks, then put it in cold idle
   3629         if (kUseFastMixer == FastMixer_Dynamic &&
   3630                 state->mCommand == FastMixerState::MIX_WRITE && state->mTrackMask <= 1) {
   3631             state->mCommand = FastMixerState::COLD_IDLE;
   3632             state->mColdFutexAddr = &mFastMixerFutex;
   3633             state->mColdGen++;
   3634             mFastMixerFutex = 0;
   3635             if (kUseFastMixer == FastMixer_Dynamic) {
   3636                 mNormalSink = mOutputSink;
   3637             }
   3638             // If we go into cold idle, need to wait for acknowledgement
   3639             // so that fast mixer stops doing I/O.
   3640             block = FastMixerStateQueue::BLOCK_UNTIL_ACKED;
   3641             pauseAudioWatchdog = true;
   3642         }
   3643     }
   3644     if (sq != NULL) {
   3645         sq->end(didModify);
   3646         sq->push(block);
   3647     }
   3648 #ifdef AUDIO_WATCHDOG
   3649     if (pauseAudioWatchdog && mAudioWatchdog != 0) {
   3650         mAudioWatchdog->pause();
   3651     }
   3652 #endif
   3653 
   3654     // Now perform the deferred reset on fast tracks that have stopped
   3655     while (resetMask != 0) {
   3656         size_t i = __builtin_ctz(resetMask);
   3657         ALOG_ASSERT(i < count);
   3658         resetMask &= ~(1 << i);
   3659         sp<Track> t = mActiveTracks[i].promote();
   3660         if (t == 0) {
   3661             continue;
   3662         }
   3663         Track* track = t.get();
   3664         ALOG_ASSERT(track->isFastTrack() && track->isStopped());
   3665         track->reset();
   3666     }
   3667 
   3668     // remove all the tracks that need to be...
   3669     removeTracks_l(*tracksToRemove);
   3670 
   3671     if (getEffectChain_l(AUDIO_SESSION_OUTPUT_MIX) != 0) {
   3672         mEffectBufferValid = true;
   3673     }
   3674 
   3675     if (mEffectBufferValid) {
   3676         // as long as there are effects we should clear the effects buffer, to avoid
   3677         // passing a non-clean buffer to the effect chain
   3678         memset(mEffectBuffer, 0, mEffectBufferSize);
   3679     }
   3680     // sink or mix buffer must be cleared if all tracks are connected to an
   3681     // effect chain as in this case the mixer will not write to the sink or mix buffer
   3682     // and track effects will accumulate into it
   3683     if ((mBytesRemaining == 0) && ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
   3684             (mixedTracks == 0 && fastTracks > 0))) {
   3685         // FIXME as a performance optimization, should remember previous zero status
   3686         if (mMixerBufferValid) {
   3687             memset(mMixerBuffer, 0, mMixerBufferSize);
   3688             // TODO: In testing, mSinkBuffer below need not be cleared because
   3689             // the PlaybackThread::threadLoop() copies mMixerBuffer into mSinkBuffer
   3690             // after mixing.
   3691             //
   3692             // To enforce this guarantee:
   3693             // ((mixedTracks != 0 && mixedTracks == tracksWithEffect) ||
   3694             // (mixedTracks == 0 && fastTracks > 0))
   3695             // must imply MIXER_TRACKS_READY.
   3696             // Later, we may clear buffers regardless, and skip much of this logic.
   3697         }
   3698         // FIXME as a performance optimization, should remember previous zero status
   3699         memset(mSinkBuffer, 0, mNormalFrameCount * mFrameSize);
   3700     }
   3701 
   3702     // if any fast tracks, then status is ready
   3703     mMixerStatusIgnoringFastTracks = mixerStatus;
   3704     if (fastTracks > 0) {
   3705         mixerStatus = MIXER_TRACKS_READY;
   3706     }
   3707     return mixerStatus;
   3708 }
   3709 
   3710 // getTrackName_l() must be called with ThreadBase::mLock held
   3711 int AudioFlinger::MixerThread::getTrackName_l(audio_channel_mask_t channelMask,
   3712         audio_format_t format, int sessionId)
   3713 {
   3714     return mAudioMixer->getTrackName(channelMask, format, sessionId);
   3715 }
   3716 
   3717 // deleteTrackName_l() must be called with ThreadBase::mLock held
   3718 void AudioFlinger::MixerThread::deleteTrackName_l(int name)
   3719 {
   3720     ALOGV("remove track (%d) and delete from mixer", name);
   3721     mAudioMixer->deleteTrackName(name);
   3722 }
   3723 
   3724 // checkForNewParameter_l() must be called with ThreadBase::mLock held
   3725 bool AudioFlinger::MixerThread::checkForNewParameter_l(const String8& keyValuePair,
   3726                                                        status_t& status)
   3727 {
   3728     bool reconfig = false;
   3729 
   3730     status = NO_ERROR;
   3731 
   3732     // if !&IDLE, holds the FastMixer state to restore after new parameters processed
   3733     FastMixerState::Command previousCommand = FastMixerState::HOT_IDLE;
   3734     if (mFastMixer != 0) {
   3735         FastMixerStateQueue *sq = mFastMixer->sq();
   3736         FastMixerState *state = sq->begin();
   3737         if (!(state->mCommand & FastMixerState::IDLE)) {
   3738             previousCommand = state->mCommand;
   3739             state->mCommand = FastMixerState::HOT_IDLE;
   3740             sq->end();
   3741             sq->push(FastMixerStateQueue::BLOCK_UNTIL_ACKED);
   3742         } else {
   3743             sq->end(false /*didModify*/);
   3744         }
   3745     }
   3746 
   3747     AudioParameter param = AudioParameter(keyValuePair);
   3748     int value;
   3749     if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
   3750         reconfig = true;
   3751     }
   3752     if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
   3753         if (!isValidPcmSinkFormat((audio_format_t) value)) {
   3754             status = BAD_VALUE;
   3755         } else {
   3756             // no need to save value, since it's constant
   3757             reconfig = true;
   3758         }
   3759     }
   3760     if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
   3761         if (!isValidPcmSinkChannelMask((audio_channel_mask_t) value)) {
   3762             status = BAD_VALUE;
   3763         } else {
   3764             // no need to save value, since it's constant
   3765             reconfig = true;
   3766         }
   3767     }
   3768     if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
   3769         // do not accept frame count changes if tracks are open as the track buffer
   3770         // size depends on frame count and correct behavior would not be guaranteed
   3771         // if frame count is changed after track creation
   3772         if (!mTracks.isEmpty()) {
   3773             status = INVALID_OPERATION;
   3774         } else {
   3775             reconfig = true;
   3776         }
   3777     }
   3778     if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
   3779 #ifdef ADD_BATTERY_DATA
   3780         // when changing the audio output device, call addBatteryData to notify
   3781         // the change
   3782         if (mOutDevice != value) {
   3783             uint32_t params = 0;
   3784             // check whether speaker is on
   3785             if (value & AUDIO_DEVICE_OUT_SPEAKER) {
   3786                 params |= IMediaPlayerService::kBatteryDataSpeakerOn;
   3787             }
   3788 
   3789             audio_devices_t deviceWithoutSpeaker
   3790                 = AUDIO_DEVICE_OUT_ALL & ~AUDIO_DEVICE_OUT_SPEAKER;
   3791             // check if any other device (except speaker) is on
   3792             if (value & deviceWithoutSpeaker ) {
   3793                 params |= IMediaPlayerService::kBatteryDataOtherAudioDeviceOn;
   3794             }
   3795 
   3796             if (params != 0) {
   3797                 addBatteryData(params);
   3798             }
   3799         }
   3800 #endif
   3801 
   3802         // forward device change to effects that have requested to be
   3803         // aware of attached audio device.
   3804         if (value != AUDIO_DEVICE_NONE) {
   3805             mOutDevice = value;
   3806             for (size_t i = 0; i < mEffectChains.size(); i++) {
   3807                 mEffectChains[i]->setDevice_l(mOutDevice);
   3808             }
   3809         }
   3810     }
   3811 
   3812     if (status == NO_ERROR) {
   3813         status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
   3814                                                 keyValuePair.string());
   3815         if (!mStandby && status == INVALID_OPERATION) {
   3816             mOutput->stream->common.standby(&mOutput->stream->common);
   3817             mStandby = true;
   3818             mBytesWritten = 0;
   3819             status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
   3820                                                    keyValuePair.string());
   3821         }
   3822         if (status == NO_ERROR && reconfig) {
   3823             readOutputParameters_l();
   3824             delete mAudioMixer;
   3825             mAudioMixer = new AudioMixer(mNormalFrameCount, mSampleRate);
   3826             for (size_t i = 0; i < mTracks.size() ; i++) {
   3827                 int name = getTrackName_l(mTracks[i]->mChannelMask,
   3828                         mTracks[i]->mFormat, mTracks[i]->mSessionId);
   3829                 if (name < 0) {
   3830                     break;
   3831                 }
   3832                 mTracks[i]->mName = name;
   3833             }
   3834             sendIoConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
   3835         }
   3836     }
   3837 
   3838     if (!(previousCommand & FastMixerState::IDLE)) {
   3839         ALOG_ASSERT(mFastMixer != 0);
   3840         FastMixerStateQueue *sq = mFastMixer->sq();
   3841         FastMixerState *state = sq->begin();
   3842         ALOG_ASSERT(state->mCommand == FastMixerState::HOT_IDLE);
   3843         state->mCommand = previousCommand;
   3844         sq->end();
   3845         sq->push(FastMixerStateQueue::BLOCK_UNTIL_PUSHED);
   3846     }
   3847 
   3848     return reconfig;
   3849 }
   3850 
   3851 
   3852 void AudioFlinger::MixerThread::dumpInternals(int fd, const Vector<String16>& args)
   3853 {
   3854     const size_t SIZE = 256;
   3855     char buffer[SIZE];
   3856     String8 result;
   3857 
   3858     PlaybackThread::dumpInternals(fd, args);
   3859 
   3860     dprintf(fd, "  AudioMixer tracks: 0x%08x\n", mAudioMixer->trackNames());
   3861 
   3862     // Make a non-atomic copy of fast mixer dump state so it won't change underneath us
   3863     const FastMixerDumpState copy(mFastMixerDumpState);
   3864     copy.dump(fd);
   3865 
   3866 #ifdef STATE_QUEUE_DUMP
   3867     // Similar for state queue
   3868     StateQueueObserverDump observerCopy = mStateQueueObserverDump;
   3869     observerCopy.dump(fd);
   3870     StateQueueMutatorDump mutatorCopy = mStateQueueMutatorDump;
   3871     mutatorCopy.dump(fd);
   3872 #endif
   3873 
   3874 #ifdef TEE_SINK
   3875     // Write the tee output to a .wav file
   3876     dumpTee(fd, mTeeSource, mId);
   3877 #endif
   3878 
   3879 #ifdef AUDIO_WATCHDOG
   3880     if (mAudioWatchdog != 0) {
   3881         // Make a non-atomic copy of audio watchdog dump so it won't change underneath us
   3882         AudioWatchdogDump wdCopy = mAudioWatchdogDump;
   3883         wdCopy.dump(fd);
   3884     }
   3885 #endif
   3886 }
   3887 
   3888 uint32_t AudioFlinger::MixerThread::idleSleepTimeUs() const
   3889 {
   3890     return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000) / 2;
   3891 }
   3892 
   3893 uint32_t AudioFlinger::MixerThread::suspendSleepTimeUs() const
   3894 {
   3895     return (uint32_t)(((mNormalFrameCount * 1000) / mSampleRate) * 1000);
   3896 }
   3897 
   3898 void AudioFlinger::MixerThread::cacheParameters_l()
   3899 {
   3900     PlaybackThread::cacheParameters_l();
   3901 
   3902     // FIXME: Relaxed timing because of a certain device that can't meet latency
   3903     // Should be reduced to 2x after the vendor fixes the driver issue
   3904     // increase threshold again due to low power audio mode. The way this warning
   3905     // threshold is calculated and its usefulness should be reconsidered anyway.
   3906     maxPeriod = seconds(mNormalFrameCount) / mSampleRate * 15;
   3907 }
   3908 
   3909 // ----------------------------------------------------------------------------
   3910 
   3911 AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
   3912         AudioStreamOut* output, audio_io_handle_t id, audio_devices_t device)
   3913     :   PlaybackThread(audioFlinger, output, id, device, DIRECT)
   3914         // mLeftVolFloat, mRightVolFloat
   3915 {
   3916 }
   3917 
   3918 AudioFlinger::DirectOutputThread::DirectOutputThread(const sp<AudioFlinger>& audioFlinger,
   3919         AudioStreamOut* output, audio_io_handle_t id, uint32_t device,
   3920         ThreadBase::type_t type)
   3921     :   PlaybackThread(audioFlinger, output, id, device, type)
   3922         // mLeftVolFloat, mRightVolFloat
   3923 {
   3924 }
   3925 
   3926 AudioFlinger::DirectOutputThread::~DirectOutputThread()
   3927 {
   3928 }
   3929 
   3930 void AudioFlinger::DirectOutputThread::processVolume_l(Track *track, bool lastTrack)
   3931 {
   3932     audio_track_cblk_t* cblk = track->cblk();
   3933     float left, right;
   3934 
   3935     if (mMasterMute || mStreamTypes[track->streamType()].mute) {
   3936         left = right = 0;
   3937     } else {
   3938         float typeVolume = mStreamTypes[track->streamType()].volume;
   3939         float v = mMasterVolume * typeVolume;
   3940         AudioTrackServerProxy *proxy = track->mAudioTrackServerProxy;
   3941         gain_minifloat_packed_t vlr = proxy->getVolumeLR();
   3942         left = float_from_gain(gain_minifloat_unpack_left(vlr));
   3943         if (left > GAIN_FLOAT_UNITY) {
   3944             left = GAIN_FLOAT_UNITY;
   3945         }
   3946         left *= v;
   3947         right = float_from_gain(gain_minifloat_unpack_right(vlr));
   3948         if (right > GAIN_FLOAT_UNITY) {
   3949             right = GAIN_FLOAT_UNITY;
   3950         }
   3951         right *= v;
   3952     }
   3953 
   3954     if (lastTrack) {
   3955         if (left != mLeftVolFloat || right != mRightVolFloat) {
   3956             mLeftVolFloat = left;
   3957             mRightVolFloat = right;
   3958 
   3959             // Convert volumes from float to 8.24
   3960             uint32_t vl = (uint32_t)(left * (1 << 24));
   3961             uint32_t vr = (uint32_t)(right * (1 << 24));
   3962 
   3963             // Delegate volume control to effect in track effect chain if needed
   3964             // only one effect chain can be present on DirectOutputThread, so if
   3965             // there is one, the track is connected to it
   3966             if (!mEffectChains.isEmpty()) {
   3967                 mEffectChains[0]->setVolume_l(&vl, &vr);
   3968                 left = (float)vl / (1 << 24);
   3969                 right = (float)vr / (1 << 24);
   3970             }
   3971             if (mOutput->stream->set_volume) {
   3972                 mOutput->stream->set_volume(mOutput->stream, left, right);
   3973             }
   3974         }
   3975     }
   3976 }
   3977 
   3978 
   3979 AudioFlinger::PlaybackThread::mixer_state AudioFlinger::DirectOutputThread::prepareTracks_l(
   3980     Vector< sp<Track> > *tracksToRemove
   3981 )
   3982 {
   3983     size_t count = mActiveTracks.size();
   3984     mixer_state mixerStatus = MIXER_IDLE;
   3985 
   3986     // find out which tracks need to be processed
   3987     for (size_t i = 0; i < count; i++) {
   3988         sp<Track> t = mActiveTracks[i].promote();
   3989         // The track died recently
   3990         if (t == 0) {
   3991             continue;
   3992         }
   3993 
   3994         Track* const track = t.get();
   3995         audio_track_cblk_t* cblk = track->cblk();
   3996         // Only consider last track started for volume and mixer state control.
   3997         // In theory an older track could underrun and restart after the new one starts
   3998         // but as we only care about the transition phase between two tracks on a
   3999         // direct output, it is not a problem to ignore the underrun case.
   4000         sp<Track> l = mLatestActiveTrack.promote();
   4001         bool last = l.get() == track;
   4002 
   4003         // The first time a track is added we wait
   4004         // for all its buffers to be filled before processing it
   4005         uint32_t minFrames;
   4006         if ((track->sharedBuffer() == 0) && !track->isStopping_1() && !track->isPausing()) {
   4007             minFrames = mNormalFrameCount;
   4008         } else {
   4009             minFrames = 1;
   4010         }
   4011 
   4012         if ((track->framesReady() >= minFrames) && track->isReady() && !track->isPaused() &&
   4013                 !track->isStopping_2() && !track->isStopped())
   4014         {
   4015             ALOGVV("track %d s=%08x [OK]", track->name(), cblk->mServer);
   4016 
   4017             if (track->mFillingUpStatus == Track::FS_FILLED) {
   4018                 track->mFillingUpStatus = Track::FS_ACTIVE;
   4019                 // make sure processVolume_l() will apply new volume even if 0
   4020                 mLeftVolFloat = mRightVolFloat = -1.0;
   4021                 if (track->mState == TrackBase::RESUMING) {
   4022                     track->mState = TrackBase::ACTIVE;
   4023                 }
   4024             }
   4025 
   4026             // compute volume for this track
   4027             processVolume_l(track, last);
   4028             if (last) {
   4029                 // reset retry count
   4030                 track->mRetryCount = kMaxTrackRetriesDirect;
   4031                 mActiveTrack = t;
   4032                 mixerStatus = MIXER_TRACKS_READY;
   4033             }
   4034         } else {
   4035             // clear effect chain input buffer if the last active track started underruns
   4036             // to avoid sending previous audio buffer again to effects
   4037             if (!mEffectChains.isEmpty() && last) {
   4038                 mEffectChains[0]->clearInputBuffer();
   4039             }
   4040             if (track->isStopping_1()) {
   4041                 track->mState = TrackBase::STOPPING_2;
   4042             }
   4043             if ((track->sharedBuffer() != 0) || track->isStopped() ||
   4044                     track->isStopping_2() || track->isPaused()) {
   4045                 // We have consumed all the buffers of this track.
   4046                 // Remove it from the list of active tracks.
   4047                 size_t audioHALFrames;
   4048                 if (audio_is_linear_pcm(mFormat)) {
   4049                     audioHALFrames = (latency_l() * mSampleRate) / 1000;
   4050                 } else {
   4051                     audioHALFrames = 0;
   4052                 }
   4053 
   4054                 size_t framesWritten = mBytesWritten / mFrameSize;
   4055                 if (mStandby || !last ||
   4056                         track->presentationComplete(framesWritten, audioHALFrames)) {
   4057                     if (track->isStopping_2()) {
   4058                         track->mState = TrackBase::STOPPED;
   4059                     }
   4060                     if (track->isStopped()) {
   4061                         if (track->mState == TrackBase::FLUSHED) {
   4062                             flushHw_l();
   4063                         }
   4064                         track->reset();
   4065                     }
   4066                     tracksToRemove->add(track);
   4067                 }
   4068             } else {
   4069                 // No buffers for this track. Give it a few chances to
   4070                 // fill a buffer, then remove it from active list.
   4071                 // Only consider last track started for mixer state control
   4072                 if (--(track->mRetryCount) <= 0) {
   4073                     ALOGV("BUFFER TIMEOUT: remove(%d) from active list", track->name());
   4074                     tracksToRemove->add(track);
   4075                     // indicate to client process that the track was disabled because of underrun;
   4076                     // it will then automatically call start() when data is available
   4077                     android_atomic_or(CBLK_DISABLED, &cblk->mFlags);
   4078                 } else if (last) {
   4079                     mixerStatus = MIXER_TRACKS_ENABLED;
   4080                 }
   4081             }
   4082         }
   4083     }
   4084 
   4085     // remove all the tracks that need to be...
   4086     removeTracks_l(*tracksToRemove);
   4087 
   4088     return mixerStatus;
   4089 }
   4090 
   4091 void AudioFlinger::DirectOutputThread::threadLoop_mix()
   4092 {
   4093     size_t frameCount = mFrameCount;
   4094     int8_t *curBuf = (int8_t *)mSinkBuffer;
   4095     // output audio to hardware
   4096     while (frameCount) {
   4097         AudioBufferProvider::Buffer buffer;
   4098         buffer.frameCount = frameCount;
   4099         mActiveTrack->getNextBuffer(&buffer);
   4100         if (buffer.raw == NULL) {
   4101             memset(curBuf, 0, frameCount * mFrameSize);
   4102             break;
   4103         }
   4104         memcpy(curBuf, buffer.raw, buffer.frameCount * mFrameSize);
   4105         frameCount -= buffer.frameCount;
   4106         curBuf += buffer.frameCount * mFrameSize;
   4107         mActiveTrack->releaseBuffer(&buffer);
   4108     }
   4109     mCurrentWriteLength = curBuf - (int8_t *)mSinkBuffer;
   4110     sleepTime = 0;
   4111     standbyTime = systemTime() + standbyDelay;
   4112     mActiveTrack.clear();
   4113 }
   4114 
   4115 void AudioFlinger::DirectOutputThread::threadLoop_sleepTime()
   4116 {
   4117     if (sleepTime == 0) {
   4118         if (mMixerStatus == MIXER_TRACKS_ENABLED) {
   4119             sleepTime = activeSleepTime;
   4120         } else {
   4121             sleepTime = idleSleepTime;
   4122         }
   4123     } else if (mBytesWritten != 0 && audio_is_linear_pcm(mFormat)) {
   4124         memset(mSinkBuffer, 0, mFrameCount * mFrameSize);
   4125         sleepTime = 0;
   4126     }
   4127 }
   4128 
   4129 // getTrackName_l() must be called with ThreadBase::mLock held
   4130 int AudioFlinger::DirectOutputThread::getTrackName_l(audio_channel_mask_t channelMask __unused,
   4131         audio_format_t format __unused, int sessionId __unused)
   4132 {
   4133     return 0;
   4134 }
   4135 
   4136 // deleteTrackName_l() must be called with ThreadBase::mLock held
   4137 void AudioFlinger::DirectOutputThread::deleteTrackName_l(int name __unused)
   4138 {
   4139 }
   4140 
   4141 // checkForNewParameter_l() must be called with ThreadBase::mLock held
   4142 bool AudioFlinger::DirectOutputThread::checkForNewParameter_l(const String8& keyValuePair,
   4143                                                               status_t& status)
   4144 {
   4145     bool reconfig = false;
   4146 
   4147     status = NO_ERROR;
   4148 
   4149     AudioParameter param = AudioParameter(keyValuePair);
   4150     int value;
   4151     if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
   4152         // forward device change to effects that have requested to be
   4153         // aware of attached audio device.
   4154         if (value != AUDIO_DEVICE_NONE) {
   4155             mOutDevice = value;
   4156             for (size_t i = 0; i < mEffectChains.size(); i++) {
   4157                 mEffectChains[i]->setDevice_l(mOutDevice);
   4158             }
   4159         }
   4160     }
   4161     if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
   4162         // do not accept frame count changes if tracks are open as the track buffer
   4163         // size depends on frame count and correct behavior would not be garantied
   4164         // if frame count is changed after track creation
   4165         if (!mTracks.isEmpty()) {
   4166             status = INVALID_OPERATION;
   4167         } else {
   4168             reconfig = true;
   4169         }
   4170     }
   4171     if (status == NO_ERROR) {
   4172         status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
   4173                                                 keyValuePair.string());
   4174         if (!mStandby && status == INVALID_OPERATION) {
   4175             mOutput->stream->common.standby(&mOutput->stream->common);
   4176             mStandby = true;
   4177             mBytesWritten = 0;
   4178             status = mOutput->stream->common.set_parameters(&mOutput->stream->common,
   4179                                                    keyValuePair.string());
   4180         }
   4181         if (status == NO_ERROR && reconfig) {
   4182             readOutputParameters_l();
   4183             sendIoConfigEvent_l(AudioSystem::OUTPUT_CONFIG_CHANGED);
   4184         }
   4185     }
   4186 
   4187     return reconfig;
   4188 }
   4189 
   4190 uint32_t AudioFlinger::DirectOutputThread::activeSleepTimeUs() const
   4191 {
   4192     uint32_t time;
   4193     if (audio_is_linear_pcm(mFormat)) {
   4194         time = PlaybackThread::activeSleepTimeUs();
   4195     } else {
   4196         time = 10000;
   4197     }
   4198     return time;
   4199 }
   4200 
   4201 uint32_t AudioFlinger::DirectOutputThread::idleSleepTimeUs() const
   4202 {
   4203     uint32_t time;
   4204     if (audio_is_linear_pcm(mFormat)) {
   4205         time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000) / 2;
   4206     } else {
   4207         time = 10000;
   4208     }
   4209     return time;
   4210 }
   4211 
   4212 uint32_t AudioFlinger::DirectOutputThread::suspendSleepTimeUs() const
   4213 {
   4214     uint32_t time;
   4215     if (audio_is_linear_pcm(mFormat)) {
   4216         time = (uint32_t)(((mFrameCount * 1000) / mSampleRate) * 1000);
   4217     } else {
   4218         time = 10000;
   4219     }
   4220     return time;
   4221 }
   4222 
   4223 void AudioFlinger::DirectOutputThread::cacheParameters_l()
   4224 {
   4225     PlaybackThread::cacheParameters_l();
   4226 
   4227     // use shorter standby delay as on normal output to release
   4228     // hardware resources as soon as possible
   4229     if (audio_is_linear_pcm(mFormat)) {
   4230         standbyDelay = microseconds(activeSleepTime*2);
   4231     } else {
   4232         standbyDelay = kOffloadStandbyDelayNs;
   4233     }
   4234 }
   4235 
   4236 void AudioFlinger::DirectOutputThread::flushHw_l()
   4237 {
   4238     if (mOutput->stream->flush != NULL)
   4239         mOutput->stream->flush(mOutput->stream);
   4240 }
   4241 
   4242 // ----------------------------------------------------------------------------
   4243 
   4244 AudioFlinger::AsyncCallbackThread::AsyncCallbackThread(
   4245         const wp<AudioFlinger::PlaybackThread>& playbackThread)
   4246     :   Thread(false /*canCallJava*/),
   4247         mPlaybackThread(playbackThread),
   4248         mWriteAckSequence(0),
   4249         mDrainSequence(0)
   4250 {
   4251 }
   4252 
   4253 AudioFlinger::AsyncCallbackThread::~AsyncCallbackThread()
   4254 {
   4255 }
   4256 
   4257 void AudioFlinger::AsyncCallbackThread::onFirstRef()
   4258 {
   4259     run("Offload Cbk", ANDROID_PRIORITY_URGENT_AUDIO);
   4260 }
   4261 
   4262 bool AudioFlinger::AsyncCallbackThread::threadLoop()
   4263 {
   4264     while (!exitPending()) {
   4265         uint32_t writeAckSequence;
   4266         uint32_t drainSequence;
   4267 
   4268         {
   4269             Mutex::Autolock _l(mLock);
   4270             while (!((mWriteAckSequence & 1) ||
   4271                      (mDrainSequence & 1) ||
   4272                      exitPending())) {
   4273                 mWaitWorkCV.wait(mLock);
   4274             }
   4275 
   4276             if (exitPending()) {
   4277                 break;
   4278             }
   4279             ALOGV("AsyncCallbackThread mWriteAckSequence %d mDrainSequence %d",
   4280                   mWriteAckSequence, mDrainSequence);
   4281             writeAckSequence = mWriteAckSequence;
   4282             mWriteAckSequence &= ~1;
   4283             drainSequence = mDrainSequence;
   4284             mDrainSequence &= ~1;
   4285         }
   4286         {
   4287             sp<AudioFlinger::PlaybackThread> playbackThread = mPlaybackThread.promote();
   4288             if (playbackThread != 0) {
   4289                 if (writeAckSequence & 1) {
   4290                     playbackThread->resetWriteBlocked(writeAckSequence >> 1);
   4291                 }
   4292                 if (drainSequence & 1) {
   4293                     playbackThread->resetDraining(drainSequence >> 1);
   4294                 }
   4295             }
   4296         }
   4297     }
   4298     return false;
   4299 }
   4300 
   4301 void AudioFlinger::AsyncCallbackThread::exit()
   4302 {
   4303     ALOGV("AsyncCallbackThread::exit");
   4304     Mutex::Autolock _l(mLock);
   4305     requestExit();
   4306     mWaitWorkCV.broadcast();
   4307 }
   4308 
   4309 void AudioFlinger::AsyncCallbackThread::setWriteBlocked(uint32_t sequence)
   4310 {
   4311     Mutex::Autolock _l(mLock);
   4312     // bit 0 is cleared
   4313     mWriteAckSequence = sequence << 1;
   4314 }
   4315 
   4316 void AudioFlinger::AsyncCallbackThread::resetWriteBlocked()
   4317 {
   4318     Mutex::Autolock _l(mLock);
   4319     // ignore unexpected callbacks
   4320     if (mWriteAckSequence & 2) {
   4321         mWriteAckSequence |= 1;
   4322         mWaitWorkCV.signal();
   4323     }
   4324 }
   4325 
   4326 void AudioFlinger::AsyncCallbackThread::setDraining(uint32_t sequence)
   4327 {
   4328     Mutex::Autolock _l(mLock);
   4329     // bit 0 is cleared
   4330     mDrainSequence = sequence << 1;
   4331 }
   4332 
   4333 void AudioFlinger::AsyncCallbackThread::resetDraining()
   4334 {
   4335     Mutex::Autolock _l(mLock);
   4336     // ignore unexpected callbacks
   4337     if (mDrainSequence & 2) {
   4338         mDrainSequence |= 1;
   4339         mWaitWorkCV.signal();
   4340     }
   4341 }
   4342 
   4343 
   4344 // ----------------------------------------------------------------------------
   4345 AudioFlinger::OffloadThread::OffloadThread(const sp<AudioFlinger>& audioFlinger,
   4346         AudioStreamOut* output, audio_io_handle_t id, uint32_t device)
   4347     :   DirectOutputThread(audioFlinger, output, id, device, OFFLOAD),
   4348         mHwPaused(false),
   4349         mFlushPending(false),
   4350         mPausedBytesRemaining(0)
   4351 {
   4352     //FIXME: mStandby should be set to true by ThreadBase constructor
   4353     mStandby = true;
   4354 }
   4355 
   4356 void AudioFlinger::OffloadThread::threadLoop_exit()
   4357 {
   4358     if (mFlushPending || mHwPaused) {
   4359         // If a flush is pending or track was paused, just discard buffered data
   4360         flushHw_l();
   4361     } else {
   4362         mMixerStatus = MIXER_DRAIN_ALL;
   4363         threadLoop_drain();
   4364     }
   4365     if (mUseAsyncWrite) {
   4366         ALOG_ASSERT(mCallbackThread != 0);
   4367         mCallbackThread->exit();
   4368     }
   4369     PlaybackThread::threadLoop_exit();
   4370 }
   4371 
   4372 AudioFlinger::PlaybackThread::mixer_state AudioFlinger::OffloadThread::prepareTracks_l(
   4373     Vector< sp<Track> > *tracksToRemove
   4374 )
   4375 {
   4376     size_t count = mActiveTracks.size();
   4377 
   4378     mixer_state mixerStatus = MIXER_IDLE;
   4379     bool doHwPause = false;
   4380     bool doHwResume = false;
   4381 
   4382     ALOGV("OffloadThread::prepareTracks_l active tracks %d", count);
   4383 
   4384     // find out which tracks need to be processed
   4385     for (size_t i = 0; i < count; i++) {
   4386         sp<Track> t = mActiveTracks[i].promote();
   4387         // The track died recently
   4388         if (t == 0) {
   4389             continue;
   4390         }
   4391         Track* const track = t.get();
   4392         audio_track_cblk_t* cblk = track->cblk();
   4393         // Only consider last track started for volume and mixer state control.
   4394         // In theory an older track could underrun and restart after the new one starts
   4395         // but as we only care about the transition phase between two tracks on a
   4396         // direct output, it is not a problem to ignore the underrun case.
   4397         sp<Track> l = mLatestActiveTrack.promote();
   4398         bool last = l.get() == track;
   4399 
   4400         if (track->isInvalid()) {
   4401             ALOGW("An invalidated track shouldn't be in active list");
   4402             tracksToRemove->add(track);
   4403             continue;
   4404         }
   4405 
   4406         if (track->mState == TrackBase::IDLE) {
   4407             ALOGW("An idle track shouldn't be in active list");
   4408             continue;
   4409         }
   4410 
   4411         if (track->isPausing()) {
   4412             track->setPaused();
   4413             if (last) {
   4414                 if (!mHwPaused) {
   4415                     doHwPause = true;
   4416                     mHwPaused = true;
   4417                 }
   4418                 // If we were part way through writing the mixbuffer to
   4419                 // the HAL we must save this until we resume
   4420                 // BUG - this will be wrong if a different track is made active,
   4421                 // in that case we want to discard the pending data in the
   4422                 // mixbuffer and tell the client to present it again when the
   4423                 // track is resumed
   4424                 mPausedWriteLength = mCurrentWriteLength;
   4425                 mPausedBytesRemaining = mBytesRemaining;
   4426                 mBytesRemaining = 0;    // stop writing
   4427             }
   4428             tracksToRemove->add(track);
   4429         } else if (track->isFlushPending()) {
   4430             track->flushAck();
   4431             if (last) {
   4432                 mFlushPending = true;
   4433             }
   4434         } else if (track->isResumePending()){
   4435             track->resumeAck();
   4436             if (last) {
   4437                 if (mPausedBytesRemaining) {
   4438                     // Need to continue write that was interrupted
   4439                     mCurrentWriteLength = mPausedWriteLength;
   4440                     mBytesRemaining = mPausedBytesRemaining;
   4441                     mPausedBytesRemaining = 0;
   4442                 }
   4443                 if (mHwPaused) {
   4444                     doHwResume = true;
   4445                     mHwPaused = false;
   4446                     // threadLoop_mix() will handle the case that we need to
   4447                     // resume an interrupted write
   4448                 }
   4449                 // enable write to audio HAL
   4450                 sleepTime = 0;
   4451 
   4452                 // Do not handle new data in this iteration even if track->framesReady()
   4453                 mixerStatus = MIXER_TRACKS_ENABLED;
   4454             }
   4455         }  else if (track->framesReady() && track->isReady() &&
   4456                 !track->isPaused() && !track->isTerminated() && !track->isStopping_2()) {
   4457             ALOGVV("OffloadThread: track %d s=%08x [OK]", track->name(), cblk->mServer);
   4458             if (track->mFillingUpStatus == Track::FS_FILLED) {
   4459                 track->mFillingUpStatus = Track::FS_ACTIVE;
   4460                 // make sure processVolume_l() will apply new volume even if 0
   4461                 mLeftVolFloat = mRightVolFloat = -1.0;
   4462             }
   4463 
   4464             if (last) {
   4465                 sp<Track> previousTrack = mPreviousTrack.promote();
   4466                 if (previousTrack != 0) {
   4467                     if (track != previousTrack.get()) {
   4468                         // Flush any data still being written from last track
   4469                         mBytesRemaining = 0;
   4470                         if (mPausedBytesRemaining) {
   4471                             // Last track was paused so we also need to flush saved
   4472                             // mixbuffer state and invalidate track so that it will
   4473                             // re-submit that unwritten data when it is next resumed
   4474                             mPausedBytesRemaining = 0;
   4475                             // Invalidate is a bit drastic - would be more efficient
   4476                             // to have a flag to tell client that some of the
   4477                             // previously written data was lost
   4478                             previousTrack->invalidate();
   4479                         }
   4480                         // flush data already sent to the DSP if changing audio session as audio
   4481                         // comes from a different source. Also invalidate previous track to force a
   4482                         // seek when resuming.
   4483                         if (previousTrack->sessionId() != track->sessionId()) {
   4484                             previousTrack->invalidate();
   4485                         }
   4486                     }
   4487                 }
   4488                 mPreviousTrack = track;
   4489                 // reset retry count
   4490                 track->mRetryCount = kMaxTrackRetriesOffload;
   4491                 mActiveTrack = t;
   4492                 mixerStatus = MIXER_TRACKS_READY;
   4493             }
   4494         } else {
   4495             ALOGVV("OffloadThread: track %d s=%08x [NOT READY]", track->name(), cblk->mServer);
   4496             if (track->isStopping_1()) {
   4497                 // Hardware buffer can hold a large amount of audio so we must
   4498                 // wait for all current track's data to drain before we say
   4499                 // that the track is stopped.
   4500                 if (mBytesRemaining == 0) {
   4501                     // Only start draining when all data in mixbuffer
   4502                     // has been written
   4503                     ALOGV("OffloadThread: underrun and STOPPING_1 -> draining, STOPPING_2");
   4504                     track->mState = TrackBase::STOPPING_2; // so presentation completes after drain
   4505                     // do not drain if no data was ever sent to HAL (mStandby == true)
   4506                     if (last && !mStandby) {
   4507                         // do not modify drain sequence if we are already draining. This happens
   4508                         // when resuming from pause after drain.
   4509                         if ((mDrainSequence & 1) == 0) {
   4510                             sleepTime = 0;
   4511                             standbyTime = systemTime() + standbyDelay;
   4512                             mixerStatus = MIXER_DRAIN_TRACK;
   4513                             mDrainSequence += 2;
   4514                         }
   4515                         if (mHwPaused) {
   4516                             // It is possible to move from PAUSED to STOPPING_1 without
   4517                             // a resume so we must ensure hardware is running
   4518                             doHwResume = true;
   4519                             mHwPaused = false;
   4520                         }
   4521                     }
   4522                 }
   4523             } else if (track->isStopping_2()) {
   4524                 // Drain has completed or we are in standby, signal presentation complete
   4525                 if (!(mDrainSequence & 1) || !last || mStandby) {
   4526                     track->mState = TrackBase::STOPPED;
   4527                     size_t audioHALFrames =
   4528                             (mOutput->stream->get_latency(mOutput->stream)*mSampleRate) / 1000;
   4529                     size_t framesWritten =
   4530                             mBytesWritten / audio_stream_out_frame_size(mOutput->stream);
   4531                     track->presentationComplete(framesWritten, audioHALFrames);
   4532                     track->reset();
   4533                     tracksToRemove->add(track);
   4534                 }
   4535             } else {
   4536                 // No buffers for this track. Give it a few chances to
   4537                 // fill a buffer, then remove it from active list.
   4538                 if (--(track->mRetryCount) <= 0) {
   4539                     ALOGV("OffloadThread: BUFFER TIMEOUT: remove(%d) from active list",
   4540                           track->name());
   4541                     tracksToRemove->add(track);
   4542                     // indicate to client process that the track was disabled because of underrun;
   4543                     // it will then automatically call start() when data is available
   4544                     android_atomic_or(CBLK_DISABLED, &cblk->mFlags);
   4545                 } else if (last){
   4546                     mixerStatus = MIXER_TRACKS_ENABLED;
   4547                 }
   4548             }
   4549         }
   4550         // compute volume for this track
   4551         processVolume_l(track, last);
   4552     }
   4553 
   4554     // make sure the pause/flush/resume sequence is executed in the right order.
   4555     // If a flush is pending and a track is active but the HW is not paused, force a HW pause
   4556     // before flush and then resume HW. This can happen in case of pause/flush/resume
   4557     // if resume is received before pause is executed.
   4558     if (!mStandby && (doHwPause || (mFlushPending && !mHwPaused && (count != 0)))) {
   4559         mOutput->stream->pause(mOutput->stream);
   4560     }
   4561     if (mFlushPending) {
   4562         flushHw_l();
   4563         mFlushPending = false;
   4564     }
   4565     if (!mStandby && doHwResume) {
   4566         mOutput->stream->resume(mOutput->stream);
   4567     }
   4568 
   4569     // remove all the tracks that need to be...
   4570     removeTracks_l(*tracksToRemove);
   4571 
   4572     return mixerStatus;
   4573 }
   4574 
   4575 // must be called with thread mutex locked
   4576 bool AudioFlinger::OffloadThread::waitingAsyncCallback_l()
   4577 {
   4578     ALOGVV("waitingAsyncCallback_l mWriteAckSequence %d mDrainSequence %d",
   4579           mWriteAckSequence, mDrainSequence);
   4580     if (mUseAsyncWrite && ((mWriteAckSequence & 1) || (mDrainSequence & 1))) {
   4581         return true;
   4582     }
   4583     return false;
   4584 }
   4585 
   4586 // must be called with thread mutex locked
   4587 bool AudioFlinger::OffloadThread::shouldStandby_l()
   4588 {
   4589     bool trackPaused = false;
   4590 
   4591     // do not put the HAL in standby when paused. AwesomePlayer clear the offloaded AudioTrack
   4592     // after a timeout and we will enter standby then.
   4593     if (mTracks.size() > 0) {
   4594         trackPaused = mTracks[mTracks.size() - 1]->isPaused();
   4595     }
   4596 
   4597     return !mStandby && !trackPaused;
   4598 }
   4599 
   4600 
   4601 bool AudioFlinger::OffloadThread::waitingAsyncCallback()
   4602 {
   4603     Mutex::Autolock _l(mLock);
   4604     return waitingAsyncCallback_l();
   4605 }
   4606 
   4607 void AudioFlinger::OffloadThread::flushHw_l()
   4608 {
   4609     DirectOutputThread::flushHw_l();
   4610     // Flush anything still waiting in the mixbuffer
   4611     mCurrentWriteLength = 0;
   4612     mBytesRemaining = 0;
   4613     mPausedWriteLength = 0;
   4614     mPausedBytesRemaining = 0;
   4615     mHwPaused = false;
   4616 
   4617     if (mUseAsyncWrite) {
   4618         // discard any pending drain or write ack by incrementing sequence
   4619         mWriteAckSequence = (mWriteAckSequence + 2) & ~1;
   4620         mDrainSequence = (mDrainSequence + 2) & ~1;
   4621         ALOG_ASSERT(mCallbackThread != 0);
   4622         mCallbackThread->setWriteBlocked(mWriteAckSequence);
   4623         mCallbackThread->setDraining(mDrainSequence);
   4624     }
   4625 }
   4626 
   4627 void AudioFlinger::OffloadThread::onAddNewTrack_l()
   4628 {
   4629     sp<Track> previousTrack = mPreviousTrack.promote();
   4630     sp<Track> latestTrack = mLatestActiveTrack.promote();
   4631 
   4632     if (previousTrack != 0 && latestTrack != 0 &&
   4633         (previousTrack->sessionId() != latestTrack->sessionId())) {
   4634         mFlushPending = true;
   4635     }
   4636     PlaybackThread::onAddNewTrack_l();
   4637 }
   4638 
   4639 // ----------------------------------------------------------------------------
   4640 
   4641 AudioFlinger::DuplicatingThread::DuplicatingThread(const sp<AudioFlinger>& audioFlinger,
   4642         AudioFlinger::MixerThread* mainThread, audio_io_handle_t id)
   4643     :   MixerThread(audioFlinger, mainThread->getOutput(), id, mainThread->outDevice(),
   4644                 DUPLICATING),
   4645         mWaitTimeMs(UINT_MAX)
   4646 {
   4647     addOutputTrack(mainThread);
   4648 }
   4649 
   4650 AudioFlinger::DuplicatingThread::~DuplicatingThread()
   4651 {
   4652     for (size_t i = 0; i < mOutputTracks.size(); i++) {
   4653         mOutputTracks[i]->destroy();
   4654     }
   4655 }
   4656 
   4657 void AudioFlinger::DuplicatingThread::threadLoop_mix()
   4658 {
   4659     // mix buffers...
   4660     if (outputsReady(outputTracks)) {
   4661         mAudioMixer->process(AudioBufferProvider::kInvalidPTS);
   4662     } else {
   4663         if (mMixerBufferValid) {
   4664             memset(mMixerBuffer, 0, mMixerBufferSize);
   4665         } else {
   4666             memset(mSinkBuffer, 0, mSinkBufferSize);
   4667         }
   4668     }
   4669     sleepTime = 0;
   4670     writeFrames = mNormalFrameCount;
   4671     mCurrentWriteLength = mSinkBufferSize;
   4672     standbyTime = systemTime() + standbyDelay;
   4673 }
   4674 
   4675 void AudioFlinger::DuplicatingThread::threadLoop_sleepTime()
   4676 {
   4677     if (sleepTime == 0) {
   4678         if (mMixerStatus == MIXER_TRACKS_ENABLED) {
   4679             sleepTime = activeSleepTime;
   4680         } else {
   4681             sleepTime = idleSleepTime;
   4682         }
   4683     } else if (mBytesWritten != 0) {
   4684         if (mMixerStatus == MIXER_TRACKS_ENABLED) {
   4685             writeFrames = mNormalFrameCount;
   4686             memset(mSinkBuffer, 0, mSinkBufferSize);
   4687         } else {
   4688             // flush remaining overflow buffers in output tracks
   4689             writeFrames = 0;
   4690         }
   4691         sleepTime = 0;
   4692     }
   4693 }
   4694 
   4695 ssize_t AudioFlinger::DuplicatingThread::threadLoop_write()
   4696 {
   4697     for (size_t i = 0; i < outputTracks.size(); i++) {
   4698         // We convert the duplicating thread format to AUDIO_FORMAT_PCM_16_BIT
   4699         // for delivery downstream as needed. This in-place conversion is safe as
   4700         // AUDIO_FORMAT_PCM_16_BIT is smaller than any other supported format
   4701         // (AUDIO_FORMAT_PCM_8_BIT is not allowed here).
   4702         if (mFormat != AUDIO_FORMAT_PCM_16_BIT) {
   4703             memcpy_by_audio_format(mSinkBuffer, AUDIO_FORMAT_PCM_16_BIT,
   4704                     mSinkBuffer, mFormat, writeFrames * mChannelCount);
   4705         }
   4706         outputTracks[i]->write(reinterpret_cast<int16_t*>(mSinkBuffer), writeFrames);
   4707     }
   4708     mStandby = false;
   4709     return (ssize_t)mSinkBufferSize;
   4710 }
   4711 
   4712 void AudioFlinger::DuplicatingThread::threadLoop_standby()
   4713 {
   4714     // DuplicatingThread implements standby by stopping all tracks
   4715     for (size_t i = 0; i < outputTracks.size(); i++) {
   4716         outputTracks[i]->stop();
   4717     }
   4718 }
   4719 
   4720 void AudioFlinger::DuplicatingThread::saveOutputTracks()
   4721 {
   4722     outputTracks = mOutputTracks;
   4723 }
   4724 
   4725 void AudioFlinger::DuplicatingThread::clearOutputTracks()
   4726 {
   4727     outputTracks.clear();
   4728 }
   4729 
   4730 void AudioFlinger::DuplicatingThread::addOutputTrack(MixerThread *thread)
   4731 {
   4732     Mutex::Autolock _l(mLock);
   4733     // FIXME explain this formula
   4734     size_t frameCount = (3 * mNormalFrameCount * mSampleRate) / thread->sampleRate();
   4735     // OutputTrack is forced to AUDIO_FORMAT_PCM_16_BIT regardless of mFormat
   4736     // due to current usage case and restrictions on the AudioBufferProvider.
   4737     // Actual buffer conversion is done in threadLoop_write().
   4738     //
   4739     // TODO: This may change in the future, depending on multichannel
   4740     // (and non int16_t*) support on AF::PlaybackThread::OutputTrack
   4741     OutputTrack *outputTrack = new OutputTrack(thread,
   4742                                             this,
   4743                                             mSampleRate,
   4744                                             AUDIO_FORMAT_PCM_16_BIT,
   4745                                             mChannelMask,
   4746                                             frameCount,
   4747                                             IPCThreadState::self()->getCallingUid());
   4748     if (outputTrack->cblk() != NULL) {
   4749         thread->setStreamVolume(AUDIO_STREAM_CNT, 1.0f);
   4750         mOutputTracks.add(outputTrack);
   4751         ALOGV("addOutputTrack() track %p, on thread %p", outputTrack, thread);
   4752         updateWaitTime_l();
   4753     }
   4754 }
   4755 
   4756 void AudioFlinger::DuplicatingThread::removeOutputTrack(MixerThread *thread)
   4757 {
   4758     Mutex::Autolock _l(mLock);
   4759     for (size_t i = 0; i < mOutputTracks.size(); i++) {
   4760         if (mOutputTracks[i]->thread() == thread) {
   4761             mOutputTracks[i]->destroy();
   4762             mOutputTracks.removeAt(i);
   4763             updateWaitTime_l();
   4764             return;
   4765         }
   4766     }
   4767     ALOGV("removeOutputTrack(): unkonwn thread: %p", thread);
   4768 }
   4769 
   4770 // caller must hold mLock
   4771 void AudioFlinger::DuplicatingThread::updateWaitTime_l()
   4772 {
   4773     mWaitTimeMs = UINT_MAX;
   4774     for (size_t i = 0; i < mOutputTracks.size(); i++) {
   4775         sp<ThreadBase> strong = mOutputTracks[i]->thread().promote();
   4776         if (strong != 0) {
   4777             uint32_t waitTimeMs = (strong->frameCount() * 2 * 1000) / strong->sampleRate();
   4778             if (waitTimeMs < mWaitTimeMs) {
   4779                 mWaitTimeMs = waitTimeMs;
   4780             }
   4781         }
   4782     }
   4783 }
   4784 
   4785 
   4786 bool AudioFlinger::DuplicatingThread::outputsReady(
   4787         const SortedVector< sp<OutputTrack> > &outputTracks)
   4788 {
   4789     for (size_t i = 0; i < outputTracks.size(); i++) {
   4790         sp<ThreadBase> thread = outputTracks[i]->thread().promote();
   4791         if (thread == 0) {
   4792             ALOGW("DuplicatingThread::outputsReady() could not promote thread on output track %p",
   4793                     outputTracks[i].get());
   4794             return false;
   4795         }
   4796         PlaybackThread *playbackThread = (PlaybackThread *)thread.get();
   4797         // see note at standby() declaration
   4798         if (playbackThread->standby() && !playbackThread->isSuspended()) {
   4799             ALOGV("DuplicatingThread output track %p on thread %p Not Ready", outputTracks[i].get(),
   4800                     thread.get());
   4801             return false;
   4802         }
   4803     }
   4804     return true;
   4805 }
   4806 
   4807 uint32_t AudioFlinger::DuplicatingThread::activeSleepTimeUs() const
   4808 {
   4809     return (mWaitTimeMs * 1000) / 2;
   4810 }
   4811 
   4812 void AudioFlinger::DuplicatingThread::cacheParameters_l()
   4813 {
   4814     // updateWaitTime_l() sets mWaitTimeMs, which affects activeSleepTimeUs(), so call it first
   4815     updateWaitTime_l();
   4816 
   4817     MixerThread::cacheParameters_l();
   4818 }
   4819 
   4820 // ----------------------------------------------------------------------------
   4821 //      Record
   4822 // ----------------------------------------------------------------------------
   4823 
   4824 AudioFlinger::RecordThread::RecordThread(const sp<AudioFlinger>& audioFlinger,
   4825                                          AudioStreamIn *input,
   4826                                          audio_io_handle_t id,
   4827                                          audio_devices_t outDevice,
   4828                                          audio_devices_t inDevice
   4829 #ifdef TEE_SINK
   4830                                          , const sp<NBAIO_Sink>& teeSink
   4831 #endif
   4832                                          ) :
   4833     ThreadBase(audioFlinger, id, outDevice, inDevice, RECORD),
   4834     mInput(input), mActiveTracksGen(0), mRsmpInBuffer(NULL),
   4835     // mRsmpInFrames and mRsmpInFramesP2 are set by readInputParameters_l()
   4836     mRsmpInRear(0)
   4837 #ifdef TEE_SINK
   4838     , mTeeSink(teeSink)
   4839 #endif
   4840     , mReadOnlyHeap(new MemoryDealer(kRecordThreadReadOnlyHeapSize,
   4841             "RecordThreadRO", MemoryHeapBase::READ_ONLY))
   4842     // mFastCapture below
   4843     , mFastCaptureFutex(0)
   4844     // mInputSource
   4845     // mPipeSink
   4846     // mPipeSource
   4847     , mPipeFramesP2(0)
   4848     // mPipeMemory
   4849     // mFastCaptureNBLogWriter
   4850     , mFastTrackAvail(false)
   4851 {
   4852     snprintf(mName, kNameLength, "AudioIn_%X", id);
   4853     mNBLogWriter = audioFlinger->newWriter_l(kLogSize, mName);
   4854 
   4855     readInputParameters_l();
   4856 
   4857     // create an NBAIO source for the HAL input stream, and negotiate
   4858     mInputSource = new AudioStreamInSource(input->stream);
   4859     size_t numCounterOffers = 0;
   4860     const NBAIO_Format offers[1] = {Format_from_SR_C(mSampleRate, mChannelCount, mFormat)};
   4861     ssize_t index = mInputSource->negotiate(offers, 1, NULL, numCounterOffers);
   4862     ALOG_ASSERT(index == 0);
   4863 
   4864     // initialize fast capture depending on configuration
   4865     bool initFastCapture;
   4866     switch (kUseFastCapture) {
   4867     case FastCapture_Never:
   4868         initFastCapture = false;
   4869         break;
   4870     case FastCapture_Always:
   4871         initFastCapture = true;
   4872         break;
   4873     case FastCapture_Static:
   4874         uint32_t primaryOutputSampleRate;
   4875         {
   4876             AutoMutex _l(audioFlinger->mHardwareLock);
   4877             primaryOutputSampleRate = audioFlinger->mPrimaryOutputSampleRate;
   4878         }
   4879         initFastCapture =
   4880                 // either capture sample rate is same as (a reasonable) primary output sample rate
   4881                 (((primaryOutputSampleRate == 44100 || primaryOutputSampleRate == 48000) &&
   4882                     (mSampleRate == primaryOutputSampleRate)) ||
   4883                 // or primary output sample rate is unknown, and capture sample rate is reasonable
   4884                 ((primaryOutputSampleRate == 0) &&
   4885                     ((mSampleRate == 44100 || mSampleRate == 48000)))) &&
   4886                 // and the buffer size is < 12 ms
   4887                 (mFrameCount * 1000) / mSampleRate < 12;
   4888         break;
   4889     // case FastCapture_Dynamic:
   4890     }
   4891 
   4892     if (initFastCapture) {
   4893         // create a Pipe for FastMixer to write to, and for us and fast tracks to read from
   4894         NBAIO_Format format = mInputSource->format();
   4895         size_t pipeFramesP2 = roundup(mSampleRate / 25);    // double-buffering of 20 ms each
   4896         size_t pipeSize = pipeFramesP2 * Format_frameSize(format);
   4897         void *pipeBuffer;
   4898         const sp<MemoryDealer> roHeap(readOnlyHeap());
   4899         sp<IMemory> pipeMemory;
   4900         if ((roHeap == 0) ||
   4901                 (pipeMemory = roHeap->allocate(pipeSize)) == 0 ||
   4902                 (pipeBuffer = pipeMemory->pointer()) == NULL) {
   4903             ALOGE("not enough memory for pipe buffer size=%zu", pipeSize);
   4904             goto failed;
   4905         }
   4906         // pipe will be shared directly with fast clients, so clear to avoid leaking old information
   4907         memset(pipeBuffer, 0, pipeSize);
   4908         Pipe *pipe = new Pipe(pipeFramesP2, format, pipeBuffer);
   4909         const NBAIO_Format offers[1] = {format};
   4910         size_t numCounterOffers = 0;
   4911         ssize_t index = pipe->negotiate(offers, 1, NULL, numCounterOffers);
   4912         ALOG_ASSERT(index == 0);
   4913         mPipeSink = pipe;
   4914         PipeReader *pipeReader = new PipeReader(*pipe);
   4915         numCounterOffers = 0;
   4916         index = pipeReader->negotiate(offers, 1, NULL, numCounterOffers);
   4917         ALOG_ASSERT(index == 0);
   4918         mPipeSource = pipeReader;
   4919         mPipeFramesP2 = pipeFramesP2;
   4920         mPipeMemory = pipeMemory;
   4921 
   4922         // create fast capture
   4923         mFastCapture = new FastCapture();
   4924         FastCaptureStateQueue *sq = mFastCapture->sq();
   4925 #ifdef STATE_QUEUE_DUMP
   4926         // FIXME
   4927 #endif
   4928         FastCaptureState *state = sq->begin();
   4929         state->mCblk = NULL;
   4930         state->mInputSource = mInputSource.get();
   4931         state->mInputSourceGen++;
   4932         state->mPipeSink = pipe;
   4933         state->mPipeSinkGen++;
   4934         state->mFrameCount = mFrameCount;
   4935         state->mCommand = FastCaptureState::COLD_IDLE;
   4936         // already done in constructor initialization list
   4937         //mFastCaptureFutex = 0;
   4938         state->mColdFutexAddr = &mFastCaptureFutex;
   4939         state->mColdGen++;
   4940         state->mDumpState = &mFastCaptureDumpState;
   4941 #ifdef TEE_SINK
   4942         // FIXME
   4943 #endif
   4944         mFastCaptureNBLogWriter = audioFlinger->newWriter_l(kFastCaptureLogSize, "FastCapture");
   4945         state->mNBLogWriter = mFastCaptureNBLogWriter.get();
   4946         sq->end();
   4947         sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
   4948 
   4949         // start the fast capture
   4950         mFastCapture->run("FastCapture", ANDROID_PRIORITY_URGENT_AUDIO);
   4951         pid_t tid = mFastCapture->getTid();
   4952         int err = requestPriority(getpid_cached, tid, kPriorityFastMixer);
   4953         if (err != 0) {
   4954             ALOGW("Policy SCHED_FIFO priority %d is unavailable for pid %d tid %d; error %d",
   4955                     kPriorityFastCapture, getpid_cached, tid, err);
   4956         }
   4957 
   4958 #ifdef AUDIO_WATCHDOG
   4959         // FIXME
   4960 #endif
   4961 
   4962         mFastTrackAvail = true;
   4963     }
   4964 failed: ;
   4965 
   4966     // FIXME mNormalSource
   4967 }
   4968 
   4969 
   4970 AudioFlinger::RecordThread::~RecordThread()
   4971 {
   4972     if (mFastCapture != 0) {
   4973         FastCaptureStateQueue *sq = mFastCapture->sq();
   4974         FastCaptureState *state = sq->begin();
   4975         if (state->mCommand == FastCaptureState::COLD_IDLE) {
   4976             int32_t old = android_atomic_inc(&mFastCaptureFutex);
   4977             if (old == -1) {
   4978                 (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
   4979             }
   4980         }
   4981         state->mCommand = FastCaptureState::EXIT;
   4982         sq->end();
   4983         sq->push(FastCaptureStateQueue::BLOCK_UNTIL_PUSHED);
   4984         mFastCapture->join();
   4985         mFastCapture.clear();
   4986     }
   4987     mAudioFlinger->unregisterWriter(mFastCaptureNBLogWriter);
   4988     mAudioFlinger->unregisterWriter(mNBLogWriter);
   4989     delete[] mRsmpInBuffer;
   4990 }
   4991 
   4992 void AudioFlinger::RecordThread::onFirstRef()
   4993 {
   4994     run(mName, PRIORITY_URGENT_AUDIO);
   4995 }
   4996 
   4997 bool AudioFlinger::RecordThread::threadLoop()
   4998 {
   4999     nsecs_t lastWarning = 0;
   5000 
   5001     inputStandBy();
   5002 
   5003 reacquire_wakelock:
   5004     sp<RecordTrack> activeTrack;
   5005     int activeTracksGen;
   5006     {
   5007         Mutex::Autolock _l(mLock);
   5008         size_t size = mActiveTracks.size();
   5009         activeTracksGen = mActiveTracksGen;
   5010         if (size > 0) {
   5011             // FIXME an arbitrary choice
   5012             activeTrack = mActiveTracks[0];
   5013             acquireWakeLock_l(activeTrack->uid());
   5014             if (size > 1) {
   5015                 SortedVector<int> tmp;
   5016                 for (size_t i = 0; i < size; i++) {
   5017                     tmp.add(mActiveTracks[i]->uid());
   5018                 }
   5019                 updateWakeLockUids_l(tmp);
   5020             }
   5021         } else {
   5022             acquireWakeLock_l(-1);
   5023         }
   5024     }
   5025 
   5026     // used to request a deferred sleep, to be executed later while mutex is unlocked
   5027     uint32_t sleepUs = 0;
   5028 
   5029     // loop while there is work to do
   5030     for (;;) {
   5031         Vector< sp<EffectChain> > effectChains;
   5032 
   5033         // sleep with mutex unlocked
   5034         if (sleepUs > 0) {
   5035             usleep(sleepUs);
   5036             sleepUs = 0;
   5037         }
   5038 
   5039         // activeTracks accumulates a copy of a subset of mActiveTracks
   5040         Vector< sp<RecordTrack> > activeTracks;
   5041 
   5042         // reference to the (first and only) active fast track
   5043         sp<RecordTrack> fastTrack;
   5044 
   5045         // reference to a fast track which is about to be removed
   5046         sp<RecordTrack> fastTrackToRemove;
   5047 
   5048         { // scope for mLock
   5049             Mutex::Autolock _l(mLock);
   5050 
   5051             processConfigEvents_l();
   5052 
   5053             // check exitPending here because checkForNewParameters_l() and
   5054             // checkForNewParameters_l() can temporarily release mLock
   5055             if (exitPending()) {
   5056                 break;
   5057             }
   5058 
   5059             // if no active track(s), then standby and release wakelock
   5060             size_t size = mActiveTracks.size();
   5061             if (size == 0) {
   5062                 standbyIfNotAlreadyInStandby();
   5063                 // exitPending() can't become true here
   5064                 releaseWakeLock_l();
   5065                 ALOGV("RecordThread: loop stopping");
   5066                 // go to sleep
   5067                 mWaitWorkCV.wait(mLock);
   5068                 ALOGV("RecordThread: loop starting");
   5069                 goto reacquire_wakelock;
   5070             }
   5071 
   5072             if (mActiveTracksGen != activeTracksGen) {
   5073                 activeTracksGen = mActiveTracksGen;
   5074                 SortedVector<int> tmp;
   5075                 for (size_t i = 0; i < size; i++) {
   5076                     tmp.add(mActiveTracks[i]->uid());
   5077                 }
   5078                 updateWakeLockUids_l(tmp);
   5079             }
   5080 
   5081             bool doBroadcast = false;
   5082             for (size_t i = 0; i < size; ) {
   5083 
   5084                 activeTrack = mActiveTracks[i];
   5085                 if (activeTrack->isTerminated()) {
   5086                     if (activeTrack->isFastTrack()) {
   5087                         ALOG_ASSERT(fastTrackToRemove == 0);
   5088                         fastTrackToRemove = activeTrack;
   5089                     }
   5090                     removeTrack_l(activeTrack);
   5091                     mActiveTracks.remove(activeTrack);
   5092                     mActiveTracksGen++;
   5093                     size--;
   5094                     continue;
   5095                 }
   5096 
   5097                 TrackBase::track_state activeTrackState = activeTrack->mState;
   5098                 switch (activeTrackState) {
   5099 
   5100                 case TrackBase::PAUSING:
   5101                     mActiveTracks.remove(activeTrack);
   5102                     mActiveTracksGen++;
   5103                     doBroadcast = true;
   5104                     size--;
   5105                     continue;
   5106 
   5107                 case TrackBase::STARTING_1:
   5108                     sleepUs = 10000;
   5109                     i++;
   5110                     continue;
   5111 
   5112                 case TrackBase::STARTING_2:
   5113                     doBroadcast = true;
   5114                     mStandby = false;
   5115                     activeTrack->mState = TrackBase::ACTIVE;
   5116                     break;
   5117 
   5118                 case TrackBase::ACTIVE:
   5119                     break;
   5120 
   5121                 case TrackBase::IDLE:
   5122                     i++;
   5123                     continue;
   5124 
   5125                 default:
   5126                     LOG_ALWAYS_FATAL("Unexpected activeTrackState %d", activeTrackState);
   5127                 }
   5128 
   5129                 activeTracks.add(activeTrack);
   5130                 i++;
   5131 
   5132                 if (activeTrack->isFastTrack()) {
   5133                     ALOG_ASSERT(!mFastTrackAvail);
   5134                     ALOG_ASSERT(fastTrack == 0);
   5135                     fastTrack = activeTrack;
   5136                 }
   5137             }
   5138             if (doBroadcast) {
   5139                 mStartStopCond.broadcast();
   5140             }
   5141 
   5142             // sleep if there are no active tracks to process
   5143             if (activeTracks.size() == 0) {
   5144                 if (sleepUs == 0) {
   5145                     sleepUs = kRecordThreadSleepUs;
   5146                 }
   5147                 continue;
   5148             }
   5149             sleepUs = 0;
   5150 
   5151             lockEffectChains_l(effectChains);
   5152         }
   5153 
   5154         // thread mutex is now unlocked, mActiveTracks unknown, activeTracks.size() > 0
   5155 
   5156         size_t size = effectChains.size();
   5157         for (size_t i = 0; i < size; i++) {
   5158             // thread mutex is not locked, but effect chain is locked
   5159             effectChains[i]->process_l();
   5160         }
   5161 
   5162         // Push a new fast capture state if fast capture is not already running, or cblk change
   5163         if (mFastCapture != 0) {
   5164             FastCaptureStateQueue *sq = mFastCapture->sq();
   5165             FastCaptureState *state = sq->begin();
   5166             bool didModify = false;
   5167             FastCaptureStateQueue::block_t block = FastCaptureStateQueue::BLOCK_UNTIL_PUSHED;
   5168             if (state->mCommand != FastCaptureState::READ_WRITE /* FIXME &&
   5169                     (kUseFastMixer != FastMixer_Dynamic || state->mTrackMask > 1)*/) {
   5170                 if (state->mCommand == FastCaptureState::COLD_IDLE) {
   5171                     int32_t old = android_atomic_inc(&mFastCaptureFutex);
   5172                     if (old == -1) {
   5173                         (void) syscall(__NR_futex, &mFastCaptureFutex, FUTEX_WAKE_PRIVATE, 1);
   5174                     }
   5175                 }
   5176                 state->mCommand = FastCaptureState::READ_WRITE;
   5177 #if 0   // FIXME
   5178                 mFastCaptureDumpState.increaseSamplingN(mAudioFlinger->isLowRamDevice() ?
   5179                         FastCaptureDumpState::kSamplingNforLowRamDevice : FastMixerDumpState::kSamplingN);
   5180 #endif
   5181                 didModify = true;
   5182             }
   5183             audio_track_cblk_t *cblkOld = state->mCblk;
   5184             audio_track_cblk_t *cblkNew = fastTrack != 0 ? fastTrack->cblk() : NULL;
   5185             if (cblkNew != cblkOld) {
   5186                 state->mCblk = cblkNew;
   5187                 // block until acked if removing a fast track
   5188                 if (cblkOld != NULL) {
   5189                     block = FastCaptureStateQueue::BLOCK_UNTIL_ACKED;
   5190                 }
   5191                 didModify = true;
   5192             }
   5193             sq->end(didModify);
   5194             if (didModify) {
   5195                 sq->push(block);
   5196 #if 0
   5197                 if (kUseFastCapture == FastCapture_Dynamic) {
   5198                     mNormalSource = mPipeSource;
   5199                 }
   5200 #endif
   5201             }
   5202         }
   5203 
   5204         // now run the fast track destructor with thread mutex unlocked
   5205         fastTrackToRemove.clear();
   5206 
   5207         // Read from HAL to keep up with fastest client if multiple active tracks, not slowest one.
   5208         // Only the client(s) that are too slow will overrun. But if even the fastest client is too
   5209         // slow, then this RecordThread will overrun by not calling HAL read often enough.
   5210         // If destination is non-contiguous, first read past the nominal end of buffer, then
   5211         // copy to the right place.  Permitted because mRsmpInBuffer was over-allocated.
   5212 
   5213         int32_t rear = mRsmpInRear & (mRsmpInFramesP2 - 1);
   5214         ssize_t framesRead;
   5215 
   5216         // If an NBAIO source is present, use it to read the normal capture's data
   5217         if (mPipeSource != 0) {
   5218             size_t framesToRead = mBufferSize / mFrameSize;
   5219             framesRead = mPipeSource->read(&mRsmpInBuffer[rear * mChannelCount],
   5220                     framesToRead, AudioBufferProvider::kInvalidPTS);
   5221             if (framesRead == 0) {
   5222                 // since pipe is non-blocking, simulate blocking input
   5223                 sleepUs = (framesToRead * 1000000LL) / mSampleRate;
   5224             }
   5225         // otherwise use the HAL / AudioStreamIn directly
   5226         } else {
   5227             ssize_t bytesRead = mInput->stream->read(mInput->stream,
   5228                     &mRsmpInBuffer[rear * mChannelCount], mBufferSize);
   5229             if (bytesRead < 0) {
   5230                 framesRead = bytesRead;
   5231             } else {
   5232                 framesRead = bytesRead / mFrameSize;
   5233             }
   5234         }
   5235 
   5236         if (framesRead < 0 || (framesRead == 0 && mPipeSource == 0)) {
   5237             ALOGE("read failed: framesRead=%d", framesRead);
   5238             // Force input into standby so that it tries to recover at next read attempt
   5239             inputStandBy();
   5240             sleepUs = kRecordThreadSleepUs;
   5241         }
   5242         if (framesRead <= 0) {
   5243             goto unlock;
   5244         }
   5245         ALOG_ASSERT(framesRead > 0);
   5246 
   5247         if (mTeeSink != 0) {
   5248             (void) mTeeSink->write(&mRsmpInBuffer[rear * mChannelCount], framesRead);
   5249         }
   5250         // If destination is non-contiguous, we now correct for reading past end of buffer.
   5251         {
   5252             size_t part1 = mRsmpInFramesP2 - rear;
   5253             if ((size_t) framesRead > part1) {
   5254                 memcpy(mRsmpInBuffer, &mRsmpInBuffer[mRsmpInFramesP2 * mChannelCount],
   5255                         (framesRead - part1) * mFrameSize);
   5256             }
   5257         }
   5258         rear = mRsmpInRear += framesRead;
   5259 
   5260         size = activeTracks.size();
   5261         // loop over each active track
   5262         for (size_t i = 0; i < size; i++) {
   5263             activeTrack = activeTracks[i];
   5264 
   5265             // skip fast tracks, as those are handled directly by FastCapture
   5266             if (activeTrack->isFastTrack()) {
   5267                 continue;
   5268             }
   5269 
   5270             enum {
   5271                 OVERRUN_UNKNOWN,
   5272                 OVERRUN_TRUE,
   5273                 OVERRUN_FALSE
   5274             } overrun = OVERRUN_UNKNOWN;
   5275 
   5276             // loop over getNextBuffer to handle circular sink
   5277             for (;;) {
   5278 
   5279                 activeTrack->mSink.frameCount = ~0;
   5280                 status_t status = activeTrack->getNextBuffer(&activeTrack->mSink);
   5281                 size_t framesOut = activeTrack->mSink.frameCount;
   5282                 LOG_ALWAYS_FATAL_IF((status == OK) != (framesOut > 0));
   5283 
   5284                 int32_t front = activeTrack->mRsmpInFront;
   5285                 ssize_t filled = rear - front;
   5286                 size_t framesIn;
   5287 
   5288                 if (filled < 0) {
   5289                     // should not happen, but treat like a massive overrun and re-sync
   5290                     framesIn = 0;
   5291                     activeTrack->mRsmpInFront = rear;
   5292                     overrun = OVERRUN_TRUE;
   5293                 } else if ((size_t) filled <= mRsmpInFrames) {
   5294                     framesIn = (size_t) filled;
   5295                 } else {
   5296                     // client is not keeping up with server, but give it latest data
   5297                     framesIn = mRsmpInFrames;
   5298                     activeTrack->mRsmpInFront = front = rear - framesIn;
   5299                     overrun = OVERRUN_TRUE;
   5300                 }
   5301 
   5302                 if (framesOut == 0 || framesIn == 0) {
   5303                     break;
   5304                 }
   5305 
   5306                 if (activeTrack->mResampler == NULL) {
   5307                     // no resampling
   5308                     if (framesIn > framesOut) {
   5309                         framesIn = framesOut;
   5310                     } else {
   5311                         framesOut = framesIn;
   5312                     }
   5313                     int8_t *dst = activeTrack->mSink.i8;
   5314                     while (framesIn > 0) {
   5315                         front &= mRsmpInFramesP2 - 1;
   5316                         size_t part1 = mRsmpInFramesP2 - front;
   5317                         if (part1 > framesIn) {
   5318                             part1 = framesIn;
   5319                         }
   5320                         int8_t *src = (int8_t *)mRsmpInBuffer + (front * mFrameSize);
   5321                         if (mChannelCount == activeTrack->mChannelCount) {
   5322                             memcpy(dst, src, part1 * mFrameSize);
   5323                         } else if (mChannelCount == 1) {
   5324                             upmix_to_stereo_i16_from_mono_i16((int16_t *)dst, (const int16_t *)src,
   5325                                     part1);
   5326                         } else {
   5327                             downmix_to_mono_i16_from_stereo_i16((int16_t *)dst, (const int16_t *)src,
   5328                                     part1);
   5329                         }
   5330                         dst += part1 * activeTrack->mFrameSize;
   5331                         front += part1;
   5332                         framesIn -= part1;
   5333                     }
   5334                     activeTrack->mRsmpInFront += framesOut;
   5335 
   5336                 } else {
   5337                     // resampling
   5338                     // FIXME framesInNeeded should really be part of resampler API, and should
   5339                     //       depend on the SRC ratio
   5340                     //       to keep mRsmpInBuffer full so resampler always has sufficient input
   5341                     size_t framesInNeeded;
   5342                     // FIXME only re-calculate when it changes, and optimize for common ratios
   5343                     // Do not precompute in/out because floating point is not associative
   5344                     // e.g. a*b/c != a*(b/c).
   5345                     const double in(mSampleRate);
   5346                     const double out(activeTrack->mSampleRate);
   5347                     framesInNeeded = ceil(framesOut * in / out) + 1;
   5348                     ALOGV("need %u frames in to produce %u out given in/out ratio of %.4g",
   5349                                 framesInNeeded, framesOut, in / out);
   5350                     // Although we theoretically have framesIn in circular buffer, some of those are
   5351                     // unreleased frames, and thus must be discounted for purpose of budgeting.
   5352                     size_t unreleased = activeTrack->mRsmpInUnrel;
   5353                     framesIn = framesIn > unreleased ? framesIn - unreleased : 0;
   5354                     if (framesIn < framesInNeeded) {
   5355                         ALOGV("not enough to resample: have %u frames in but need %u in to "
   5356                                 "produce %u out given in/out ratio of %.4g",
   5357                                 framesIn, framesInNeeded, framesOut, in / out);
   5358                         size_t newFramesOut = framesIn > 0 ? floor((framesIn - 1) * out / in) : 0;
   5359                         LOG_ALWAYS_FATAL_IF(newFramesOut >= framesOut);
   5360                         if (newFramesOut == 0) {
   5361                             break;
   5362                         }
   5363                         framesInNeeded = ceil(newFramesOut * in / out) + 1;
   5364                         ALOGV("now need %u frames in to produce %u out given out/in ratio of %.4g",
   5365                                 framesInNeeded, newFramesOut, out / in);
   5366                         LOG_ALWAYS_FATAL_IF(framesIn < framesInNeeded);
   5367                         ALOGV("success 2: have %u frames in and need %u in to produce %u out "
   5368                               "given in/out ratio of %.4g",
   5369                               framesIn, framesInNeeded, newFramesOut, in / out);
   5370                         framesOut = newFramesOut;
   5371                     } else {
   5372                         ALOGV("success 1: have %u in and need %u in to produce %u out "
   5373                             "given in/out ratio of %.4g",
   5374                             framesIn, framesInNeeded, framesOut, in / out);
   5375                     }
   5376 
   5377                     // reallocate mRsmpOutBuffer as needed; we will grow but never shrink
   5378                     if (activeTrack->mRsmpOutFrameCount < framesOut) {
   5379                         // FIXME why does each track need it's own mRsmpOutBuffer? can't they share?
   5380                         delete[] activeTrack->mRsmpOutBuffer;
   5381                         // resampler always outputs stereo
   5382                         activeTrack->mRsmpOutBuffer = new int32_t[framesOut * FCC_2];
   5383                         activeTrack->mRsmpOutFrameCount = framesOut;
   5384                     }
   5385 
   5386                     // resampler accumulates, but we only have one source track
   5387                     memset(activeTrack->mRsmpOutBuffer, 0, framesOut * FCC_2 * sizeof(int32_t));
   5388                     activeTrack->mResampler->resample(activeTrack->mRsmpOutBuffer, framesOut,
   5389                             // FIXME how about having activeTrack implement this interface itself?
   5390                             activeTrack->mResamplerBufferProvider
   5391                             /*this*/ /* AudioBufferProvider* */);
   5392                     // ditherAndClamp() works as long as all buffers returned by
   5393                     // activeTrack->getNextBuffer() are 32 bit aligned which should be always true.
   5394                     if (activeTrack->mChannelCount == 1) {
   5395                         // temporarily type pun mRsmpOutBuffer from Q4.27 to int16_t
   5396                         ditherAndClamp(activeTrack->mRsmpOutBuffer, activeTrack->mRsmpOutBuffer,
   5397                                 framesOut);
   5398                         // the resampler always outputs stereo samples:
   5399                         // do post stereo to mono conversion
   5400                         downmix_to_mono_i16_from_stereo_i16(activeTrack->mSink.i16,
   5401                                 (const int16_t *)activeTrack->mRsmpOutBuffer, framesOut);
   5402                     } else {
   5403                         ditherAndClamp((int32_t *)activeTrack->mSink.raw,
   5404                                 activeTrack->mRsmpOutBuffer, framesOut);
   5405                     }
   5406                     // now done with mRsmpOutBuffer
   5407 
   5408                 }
   5409 
   5410                 if (framesOut > 0 && (overrun == OVERRUN_UNKNOWN)) {
   5411                     overrun = OVERRUN_FALSE;
   5412                 }
   5413 
   5414                 if (activeTrack->mFramesToDrop == 0) {
   5415                     if (framesOut > 0) {
   5416                         activeTrack->mSink.frameCount = framesOut;
   5417                         activeTrack->releaseBuffer(&activeTrack->mSink);
   5418                     }
   5419                 } else {
   5420                     // FIXME could do a partial drop of framesOut
   5421                     if (activeTrack->mFramesToDrop > 0) {
   5422                         activeTrack->mFramesToDrop -= framesOut;
   5423                         if (activeTrack->mFramesToDrop <= 0) {
   5424                             activeTrack->clearSyncStartEvent();
   5425                         }
   5426                     } else {
   5427                         activeTrack->mFramesToDrop += framesOut;
   5428                         if (activeTrack->mFramesToDrop >= 0 || activeTrack->mSyncStartEvent == 0 ||
   5429                                 activeTrack->mSyncStartEvent->isCancelled()) {
   5430                             ALOGW("Synced record %s, session %d, trigger session %d",
   5431                                   (activeTrack->mFramesToDrop >= 0) ? "timed out" : "cancelled",
   5432                                   activeTrack->sessionId(),
   5433                                   (activeTrack->mSyncStartEvent != 0) ?
   5434                                           activeTrack->mSyncStartEvent->triggerSession() : 0);
   5435                             activeTrack->clearSyncStartEvent();
   5436                         }
   5437                     }
   5438                 }
   5439 
   5440                 if (framesOut == 0) {
   5441                     break;
   5442                 }
   5443             }
   5444 
   5445             switch (overrun) {
   5446             case OVERRUN_TRUE:
   5447                 // client isn't retrieving buffers fast enough
   5448                 if (!activeTrack->setOverflow()) {
   5449                     nsecs_t now = systemTime();
   5450                     // FIXME should lastWarning per track?
   5451                     if ((now - lastWarning) > kWarningThrottleNs) {
   5452                         ALOGW("RecordThread: buffer overflow");
   5453                         lastWarning = now;
   5454                     }
   5455                 }
   5456                 break;
   5457             case OVERRUN_FALSE:
   5458                 activeTrack->clearOverflow();
   5459                 break;
   5460             case OVERRUN_UNKNOWN:
   5461                 break;
   5462             }
   5463 
   5464         }
   5465 
   5466 unlock:
   5467         // enable changes in effect chain
   5468         unlockEffectChains(effectChains);
   5469         // effectChains doesn't need to be cleared, since it is cleared by destructor at scope end
   5470     }
   5471 
   5472     standbyIfNotAlreadyInStandby();
   5473 
   5474     {
   5475         Mutex::Autolock _l(mLock);
   5476         for (size_t i = 0; i < mTracks.size(); i++) {
   5477             sp<RecordTrack> track = mTracks[i];
   5478             track->invalidate();
   5479         }
   5480         mActiveTracks.clear();
   5481         mActiveTracksGen++;
   5482         mStartStopCond.broadcast();
   5483     }
   5484 
   5485     releaseWakeLock();
   5486 
   5487     ALOGV("RecordThread %p exiting", this);
   5488     return false;
   5489 }
   5490 
   5491 void AudioFlinger::RecordThread::standbyIfNotAlreadyInStandby()
   5492 {
   5493     if (!mStandby) {
   5494         inputStandBy();
   5495         mStandby = true;
   5496     }
   5497 }
   5498 
   5499 void AudioFlinger::RecordThread::inputStandBy()
   5500 {
   5501     // Idle the fast capture if it's currently running
   5502     if (mFastCapture != 0) {
   5503         FastCaptureStateQueue *sq = mFastCapture->sq();
   5504         FastCaptureState *state = sq->begin();
   5505         if (!(state->mCommand & FastCaptureState::IDLE)) {
   5506             state->mCommand = FastCaptureState::COLD_IDLE;
   5507             state->mColdFutexAddr = &mFastCaptureFutex;
   5508             state->mColdGen++;
   5509             mFastCaptureFutex = 0;
   5510             sq->end();
   5511             // BLOCK_UNTIL_PUSHED would be insufficient, as we need it to stop doing I/O now
   5512             sq->push(FastCaptureStateQueue::BLOCK_UNTIL_ACKED);
   5513 #if 0
   5514             if (kUseFastCapture == FastCapture_Dynamic) {
   5515                 // FIXME
   5516             }
   5517 #endif
   5518 #ifdef AUDIO_WATCHDOG
   5519             // FIXME
   5520 #endif
   5521         } else {
   5522             sq->end(false /*didModify*/);
   5523         }
   5524     }
   5525     mInput->stream->common.standby(&mInput->stream->common);
   5526 }
   5527 
   5528 // RecordThread::createRecordTrack_l() must be called with AudioFlinger::mLock held
   5529 sp<AudioFlinger::RecordThread::RecordTrack> AudioFlinger::RecordThread::createRecordTrack_l(
   5530         const sp<AudioFlinger::Client>& client,
   5531         uint32_t sampleRate,
   5532         audio_format_t format,
   5533         audio_channel_mask_t channelMask,
   5534         size_t *pFrameCount,
   5535         int sessionId,
   5536         size_t *notificationFrames,
   5537         int uid,
   5538         IAudioFlinger::track_flags_t *flags,
   5539         pid_t tid,
   5540         status_t *status)
   5541 {
   5542     size_t frameCount = *pFrameCount;
   5543     sp<RecordTrack> track;
   5544     status_t lStatus;
   5545 
   5546     // client expresses a preference for FAST, but we get the final say
   5547     if (*flags & IAudioFlinger::TRACK_FAST) {
   5548       if (
   5549             // use case: callback handler
   5550             (tid != -1) &&
   5551             // frame count is not specified, or is exactly the pipe depth
   5552             ((frameCount == 0) || (frameCount == mPipeFramesP2)) &&
   5553             // PCM data
   5554             audio_is_linear_pcm(format) &&
   5555             // native format
   5556             (format == mFormat) &&
   5557             // native channel mask
   5558             (channelMask == mChannelMask) &&
   5559             // native hardware sample rate
   5560             (sampleRate == mSampleRate) &&
   5561             // record thread has an associated fast capture
   5562             hasFastCapture() &&
   5563             // there are sufficient fast track slots available
   5564             mFastTrackAvail
   5565         ) {
   5566         ALOGV("AUDIO_INPUT_FLAG_FAST accepted: frameCount=%u mFrameCount=%u",
   5567                 frameCount, mFrameCount);
   5568       } else {
   5569         ALOGV("AUDIO_INPUT_FLAG_FAST denied: frameCount=%u mFrameCount=%u mPipeFramesP2=%u "
   5570                 "format=%#x isLinear=%d channelMask=%#x sampleRate=%u mSampleRate=%u "
   5571                 "hasFastCapture=%d tid=%d mFastTrackAvail=%d",
   5572                 frameCount, mFrameCount, mPipeFramesP2,
   5573                 format, audio_is_linear_pcm(format), channelMask, sampleRate, mSampleRate,
   5574                 hasFastCapture(), tid, mFastTrackAvail);
   5575         *flags &= ~IAudioFlinger::TRACK_FAST;
   5576       }
   5577     }
   5578 
   5579     // compute track buffer size in frames, and suggest the notification frame count
   5580     if (*flags & IAudioFlinger::TRACK_FAST) {
   5581         // fast track: frame count is exactly the pipe depth
   5582         frameCount = mPipeFramesP2;
   5583         // ignore requested notificationFrames, and always notify exactly once every HAL buffer
   5584         *notificationFrames = mFrameCount;
   5585     } else {
   5586         // not fast track: max notification period is resampled equivalent of one HAL buffer time
   5587         //                 or 20 ms if there is a fast capture
   5588         // TODO This could be a roundupRatio inline, and const
   5589         size_t maxNotificationFrames = ((int64_t) (hasFastCapture() ? mSampleRate/50 : mFrameCount)
   5590                 * sampleRate + mSampleRate - 1) / mSampleRate;
   5591         // minimum number of notification periods is at least kMinNotifications,
   5592         // and at least kMinMs rounded up to a whole notification period (minNotificationsByMs)
   5593         static const size_t kMinNotifications = 3;
   5594         static const uint32_t kMinMs = 30;
   5595         // TODO This could be a roundupRatio inline
   5596         const size_t minFramesByMs = (sampleRate * kMinMs + 1000 - 1) / 1000;
   5597         // TODO This could be a roundupRatio inline
   5598         const size_t minNotificationsByMs = (minFramesByMs + maxNotificationFrames - 1) /
   5599                 maxNotificationFrames;
   5600         const size_t minFrameCount = maxNotificationFrames *
   5601                 max(kMinNotifications, minNotificationsByMs);
   5602         frameCount = max(frameCount, minFrameCount);
   5603         if (*notificationFrames == 0 || *notificationFrames > maxNotificationFrames) {
   5604             *notificationFrames = maxNotificationFrames;
   5605         }
   5606     }
   5607     *pFrameCount = frameCount;
   5608 
   5609     lStatus = initCheck();
   5610     if (lStatus != NO_ERROR) {
   5611         ALOGE("createRecordTrack_l() audio driver not initialized");
   5612         goto Exit;
   5613     }
   5614 
   5615     { // scope for mLock
   5616         Mutex::Autolock _l(mLock);
   5617 
   5618         track = new RecordTrack(this, client, sampleRate,
   5619                       format, channelMask, frameCount, NULL, sessionId, uid,
   5620                       *flags, TrackBase::TYPE_DEFAULT);
   5621 
   5622         lStatus = track->initCheck();
   5623         if (lStatus != NO_ERROR) {
   5624             ALOGE("createRecordTrack_l() initCheck failed %d; no control block?", lStatus);
   5625             // track must be cleared from the caller as the caller has the AF lock
   5626             goto Exit;
   5627         }
   5628         mTracks.add(track);
   5629 
   5630         // disable AEC and NS if the device is a BT SCO headset supporting those pre processings
   5631         bool suspend = audio_is_bluetooth_sco_device(mInDevice) &&
   5632                         mAudioFlinger->btNrecIsOff();
   5633         setEffectSuspended_l(FX_IID_AEC, suspend, sessionId);
   5634         setEffectSuspended_l(FX_IID_NS, suspend, sessionId);
   5635 
   5636         if ((*flags & IAudioFlinger::TRACK_FAST) && (tid != -1)) {
   5637             pid_t callingPid = IPCThreadState::self()->getCallingPid();
   5638             // we don't have CAP_SYS_NICE, nor do we want to have it as it's too powerful,
   5639             // so ask activity manager to do this on our behalf
   5640             sendPrioConfigEvent_l(callingPid, tid, kPriorityAudioApp);
   5641         }
   5642     }
   5643 
   5644     lStatus = NO_ERROR;
   5645 
   5646 Exit:
   5647     *status = lStatus;
   5648     return track;
   5649 }
   5650 
   5651 status_t AudioFlinger::RecordThread::start(RecordThread::RecordTrack* recordTrack,
   5652                                            AudioSystem::sync_event_t event,
   5653                                            int triggerSession)
   5654 {
   5655     ALOGV("RecordThread::start event %d, triggerSession %d", event, triggerSession);
   5656     sp<ThreadBase> strongMe = this;
   5657     status_t status = NO_ERROR;
   5658 
   5659     if (event == AudioSystem::SYNC_EVENT_NONE) {
   5660         recordTrack->clearSyncStartEvent();
   5661     } else if (event != AudioSystem::SYNC_EVENT_SAME) {
   5662         recordTrack->mSyncStartEvent = mAudioFlinger->createSyncEvent(event,
   5663                                        triggerSession,
   5664                                        recordTrack->sessionId(),
   5665                                        syncStartEventCallback,
   5666                                        recordTrack);
   5667         // Sync event can be cancelled by the trigger session if the track is not in a
   5668         // compatible state in which case we start record immediately
   5669         if (recordTrack->mSyncStartEvent->isCancelled()) {
   5670             recordTrack->clearSyncStartEvent();
   5671         } else {
   5672             // do not wait for the event for more than AudioSystem::kSyncRecordStartTimeOutMs
   5673             recordTrack->mFramesToDrop = -
   5674                     ((AudioSystem::kSyncRecordStartTimeOutMs * recordTrack->mSampleRate) / 1000);
   5675         }
   5676     }
   5677 
   5678     {
   5679         // This section is a rendezvous between binder thread executing start() and RecordThread
   5680         AutoMutex lock(mLock);
   5681         if (mActiveTracks.indexOf(recordTrack) >= 0) {
   5682             if (recordTrack->mState == TrackBase::PAUSING) {
   5683                 ALOGV("active record track PAUSING -> ACTIVE");
   5684                 recordTrack->mState = TrackBase::ACTIVE;
   5685             } else {
   5686                 ALOGV("active record track state %d", recordTrack->mState);
   5687             }
   5688             return status;
   5689         }
   5690 
   5691         // TODO consider other ways of handling this, such as changing the state to :STARTING and
   5692         //      adding the track to mActiveTracks after returning from AudioSystem::startInput(),
   5693         //      or using a separate command thread
   5694         recordTrack->mState = TrackBase::STARTING_1;
   5695         mActiveTracks.add(recordTrack);
   5696         mActiveTracksGen++;
   5697         status_t status = NO_ERROR;
   5698         if (recordTrack->isExternalTrack()) {
   5699             mLock.unlock();
   5700             status = AudioSystem::startInput(mId, (audio_session_t)recordTrack->sessionId());
   5701             mLock.lock();
   5702             // FIXME should verify that recordTrack is still in mActiveTracks
   5703             if (status != NO_ERROR) {
   5704                 mActiveTracks.remove(recordTrack);
   5705                 mActiveTracksGen++;
   5706                 recordTrack->clearSyncStartEvent();
   5707                 ALOGV("RecordThread::start error %d", status);
   5708                 return status;
   5709             }
   5710         }
   5711         // Catch up with current buffer indices if thread is already running.
   5712         // This is what makes a new client discard all buffered data.  If the track's mRsmpInFront
   5713         // was initialized to some value closer to the thread's mRsmpInFront, then the track could
   5714         // see previously buffered data before it called start(), but with greater risk of overrun.
   5715 
   5716         recordTrack->mRsmpInFront = mRsmpInRear;
   5717         recordTrack->mRsmpInUnrel = 0;
   5718         // FIXME why reset?
   5719         if (recordTrack->mResampler != NULL) {
   5720             recordTrack->mResampler->reset();
   5721         }
   5722         recordTrack->mState = TrackBase::STARTING_2;
   5723         // signal thread to start
   5724         mWaitWorkCV.broadcast();
   5725         if (mActiveTracks.indexOf(recordTrack) < 0) {
   5726             ALOGV("Record failed to start");
   5727             status = BAD_VALUE;
   5728             goto startError;
   5729         }
   5730         return status;
   5731     }
   5732 
   5733 startError:
   5734     if (recordTrack->isExternalTrack()) {
   5735         AudioSystem::stopInput(mId, (audio_session_t)recordTrack->sessionId());
   5736     }
   5737     recordTrack->clearSyncStartEvent();
   5738     // FIXME I wonder why we do not reset the state here?
   5739     return status;
   5740 }
   5741 
   5742 void AudioFlinger::RecordThread::syncStartEventCallback(const wp<SyncEvent>& event)
   5743 {
   5744     sp<SyncEvent> strongEvent = event.promote();
   5745 
   5746     if (strongEvent != 0) {
   5747         sp<RefBase> ptr = strongEvent->cookie().promote();
   5748         if (ptr != 0) {
   5749             RecordTrack *recordTrack = (RecordTrack *)ptr.get();
   5750             recordTrack->handleSyncStartEvent(strongEvent);
   5751         }
   5752     }
   5753 }
   5754 
   5755 bool AudioFlinger::RecordThread::stop(RecordThread::RecordTrack* recordTrack) {
   5756     ALOGV("RecordThread::stop");
   5757     AutoMutex _l(mLock);
   5758     if (mActiveTracks.indexOf(recordTrack) != 0 || recordTrack->mState == TrackBase::PAUSING) {
   5759         return false;
   5760     }
   5761     // note that threadLoop may still be processing the track at this point [without lock]
   5762     recordTrack->mState = TrackBase::PAUSING;
   5763     // do not wait for mStartStopCond if exiting
   5764     if (exitPending()) {
   5765         return true;
   5766     }
   5767     // FIXME incorrect usage of wait: no explicit predicate or loop
   5768     mStartStopCond.wait(mLock);
   5769     // if we have been restarted, recordTrack is in mActiveTracks here
   5770     if (exitPending() || mActiveTracks.indexOf(recordTrack) != 0) {
   5771         ALOGV("Record stopped OK");
   5772         return true;
   5773     }
   5774     return false;
   5775 }
   5776 
   5777 bool AudioFlinger::RecordThread::isValidSyncEvent(const sp<SyncEvent>& event __unused) const
   5778 {
   5779     return false;
   5780 }
   5781 
   5782 status_t AudioFlinger::RecordThread::setSyncEvent(const sp<SyncEvent>& event __unused)
   5783 {
   5784 #if 0   // This branch is currently dead code, but is preserved in case it will be needed in future
   5785     if (!isValidSyncEvent(event)) {
   5786         return BAD_VALUE;
   5787     }
   5788 
   5789     int eventSession = event->triggerSession();
   5790     status_t ret = NAME_NOT_FOUND;
   5791 
   5792     Mutex::Autolock _l(mLock);
   5793 
   5794     for (size_t i = 0; i < mTracks.size(); i++) {
   5795         sp<RecordTrack> track = mTracks[i];
   5796         if (eventSession == track->sessionId()) {
   5797             (void) track->setSyncEvent(event);
   5798             ret = NO_ERROR;
   5799         }
   5800     }
   5801     return ret;
   5802 #else
   5803     return BAD_VALUE;
   5804 #endif
   5805 }
   5806 
   5807 // destroyTrack_l() must be called with ThreadBase::mLock held
   5808 void AudioFlinger::RecordThread::destroyTrack_l(const sp<RecordTrack>& track)
   5809 {
   5810     track->terminate();
   5811     track->mState = TrackBase::STOPPED;
   5812     // active tracks are removed by threadLoop()
   5813     if (mActiveTracks.indexOf(track) < 0) {
   5814         removeTrack_l(track);
   5815     }
   5816 }
   5817 
   5818 void AudioFlinger::RecordThread::removeTrack_l(const sp<RecordTrack>& track)
   5819 {
   5820     mTracks.remove(track);
   5821     // need anything related to effects here?
   5822     if (track->isFastTrack()) {
   5823         ALOG_ASSERT(!mFastTrackAvail);
   5824         mFastTrackAvail = true;
   5825     }
   5826 }
   5827 
   5828 void AudioFlinger::RecordThread::dump(int fd, const Vector<String16>& args)
   5829 {
   5830     dumpInternals(fd, args);
   5831     dumpTracks(fd, args);
   5832     dumpEffectChains(fd, args);
   5833 }
   5834 
   5835 void AudioFlinger::RecordThread::dumpInternals(int fd, const Vector<String16>& args)
   5836 {
   5837     dprintf(fd, "\nInput thread %p:\n", this);
   5838 
   5839     if (mActiveTracks.size() > 0) {
   5840         dprintf(fd, "  Buffer size: %zu bytes\n", mBufferSize);
   5841     } else {
   5842         dprintf(fd, "  No active record clients\n");
   5843     }
   5844     dprintf(fd, "  Fast capture thread: %s\n", hasFastCapture() ? "yes" : "no");
   5845     dprintf(fd, "  Fast track available: %s\n", mFastTrackAvail ? "yes" : "no");
   5846 
   5847     dumpBase(fd, args);
   5848 }
   5849 
   5850 void AudioFlinger::RecordThread::dumpTracks(int fd, const Vector<String16>& args __unused)
   5851 {
   5852     const size_t SIZE = 256;
   5853     char buffer[SIZE];
   5854     String8 result;
   5855 
   5856     size_t numtracks = mTracks.size();
   5857     size_t numactive = mActiveTracks.size();
   5858     size_t numactiveseen = 0;
   5859     dprintf(fd, "  %d Tracks", numtracks);
   5860     if (numtracks) {
   5861         dprintf(fd, " of which %d are active\n", numactive);
   5862         RecordTrack::appendDumpHeader(result);
   5863         for (size_t i = 0; i < numtracks ; ++i) {
   5864             sp<RecordTrack> track = mTracks[i];
   5865             if (track != 0) {
   5866                 bool active = mActiveTracks.indexOf(track) >= 0;
   5867                 if (active) {
   5868                     numactiveseen++;
   5869                 }
   5870                 track->dump(buffer, SIZE, active);
   5871                 result.append(buffer);
   5872             }
   5873         }
   5874     } else {
   5875         dprintf(fd, "\n");
   5876     }
   5877 
   5878     if (numactiveseen != numactive) {
   5879         snprintf(buffer, SIZE, "  The following tracks are in the active list but"
   5880                 " not in the track list\n");
   5881         result.append(buffer);
   5882         RecordTrack::appendDumpHeader(result);
   5883         for (size_t i = 0; i < numactive; ++i) {
   5884             sp<RecordTrack> track = mActiveTracks[i];
   5885             if (mTracks.indexOf(track) < 0) {
   5886                 track->dump(buffer, SIZE, true);
   5887                 result.append(buffer);
   5888             }
   5889         }
   5890 
   5891     }
   5892     write(fd, result.string(), result.size());
   5893 }
   5894 
   5895 // AudioBufferProvider interface
   5896 status_t AudioFlinger::RecordThread::ResamplerBufferProvider::getNextBuffer(
   5897         AudioBufferProvider::Buffer* buffer, int64_t pts __unused)
   5898 {
   5899     RecordTrack *activeTrack = mRecordTrack;
   5900     sp<ThreadBase> threadBase = activeTrack->mThread.promote();
   5901     if (threadBase == 0) {
   5902         buffer->frameCount = 0;
   5903         buffer->raw = NULL;
   5904         return NOT_ENOUGH_DATA;
   5905     }
   5906     RecordThread *recordThread = (RecordThread *) threadBase.get();
   5907     int32_t rear = recordThread->mRsmpInRear;
   5908     int32_t front = activeTrack->mRsmpInFront;
   5909     ssize_t filled = rear - front;
   5910     // FIXME should not be P2 (don't want to increase latency)
   5911     // FIXME if client not keeping up, discard
   5912     LOG_ALWAYS_FATAL_IF(!(0 <= filled && (size_t) filled <= recordThread->mRsmpInFrames));
   5913     // 'filled' may be non-contiguous, so return only the first contiguous chunk
   5914     front &= recordThread->mRsmpInFramesP2 - 1;
   5915     size_t part1 = recordThread->mRsmpInFramesP2 - front;
   5916     if (part1 > (size_t) filled) {
   5917         part1 = filled;
   5918     }
   5919     size_t ask = buffer->frameCount;
   5920     ALOG_ASSERT(ask > 0);
   5921     if (part1 > ask) {
   5922         part1 = ask;
   5923     }
   5924     if (part1 == 0) {
   5925         // Higher-level should keep mRsmpInBuffer full, and not call resampler if empty
   5926         LOG_ALWAYS_FATAL("RecordThread::getNextBuffer() starved");
   5927         buffer->raw = NULL;
   5928         buffer->frameCount = 0;
   5929         activeTrack->mRsmpInUnrel = 0;
   5930         return NOT_ENOUGH_DATA;
   5931     }
   5932 
   5933     buffer->raw = recordThread->mRsmpInBuffer + front * recordThread->mChannelCount;
   5934     buffer->frameCount = part1;
   5935     activeTrack->mRsmpInUnrel = part1;
   5936     return NO_ERROR;
   5937 }
   5938 
   5939 // AudioBufferProvider interface
   5940 void AudioFlinger::RecordThread::ResamplerBufferProvider::releaseBuffer(
   5941         AudioBufferProvider::Buffer* buffer)
   5942 {
   5943     RecordTrack *activeTrack = mRecordTrack;
   5944     size_t stepCount = buffer->frameCount;
   5945     if (stepCount == 0) {
   5946         return;
   5947     }
   5948     ALOG_ASSERT(stepCount <= activeTrack->mRsmpInUnrel);
   5949     activeTrack->mRsmpInUnrel -= stepCount;
   5950     activeTrack->mRsmpInFront += stepCount;
   5951     buffer->raw = NULL;
   5952     buffer->frameCount = 0;
   5953 }
   5954 
   5955 bool AudioFlinger::RecordThread::checkForNewParameter_l(const String8& keyValuePair,
   5956                                                         status_t& status)
   5957 {
   5958     bool reconfig = false;
   5959 
   5960     status = NO_ERROR;
   5961 
   5962     audio_format_t reqFormat = mFormat;
   5963     uint32_t samplingRate = mSampleRate;
   5964     audio_channel_mask_t channelMask = audio_channel_in_mask_from_count(mChannelCount);
   5965 
   5966     AudioParameter param = AudioParameter(keyValuePair);
   5967     int value;
   5968     // TODO Investigate when this code runs. Check with audio policy when a sample rate and
   5969     //      channel count change can be requested. Do we mandate the first client defines the
   5970     //      HAL sampling rate and channel count or do we allow changes on the fly?
   5971     if (param.getInt(String8(AudioParameter::keySamplingRate), value) == NO_ERROR) {
   5972         samplingRate = value;
   5973         reconfig = true;
   5974     }
   5975     if (param.getInt(String8(AudioParameter::keyFormat), value) == NO_ERROR) {
   5976         if ((audio_format_t) value != AUDIO_FORMAT_PCM_16_BIT) {
   5977             status = BAD_VALUE;
   5978         } else {
   5979             reqFormat = (audio_format_t) value;
   5980             reconfig = true;
   5981         }
   5982     }
   5983     if (param.getInt(String8(AudioParameter::keyChannels), value) == NO_ERROR) {
   5984         audio_channel_mask_t mask = (audio_channel_mask_t) value;
   5985         if (mask != AUDIO_CHANNEL_IN_MONO && mask != AUDIO_CHANNEL_IN_STEREO) {
   5986             status = BAD_VALUE;
   5987         } else {
   5988             channelMask = mask;
   5989             reconfig = true;
   5990         }
   5991     }
   5992     if (param.getInt(String8(AudioParameter::keyFrameCount), value) == NO_ERROR) {
   5993         // do not accept frame count changes if tracks are open as the track buffer
   5994         // size depends on frame count and correct behavior would not be guaranteed
   5995         // if frame count is changed after track creation
   5996         if (mActiveTracks.size() > 0) {
   5997             status = INVALID_OPERATION;
   5998         } else {
   5999             reconfig = true;
   6000         }
   6001     }
   6002     if (param.getInt(String8(AudioParameter::keyRouting), value) == NO_ERROR) {
   6003         // forward device change to effects that have requested to be
   6004         // aware of attached audio device.
   6005         for (size_t i = 0; i < mEffectChains.size(); i++) {
   6006             mEffectChains[i]->setDevice_l(value);
   6007         }
   6008 
   6009         // store input device and output device but do not forward output device to audio HAL.
   6010         // Note that status is ignored by the caller for output device
   6011         // (see AudioFlinger::setParameters()
   6012         if (audio_is_output_devices(value)) {
   6013             mOutDevice = value;
   6014             status = BAD_VALUE;
   6015         } else {
   6016             mInDevice = value;
   6017             // disable AEC and NS if the device is a BT SCO headset supporting those
   6018             // pre processings
   6019             if (mTracks.size() > 0) {
   6020                 bool suspend = audio_is_bluetooth_sco_device(mInDevice) &&
   6021                                     mAudioFlinger->btNrecIsOff();
   6022                 for (size_t i = 0; i < mTracks.size(); i++) {
   6023                     sp<RecordTrack> track = mTracks[i];
   6024                     setEffectSuspended_l(FX_IID_AEC, suspend, track->sessionId());
   6025                     setEffectSuspended_l(FX_IID_NS, suspend, track->sessionId());
   6026                 }
   6027             }
   6028         }
   6029     }
   6030     if (param.getInt(String8(AudioParameter::keyInputSource), value) == NO_ERROR &&
   6031             mAudioSource != (audio_source_t)value) {
   6032         // forward device change to effects that have requested to be
   6033         // aware of attached audio device.
   6034         for (size_t i = 0; i < mEffectChains.size(); i++) {
   6035             mEffectChains[i]->setAudioSource_l((audio_source_t)value);
   6036         }
   6037         mAudioSource = (audio_source_t)value;
   6038     }
   6039 
   6040     if (status == NO_ERROR) {
   6041         status = mInput->stream->common.set_parameters(&mInput->stream->common,
   6042                 keyValuePair.string());
   6043         if (status == INVALID_OPERATION) {
   6044             inputStandBy();
   6045             status = mInput->stream->common.set_parameters(&mInput->stream->common,
   6046                     keyValuePair.string());
   6047         }
   6048         if (reconfig) {
   6049             if (status == BAD_VALUE &&
   6050                 reqFormat == mInput->stream->common.get_format(&mInput->stream->common) &&
   6051                 reqFormat == AUDIO_FORMAT_PCM_16_BIT &&
   6052                 (mInput->stream->common.get_sample_rate(&mInput->stream->common)
   6053                         <= (2 * samplingRate)) &&
   6054                 audio_channel_count_from_in_mask(
   6055                         mInput->stream->common.get_channels(&mInput->stream->common)) <= FCC_2 &&
   6056                 (channelMask == AUDIO_CHANNEL_IN_MONO ||
   6057                         channelMask == AUDIO_CHANNEL_IN_STEREO)) {
   6058                 status = NO_ERROR;
   6059             }
   6060             if (status == NO_ERROR) {
   6061                 readInputParameters_l();
   6062                 sendIoConfigEvent_l(AudioSystem::INPUT_CONFIG_CHANGED);
   6063             }
   6064         }
   6065     }
   6066 
   6067     return reconfig;
   6068 }
   6069 
   6070 String8 AudioFlinger::RecordThread::getParameters(const String8& keys)
   6071 {
   6072     Mutex::Autolock _l(mLock);
   6073     if (initCheck() != NO_ERROR) {
   6074         return String8();
   6075     }
   6076 
   6077     char *s = mInput->stream->common.get_parameters(&mInput->stream->common, keys.string());
   6078     const String8 out_s8(s);
   6079     free(s);
   6080     return out_s8;
   6081 }
   6082 
   6083 void AudioFlinger::RecordThread::audioConfigChanged(int event, int param __unused) {
   6084     AudioSystem::OutputDescriptor desc;
   6085     const void *param2 = NULL;
   6086 
   6087     switch (event) {
   6088     case AudioSystem::INPUT_OPENED:
   6089     case AudioSystem::INPUT_CONFIG_CHANGED:
   6090         desc.channelMask = mChannelMask;
   6091         desc.samplingRate = mSampleRate;
   6092         desc.format = mFormat;
   6093         desc.frameCount = mFrameCount;
   6094         desc.latency = 0;
   6095         param2 = &desc;
   6096         break;
   6097 
   6098     case AudioSystem::INPUT_CLOSED:
   6099     default:
   6100         break;
   6101     }
   6102     mAudioFlinger->audioConfigChanged(event, mId, param2);
   6103 }
   6104 
   6105 void AudioFlinger::RecordThread::readInputParameters_l()
   6106 {
   6107     mSampleRate = mInput->stream->common.get_sample_rate(&mInput->stream->common);
   6108     mChannelMask = mInput->stream->common.get_channels(&mInput->stream->common);
   6109     mChannelCount = audio_channel_count_from_in_mask(mChannelMask);
   6110     mHALFormat = mInput->stream->common.get_format(&mInput->stream->common);
   6111     mFormat = mHALFormat;
   6112     if (mFormat != AUDIO_FORMAT_PCM_16_BIT) {
   6113         ALOGE("HAL format %#x not supported; must be AUDIO_FORMAT_PCM_16_BIT", mFormat);
   6114     }
   6115     mFrameSize = audio_stream_in_frame_size(mInput->stream);
   6116     mBufferSize = mInput->stream->common.get_buffer_size(&mInput->stream->common);
   6117     mFrameCount = mBufferSize / mFrameSize;
   6118     // This is the formula for calculating the temporary buffer size.
   6119     // With 7 HAL buffers, we can guarantee ability to down-sample the input by ratio of 6:1 to
   6120     // 1 full output buffer, regardless of the alignment of the available input.
   6121     // The value is somewhat arbitrary, and could probably be even larger.
   6122     // A larger value should allow more old data to be read after a track calls start(),
   6123     // without increasing latency.
   6124     mRsmpInFrames = mFrameCount * 7;
   6125     mRsmpInFramesP2 = roundup(mRsmpInFrames);
   6126     delete[] mRsmpInBuffer;
   6127 
   6128     // TODO optimize audio capture buffer sizes ...
   6129     // Here we calculate the size of the sliding buffer used as a source
   6130     // for resampling.  mRsmpInFramesP2 is currently roundup(mFrameCount * 7).
   6131     // For current HAL frame counts, this is usually 2048 = 40 ms.  It would
   6132     // be better to have it derived from the pipe depth in the long term.
   6133     // The current value is higher than necessary.  However it should not add to latency.
   6134 
   6135     // Over-allocate beyond mRsmpInFramesP2 to permit a HAL read past end of buffer
   6136     mRsmpInBuffer = new int16_t[(mRsmpInFramesP2 + mFrameCount - 1) * mChannelCount];
   6137 
   6138     // AudioRecord mSampleRate and mChannelCount are constant due to AudioRecord API constraints.
   6139     // But if thread's mSampleRate or mChannelCount changes, how will that affect active tracks?
   6140 }
   6141 
   6142 uint32_t AudioFlinger::RecordThread::getInputFramesLost()
   6143 {
   6144     Mutex::Autolock _l(mLock);
   6145     if (initCheck() != NO_ERROR) {
   6146         return 0;
   6147     }
   6148 
   6149     return mInput->stream->get_input_frames_lost(mInput->stream);
   6150 }
   6151 
   6152 uint32_t AudioFlinger::RecordThread::hasAudioSession(int sessionId) const
   6153 {
   6154     Mutex::Autolock _l(mLock);
   6155     uint32_t result = 0;
   6156     if (getEffectChain_l(sessionId) != 0) {
   6157         result = EFFECT_SESSION;
   6158     }
   6159 
   6160     for (size_t i = 0; i < mTracks.size(); ++i) {
   6161         if (sessionId == mTracks[i]->sessionId()) {
   6162             result |= TRACK_SESSION;
   6163             break;
   6164         }
   6165     }
   6166 
   6167     return result;
   6168 }
   6169 
   6170 KeyedVector<int, bool> AudioFlinger::RecordThread::sessionIds() const
   6171 {
   6172     KeyedVector<int, bool> ids;
   6173     Mutex::Autolock _l(mLock);
   6174     for (size_t j = 0; j < mTracks.size(); ++j) {
   6175         sp<RecordThread::RecordTrack> track = mTracks[j];
   6176         int sessionId = track->sessionId();
   6177         if (ids.indexOfKey(sessionId) < 0) {
   6178             ids.add(sessionId, true);
   6179         }
   6180     }
   6181     return ids;
   6182 }
   6183 
   6184 AudioFlinger::AudioStreamIn* AudioFlinger::RecordThread::clearInput()
   6185 {
   6186     Mutex::Autolock _l(mLock);
   6187     AudioStreamIn *input = mInput;
   6188     mInput = NULL;
   6189     return input;
   6190 }
   6191 
   6192 // this method must always be called either with ThreadBase mLock held or inside the thread loop
   6193 audio_stream_t* AudioFlinger::RecordThread::stream() const
   6194 {
   6195     if (mInput == NULL) {
   6196         return NULL;
   6197     }
   6198     return &mInput->stream->common;
   6199 }
   6200 
   6201 status_t AudioFlinger::RecordThread::addEffectChain_l(const sp<EffectChain>& chain)
   6202 {
   6203     // only one chain per input thread
   6204     if (mEffectChains.size() != 0) {
   6205         ALOGW("addEffectChain_l() already one chain %p on thread %p", chain.get(), this);
   6206         return INVALID_OPERATION;
   6207     }
   6208     ALOGV("addEffectChain_l() %p on thread %p", chain.get(), this);
   6209     chain->setThread(this);
   6210     chain->setInBuffer(NULL);
   6211     chain->setOutBuffer(NULL);
   6212 
   6213     checkSuspendOnAddEffectChain_l(chain);
   6214 
   6215     // make sure enabled pre processing effects state is communicated to the HAL as we
   6216     // just moved them to a new input stream.
   6217     chain->syncHalEffectsState();
   6218 
   6219     mEffectChains.add(chain);
   6220 
   6221     return NO_ERROR;
   6222 }
   6223 
   6224 size_t AudioFlinger::RecordThread::removeEffectChain_l(const sp<EffectChain>& chain)
   6225 {
   6226     ALOGV("removeEffectChain_l() %p from thread %p", chain.get(), this);
   6227     ALOGW_IF(mEffectChains.size() != 1,
   6228             "removeEffectChain_l() %p invalid chain size %d on thread %p",
   6229             chain.get(), mEffectChains.size(), this);
   6230     if (mEffectChains.size() == 1) {
   6231         mEffectChains.removeAt(0);
   6232     }
   6233     return 0;
   6234 }
   6235 
   6236 status_t AudioFlinger::RecordThread::createAudioPatch_l(const struct audio_patch *patch,
   6237                                                           audio_patch_handle_t *handle)
   6238 {
   6239     status_t status = NO_ERROR;
   6240     if (mInput->audioHwDev->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
   6241         // store new device and send to effects
   6242         mInDevice = patch->sources[0].ext.device.type;
   6243         for (size_t i = 0; i < mEffectChains.size(); i++) {
   6244             mEffectChains[i]->setDevice_l(mInDevice);
   6245         }
   6246 
   6247         // disable AEC and NS if the device is a BT SCO headset supporting those
   6248         // pre processings
   6249         if (mTracks.size() > 0) {
   6250             bool suspend = audio_is_bluetooth_sco_device(mInDevice) &&
   6251                                 mAudioFlinger->btNrecIsOff();
   6252             for (size_t i = 0; i < mTracks.size(); i++) {
   6253                 sp<RecordTrack> track = mTracks[i];
   6254                 setEffectSuspended_l(FX_IID_AEC, suspend, track->sessionId());
   6255                 setEffectSuspended_l(FX_IID_NS, suspend, track->sessionId());
   6256             }
   6257         }
   6258 
   6259         // store new source and send to effects
   6260         if (mAudioSource != patch->sinks[0].ext.mix.usecase.source) {
   6261             mAudioSource = patch->sinks[0].ext.mix.usecase.source;
   6262             for (size_t i = 0; i < mEffectChains.size(); i++) {
   6263                 mEffectChains[i]->setAudioSource_l(mAudioSource);
   6264             }
   6265         }
   6266 
   6267         audio_hw_device_t *hwDevice = mInput->audioHwDev->hwDevice();
   6268         status = hwDevice->create_audio_patch(hwDevice,
   6269                                                patch->num_sources,
   6270                                                patch->sources,
   6271                                                patch->num_sinks,
   6272                                                patch->sinks,
   6273                                                handle);
   6274     } else {
   6275         ALOG_ASSERT(false, "createAudioPatch_l() called on a pre 3.0 HAL");
   6276     }
   6277     return status;
   6278 }
   6279 
   6280 status_t AudioFlinger::RecordThread::releaseAudioPatch_l(const audio_patch_handle_t handle)
   6281 {
   6282     status_t status = NO_ERROR;
   6283     if (mInput->audioHwDev->version() >= AUDIO_DEVICE_API_VERSION_3_0) {
   6284         audio_hw_device_t *hwDevice = mInput->audioHwDev->hwDevice();
   6285         status = hwDevice->release_audio_patch(hwDevice, handle);
   6286     } else {
   6287         ALOG_ASSERT(false, "releaseAudioPatch_l() called on a pre 3.0 HAL");
   6288     }
   6289     return status;
   6290 }
   6291 
   6292 void AudioFlinger::RecordThread::addPatchRecord(const sp<PatchRecord>& record)
   6293 {
   6294     Mutex::Autolock _l(mLock);
   6295     mTracks.add(record);
   6296 }
   6297 
   6298 void AudioFlinger::RecordThread::deletePatchRecord(const sp<PatchRecord>& record)
   6299 {
   6300     Mutex::Autolock _l(mLock);
   6301     destroyTrack_l(record);
   6302 }
   6303 
   6304 void AudioFlinger::RecordThread::getAudioPortConfig(struct audio_port_config *config)
   6305 {
   6306     ThreadBase::getAudioPortConfig(config);
   6307     config->role = AUDIO_PORT_ROLE_SINK;
   6308     config->ext.mix.hw_module = mInput->audioHwDev->handle();
   6309     config->ext.mix.usecase.source = mAudioSource;
   6310 }
   6311 
   6312 }; // namespace android
   6313