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 #ifndef INCLUDING_FROM_AUDIOFLINGER_H
     19     #error This header file should only be included from AudioFlinger.h
     20 #endif
     21 
     22 class ThreadBase : public Thread {
     23 public:
     24 
     25 #include "TrackBase.h"
     26 
     27     enum type_t {
     28         MIXER,              // Thread class is MixerThread
     29         DIRECT,             // Thread class is DirectOutputThread
     30         DUPLICATING,        // Thread class is DuplicatingThread
     31         RECORD,             // Thread class is RecordThread
     32         OFFLOAD             // Thread class is OffloadThread
     33     };
     34 
     35     static const char *threadTypeToString(type_t type);
     36 
     37     ThreadBase(const sp<AudioFlinger>& audioFlinger, audio_io_handle_t id,
     38                 audio_devices_t outDevice, audio_devices_t inDevice, type_t type,
     39                 bool systemReady);
     40     virtual             ~ThreadBase();
     41 
     42     virtual status_t    readyToRun();
     43 
     44     void dumpBase(int fd, const Vector<String16>& args);
     45     void dumpEffectChains(int fd, const Vector<String16>& args);
     46 
     47     void clearPowerManager();
     48 
     49     // base for record and playback
     50     enum {
     51         CFG_EVENT_IO,
     52         CFG_EVENT_PRIO,
     53         CFG_EVENT_SET_PARAMETER,
     54         CFG_EVENT_CREATE_AUDIO_PATCH,
     55         CFG_EVENT_RELEASE_AUDIO_PATCH,
     56     };
     57 
     58     class ConfigEventData: public RefBase {
     59     public:
     60         virtual ~ConfigEventData() {}
     61 
     62         virtual  void dump(char *buffer, size_t size) = 0;
     63     protected:
     64         ConfigEventData() {}
     65     };
     66 
     67     // Config event sequence by client if status needed (e.g binder thread calling setParameters()):
     68     //  1. create SetParameterConfigEvent. This sets mWaitStatus in config event
     69     //  2. Lock mLock
     70     //  3. Call sendConfigEvent_l(): Append to mConfigEvents and mWaitWorkCV.signal
     71     //  4. sendConfigEvent_l() reads status from event->mStatus;
     72     //  5. sendConfigEvent_l() returns status
     73     //  6. Unlock
     74     //
     75     // Parameter sequence by server: threadLoop calling processConfigEvents_l():
     76     // 1. Lock mLock
     77     // 2. If there is an entry in mConfigEvents proceed ...
     78     // 3. Read first entry in mConfigEvents
     79     // 4. Remove first entry from mConfigEvents
     80     // 5. Process
     81     // 6. Set event->mStatus
     82     // 7. event->mCond.signal
     83     // 8. Unlock
     84 
     85     class ConfigEvent: public RefBase {
     86     public:
     87         virtual ~ConfigEvent() {}
     88 
     89         void dump(char *buffer, size_t size) { mData->dump(buffer, size); }
     90 
     91         const int mType; // event type e.g. CFG_EVENT_IO
     92         Mutex mLock;     // mutex associated with mCond
     93         Condition mCond; // condition for status return
     94         status_t mStatus; // status communicated to sender
     95         bool mWaitStatus; // true if sender is waiting for status
     96         bool mRequiresSystemReady; // true if must wait for system ready to enter event queue
     97         sp<ConfigEventData> mData;     // event specific parameter data
     98 
     99     protected:
    100         ConfigEvent(int type, bool requiresSystemReady = false) :
    101             mType(type), mStatus(NO_ERROR), mWaitStatus(false),
    102             mRequiresSystemReady(requiresSystemReady), mData(NULL) {}
    103     };
    104 
    105     class IoConfigEventData : public ConfigEventData {
    106     public:
    107         IoConfigEventData(audio_io_config_event event, pid_t pid) :
    108             mEvent(event), mPid(pid) {}
    109 
    110         virtual  void dump(char *buffer, size_t size) {
    111             snprintf(buffer, size, "IO event: event %d\n", mEvent);
    112         }
    113 
    114         const audio_io_config_event mEvent;
    115         const pid_t                 mPid;
    116     };
    117 
    118     class IoConfigEvent : public ConfigEvent {
    119     public:
    120         IoConfigEvent(audio_io_config_event event, pid_t pid) :
    121             ConfigEvent(CFG_EVENT_IO) {
    122             mData = new IoConfigEventData(event, pid);
    123         }
    124         virtual ~IoConfigEvent() {}
    125     };
    126 
    127     class PrioConfigEventData : public ConfigEventData {
    128     public:
    129         PrioConfigEventData(pid_t pid, pid_t tid, int32_t prio) :
    130             mPid(pid), mTid(tid), mPrio(prio) {}
    131 
    132         virtual  void dump(char *buffer, size_t size) {
    133             snprintf(buffer, size, "Prio event: pid %d, tid %d, prio %d\n", mPid, mTid, mPrio);
    134         }
    135 
    136         const pid_t mPid;
    137         const pid_t mTid;
    138         const int32_t mPrio;
    139     };
    140 
    141     class PrioConfigEvent : public ConfigEvent {
    142     public:
    143         PrioConfigEvent(pid_t pid, pid_t tid, int32_t prio) :
    144             ConfigEvent(CFG_EVENT_PRIO, true) {
    145             mData = new PrioConfigEventData(pid, tid, prio);
    146         }
    147         virtual ~PrioConfigEvent() {}
    148     };
    149 
    150     class SetParameterConfigEventData : public ConfigEventData {
    151     public:
    152         SetParameterConfigEventData(String8 keyValuePairs) :
    153             mKeyValuePairs(keyValuePairs) {}
    154 
    155         virtual  void dump(char *buffer, size_t size) {
    156             snprintf(buffer, size, "KeyValue: %s\n", mKeyValuePairs.string());
    157         }
    158 
    159         const String8 mKeyValuePairs;
    160     };
    161 
    162     class SetParameterConfigEvent : public ConfigEvent {
    163     public:
    164         SetParameterConfigEvent(String8 keyValuePairs) :
    165             ConfigEvent(CFG_EVENT_SET_PARAMETER) {
    166             mData = new SetParameterConfigEventData(keyValuePairs);
    167             mWaitStatus = true;
    168         }
    169         virtual ~SetParameterConfigEvent() {}
    170     };
    171 
    172     class CreateAudioPatchConfigEventData : public ConfigEventData {
    173     public:
    174         CreateAudioPatchConfigEventData(const struct audio_patch patch,
    175                                         audio_patch_handle_t handle) :
    176             mPatch(patch), mHandle(handle) {}
    177 
    178         virtual  void dump(char *buffer, size_t size) {
    179             snprintf(buffer, size, "Patch handle: %u\n", mHandle);
    180         }
    181 
    182         const struct audio_patch mPatch;
    183         audio_patch_handle_t mHandle;
    184     };
    185 
    186     class CreateAudioPatchConfigEvent : public ConfigEvent {
    187     public:
    188         CreateAudioPatchConfigEvent(const struct audio_patch patch,
    189                                     audio_patch_handle_t handle) :
    190             ConfigEvent(CFG_EVENT_CREATE_AUDIO_PATCH) {
    191             mData = new CreateAudioPatchConfigEventData(patch, handle);
    192             mWaitStatus = true;
    193         }
    194         virtual ~CreateAudioPatchConfigEvent() {}
    195     };
    196 
    197     class ReleaseAudioPatchConfigEventData : public ConfigEventData {
    198     public:
    199         ReleaseAudioPatchConfigEventData(const audio_patch_handle_t handle) :
    200             mHandle(handle) {}
    201 
    202         virtual  void dump(char *buffer, size_t size) {
    203             snprintf(buffer, size, "Patch handle: %u\n", mHandle);
    204         }
    205 
    206         audio_patch_handle_t mHandle;
    207     };
    208 
    209     class ReleaseAudioPatchConfigEvent : public ConfigEvent {
    210     public:
    211         ReleaseAudioPatchConfigEvent(const audio_patch_handle_t handle) :
    212             ConfigEvent(CFG_EVENT_RELEASE_AUDIO_PATCH) {
    213             mData = new ReleaseAudioPatchConfigEventData(handle);
    214             mWaitStatus = true;
    215         }
    216         virtual ~ReleaseAudioPatchConfigEvent() {}
    217     };
    218 
    219     class PMDeathRecipient : public IBinder::DeathRecipient {
    220     public:
    221                     PMDeathRecipient(const wp<ThreadBase>& thread) : mThread(thread) {}
    222         virtual     ~PMDeathRecipient() {}
    223 
    224         // IBinder::DeathRecipient
    225         virtual     void        binderDied(const wp<IBinder>& who);
    226 
    227     private:
    228                     PMDeathRecipient(const PMDeathRecipient&);
    229                     PMDeathRecipient& operator = (const PMDeathRecipient&);
    230 
    231         wp<ThreadBase> mThread;
    232     };
    233 
    234     virtual     status_t    initCheck() const = 0;
    235 
    236                 // static externally-visible
    237                 type_t      type() const { return mType; }
    238                 bool isDuplicating() const { return (mType == DUPLICATING); }
    239 
    240                 audio_io_handle_t id() const { return mId;}
    241 
    242                 // dynamic externally-visible
    243                 uint32_t    sampleRate() const { return mSampleRate; }
    244                 audio_channel_mask_t channelMask() const { return mChannelMask; }
    245                 audio_format_t format() const { return mHALFormat; }
    246                 uint32_t channelCount() const { return mChannelCount; }
    247                 // Called by AudioFlinger::frameCount(audio_io_handle_t output) and effects,
    248                 // and returns the [normal mix] buffer's frame count.
    249     virtual     size_t      frameCount() const = 0;
    250 
    251                 // Return's the HAL's frame count i.e. fast mixer buffer size.
    252                 size_t      frameCountHAL() const { return mFrameCount; }
    253 
    254                 size_t      frameSize() const { return mFrameSize; }
    255 
    256     // Should be "virtual status_t requestExitAndWait()" and override same
    257     // method in Thread, but Thread::requestExitAndWait() is not yet virtual.
    258                 void        exit();
    259     virtual     bool        checkForNewParameter_l(const String8& keyValuePair,
    260                                                     status_t& status) = 0;
    261     virtual     status_t    setParameters(const String8& keyValuePairs);
    262     virtual     String8     getParameters(const String8& keys) = 0;
    263     virtual     void        ioConfigChanged(audio_io_config_event event, pid_t pid = 0) = 0;
    264                 // sendConfigEvent_l() must be called with ThreadBase::mLock held
    265                 // Can temporarily release the lock if waiting for a reply from
    266                 // processConfigEvents_l().
    267                 status_t    sendConfigEvent_l(sp<ConfigEvent>& event);
    268                 void        sendIoConfigEvent(audio_io_config_event event, pid_t pid = 0);
    269                 void        sendIoConfigEvent_l(audio_io_config_event event, pid_t pid = 0);
    270                 void        sendPrioConfigEvent(pid_t pid, pid_t tid, int32_t prio);
    271                 void        sendPrioConfigEvent_l(pid_t pid, pid_t tid, int32_t prio);
    272                 status_t    sendSetParameterConfigEvent_l(const String8& keyValuePair);
    273                 status_t    sendCreateAudioPatchConfigEvent(const struct audio_patch *patch,
    274                                                             audio_patch_handle_t *handle);
    275                 status_t    sendReleaseAudioPatchConfigEvent(audio_patch_handle_t handle);
    276                 void        processConfigEvents_l();
    277     virtual     void        cacheParameters_l() = 0;
    278     virtual     status_t    createAudioPatch_l(const struct audio_patch *patch,
    279                                                audio_patch_handle_t *handle) = 0;
    280     virtual     status_t    releaseAudioPatch_l(const audio_patch_handle_t handle) = 0;
    281     virtual     void        getAudioPortConfig(struct audio_port_config *config) = 0;
    282 
    283 
    284                 // see note at declaration of mStandby, mOutDevice and mInDevice
    285                 bool        standby() const { return mStandby; }
    286                 audio_devices_t outDevice() const { return mOutDevice; }
    287                 audio_devices_t inDevice() const { return mInDevice; }
    288 
    289     virtual     audio_stream_t* stream() const = 0;
    290 
    291                 sp<EffectHandle> createEffect_l(
    292                                     const sp<AudioFlinger::Client>& client,
    293                                     const sp<IEffectClient>& effectClient,
    294                                     int32_t priority,
    295                                     audio_session_t sessionId,
    296                                     effect_descriptor_t *desc,
    297                                     int *enabled,
    298                                     status_t *status /*non-NULL*/);
    299 
    300                 // return values for hasAudioSession (bit field)
    301                 enum effect_state {
    302                     EFFECT_SESSION = 0x1,   // the audio session corresponds to at least one
    303                                             // effect
    304                     TRACK_SESSION = 0x2,    // the audio session corresponds to at least one
    305                                             // track
    306                     FAST_SESSION = 0x4      // the audio session corresponds to at least one
    307                                             // fast track
    308                 };
    309 
    310                 // get effect chain corresponding to session Id.
    311                 sp<EffectChain> getEffectChain(audio_session_t sessionId);
    312                 // same as getEffectChain() but must be called with ThreadBase mutex locked
    313                 sp<EffectChain> getEffectChain_l(audio_session_t sessionId) const;
    314                 // add an effect chain to the chain list (mEffectChains)
    315     virtual     status_t addEffectChain_l(const sp<EffectChain>& chain) = 0;
    316                 // remove an effect chain from the chain list (mEffectChains)
    317     virtual     size_t removeEffectChain_l(const sp<EffectChain>& chain) = 0;
    318                 // lock all effect chains Mutexes. Must be called before releasing the
    319                 // ThreadBase mutex before processing the mixer and effects. This guarantees the
    320                 // integrity of the chains during the process.
    321                 // Also sets the parameter 'effectChains' to current value of mEffectChains.
    322                 void lockEffectChains_l(Vector< sp<EffectChain> >& effectChains);
    323                 // unlock effect chains after process
    324                 void unlockEffectChains(const Vector< sp<EffectChain> >& effectChains);
    325                 // get a copy of mEffectChains vector
    326                 Vector< sp<EffectChain> > getEffectChains_l() const { return mEffectChains; };
    327                 // set audio mode to all effect chains
    328                 void setMode(audio_mode_t mode);
    329                 // get effect module with corresponding ID on specified audio session
    330                 sp<AudioFlinger::EffectModule> getEffect(audio_session_t sessionId, int effectId);
    331                 sp<AudioFlinger::EffectModule> getEffect_l(audio_session_t sessionId, int effectId);
    332                 // add and effect module. Also creates the effect chain is none exists for
    333                 // the effects audio session
    334                 status_t addEffect_l(const sp< EffectModule>& effect);
    335                 // remove and effect module. Also removes the effect chain is this was the last
    336                 // effect
    337                 void removeEffect_l(const sp< EffectModule>& effect);
    338                 // detach all tracks connected to an auxiliary effect
    339     virtual     void detachAuxEffect_l(int effectId __unused) {}
    340                 // returns a combination of:
    341                 // - EFFECT_SESSION if effects on this audio session exist in one chain
    342                 // - TRACK_SESSION if tracks on this audio session exist
    343                 // - FAST_SESSION if fast tracks on this audio session exist
    344     virtual     uint32_t hasAudioSession_l(audio_session_t sessionId) const = 0;
    345                 uint32_t hasAudioSession(audio_session_t sessionId) const {
    346                     Mutex::Autolock _l(mLock);
    347                     return hasAudioSession_l(sessionId);
    348                 }
    349 
    350                 // the value returned by default implementation is not important as the
    351                 // strategy is only meaningful for PlaybackThread which implements this method
    352                 virtual uint32_t getStrategyForSession_l(audio_session_t sessionId __unused)
    353                         { return 0; }
    354 
    355                 // suspend or restore effect according to the type of effect passed. a NULL
    356                 // type pointer means suspend all effects in the session
    357                 void setEffectSuspended(const effect_uuid_t *type,
    358                                         bool suspend,
    359                                         audio_session_t sessionId = AUDIO_SESSION_OUTPUT_MIX);
    360                 // check if some effects must be suspended/restored when an effect is enabled
    361                 // or disabled
    362                 void checkSuspendOnEffectEnabled(const sp<EffectModule>& effect,
    363                                                  bool enabled,
    364                                                  audio_session_t sessionId =
    365                                                         AUDIO_SESSION_OUTPUT_MIX);
    366                 void checkSuspendOnEffectEnabled_l(const sp<EffectModule>& effect,
    367                                                    bool enabled,
    368                                                    audio_session_t sessionId =
    369                                                         AUDIO_SESSION_OUTPUT_MIX);
    370 
    371                 virtual status_t    setSyncEvent(const sp<SyncEvent>& event) = 0;
    372                 virtual bool        isValidSyncEvent(const sp<SyncEvent>& event) const = 0;
    373 
    374                 // Return a reference to a per-thread heap which can be used to allocate IMemory
    375                 // objects that will be read-only to client processes, read/write to mediaserver,
    376                 // and shared by all client processes of the thread.
    377                 // The heap is per-thread rather than common across all threads, because
    378                 // clients can't be trusted not to modify the offset of the IMemory they receive.
    379                 // If a thread does not have such a heap, this method returns 0.
    380                 virtual sp<MemoryDealer>    readOnlyHeap() const { return 0; }
    381 
    382                 virtual sp<IMemory> pipeMemory() const { return 0; }
    383 
    384                         void systemReady();
    385 
    386                 // checkEffectCompatibility_l() must be called with ThreadBase::mLock held
    387                 virtual status_t    checkEffectCompatibility_l(const effect_descriptor_t *desc,
    388                                                                audio_session_t sessionId) = 0;
    389 
    390     mutable     Mutex                   mLock;
    391 
    392 protected:
    393 
    394                 // entry describing an effect being suspended in mSuspendedSessions keyed vector
    395                 class SuspendedSessionDesc : public RefBase {
    396                 public:
    397                     SuspendedSessionDesc() : mRefCount(0) {}
    398 
    399                     int mRefCount;          // number of active suspend requests
    400                     effect_uuid_t mType;    // effect type UUID
    401                 };
    402 
    403                 void        acquireWakeLock(int uid = -1);
    404                 virtual void acquireWakeLock_l(int uid = -1);
    405                 void        releaseWakeLock();
    406                 void        releaseWakeLock_l();
    407                 void        updateWakeLockUids(const SortedVector<int> &uids);
    408                 void        updateWakeLockUids_l(const SortedVector<int> &uids);
    409                 void        getPowerManager_l();
    410                 void setEffectSuspended_l(const effect_uuid_t *type,
    411                                           bool suspend,
    412                                           audio_session_t sessionId);
    413                 // updated mSuspendedSessions when an effect suspended or restored
    414                 void        updateSuspendedSessions_l(const effect_uuid_t *type,
    415                                                       bool suspend,
    416                                                       audio_session_t sessionId);
    417                 // check if some effects must be suspended when an effect chain is added
    418                 void checkSuspendOnAddEffectChain_l(const sp<EffectChain>& chain);
    419 
    420                 String16 getWakeLockTag();
    421 
    422     virtual     void        preExit() { }
    423     virtual     void        setMasterMono_l(bool mono __unused) { }
    424     virtual     bool        requireMonoBlend() { return false; }
    425 
    426     friend class AudioFlinger;      // for mEffectChains
    427 
    428                 const type_t            mType;
    429 
    430                 // Used by parameters, config events, addTrack_l, exit
    431                 Condition               mWaitWorkCV;
    432 
    433                 const sp<AudioFlinger>  mAudioFlinger;
    434 
    435                 // updated by PlaybackThread::readOutputParameters_l() or
    436                 // RecordThread::readInputParameters_l()
    437                 uint32_t                mSampleRate;
    438                 size_t                  mFrameCount;       // output HAL, direct output, record
    439                 audio_channel_mask_t    mChannelMask;
    440                 uint32_t                mChannelCount;
    441                 size_t                  mFrameSize;
    442                 // not HAL frame size, this is for output sink (to pipe to fast mixer)
    443                 audio_format_t          mFormat;           // Source format for Recording and
    444                                                            // Sink format for Playback.
    445                                                            // Sink format may be different than
    446                                                            // HAL format if Fastmixer is used.
    447                 audio_format_t          mHALFormat;
    448                 size_t                  mBufferSize;       // HAL buffer size for read() or write()
    449 
    450                 Vector< sp<ConfigEvent> >     mConfigEvents;
    451                 Vector< sp<ConfigEvent> >     mPendingConfigEvents; // events awaiting system ready
    452 
    453                 // These fields are written and read by thread itself without lock or barrier,
    454                 // and read by other threads without lock or barrier via standby(), outDevice()
    455                 // and inDevice().
    456                 // Because of the absence of a lock or barrier, any other thread that reads
    457                 // these fields must use the information in isolation, or be prepared to deal
    458                 // with possibility that it might be inconsistent with other information.
    459                 bool                    mStandby;     // Whether thread is currently in standby.
    460                 audio_devices_t         mOutDevice;   // output device
    461                 audio_devices_t         mInDevice;    // input device
    462                 audio_devices_t         mPrevOutDevice;   // previous output device
    463                 audio_devices_t         mPrevInDevice;    // previous input device
    464                 struct audio_patch      mPatch;
    465                 audio_source_t          mAudioSource;
    466 
    467                 const audio_io_handle_t mId;
    468                 Vector< sp<EffectChain> > mEffectChains;
    469 
    470                 static const int        kThreadNameLength = 16; // prctl(PR_SET_NAME) limit
    471                 char                    mThreadName[kThreadNameLength]; // guaranteed NUL-terminated
    472                 sp<IPowerManager>       mPowerManager;
    473                 sp<IBinder>             mWakeLockToken;
    474                 const sp<PMDeathRecipient> mDeathRecipient;
    475                 // list of suspended effects per session and per type. The first (outer) vector is
    476                 // keyed by session ID, the second (inner) by type UUID timeLow field
    477                 KeyedVector< audio_session_t, KeyedVector< int, sp<SuspendedSessionDesc> > >
    478                                         mSuspendedSessions;
    479                 static const size_t     kLogSize = 4 * 1024;
    480                 sp<NBLog::Writer>       mNBLogWriter;
    481                 bool                    mSystemReady;
    482                 bool                    mNotifiedBatteryStart;
    483                 ExtendedTimestamp       mTimestamp;
    484 };
    485 
    486 // --- PlaybackThread ---
    487 class PlaybackThread : public ThreadBase {
    488 public:
    489 
    490 #include "PlaybackTracks.h"
    491 
    492     enum mixer_state {
    493         MIXER_IDLE,             // no active tracks
    494         MIXER_TRACKS_ENABLED,   // at least one active track, but no track has any data ready
    495         MIXER_TRACKS_READY,      // at least one active track, and at least one track has data
    496         MIXER_DRAIN_TRACK,      // drain currently playing track
    497         MIXER_DRAIN_ALL,        // fully drain the hardware
    498         // standby mode does not have an enum value
    499         // suspend by audio policy manager is orthogonal to mixer state
    500     };
    501 
    502     // retry count before removing active track in case of underrun on offloaded thread:
    503     // we need to make sure that AudioTrack client has enough time to send large buffers
    504     //FIXME may be more appropriate if expressed in time units. Need to revise how underrun is
    505     // handled for offloaded tracks
    506     static const int8_t kMaxTrackRetriesOffload = 20;
    507     static const int8_t kMaxTrackStartupRetriesOffload = 100;
    508     static const int8_t kMaxTrackStopRetriesOffload = 2;
    509 
    510     PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
    511                    audio_io_handle_t id, audio_devices_t device, type_t type, bool systemReady);
    512     virtual             ~PlaybackThread();
    513 
    514                 void        dump(int fd, const Vector<String16>& args);
    515 
    516     // Thread virtuals
    517     virtual     bool        threadLoop();
    518 
    519     // RefBase
    520     virtual     void        onFirstRef();
    521 
    522     virtual     status_t    checkEffectCompatibility_l(const effect_descriptor_t *desc,
    523                                                        audio_session_t sessionId);
    524 
    525 protected:
    526     // Code snippets that were lifted up out of threadLoop()
    527     virtual     void        threadLoop_mix() = 0;
    528     virtual     void        threadLoop_sleepTime() = 0;
    529     virtual     ssize_t     threadLoop_write();
    530     virtual     void        threadLoop_drain();
    531     virtual     void        threadLoop_standby();
    532     virtual     void        threadLoop_exit();
    533     virtual     void        threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
    534 
    535                 // prepareTracks_l reads and writes mActiveTracks, and returns
    536                 // the pending set of tracks to remove via Vector 'tracksToRemove'.  The caller
    537                 // is responsible for clearing or destroying this Vector later on, when it
    538                 // is safe to do so. That will drop the final ref count and destroy the tracks.
    539     virtual     mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove) = 0;
    540                 void        removeTracks_l(const Vector< sp<Track> >& tracksToRemove);
    541 
    542                 void        writeCallback();
    543                 void        resetWriteBlocked(uint32_t sequence);
    544                 void        drainCallback();
    545                 void        resetDraining(uint32_t sequence);
    546                 void        errorCallback();
    547 
    548     static      int         asyncCallback(stream_callback_event_t event, void *param, void *cookie);
    549 
    550     virtual     bool        waitingAsyncCallback();
    551     virtual     bool        waitingAsyncCallback_l();
    552     virtual     bool        shouldStandby_l();
    553     virtual     void        onAddNewTrack_l();
    554                 void        onAsyncError(); // error reported by AsyncCallbackThread
    555 
    556     // ThreadBase virtuals
    557     virtual     void        preExit();
    558 
    559     virtual     bool        keepWakeLock() const { return true; }
    560 
    561 public:
    562 
    563     virtual     status_t    initCheck() const { return (mOutput == NULL) ? NO_INIT : NO_ERROR; }
    564 
    565                 // return estimated latency in milliseconds, as reported by HAL
    566                 uint32_t    latency() const;
    567                 // same, but lock must already be held
    568                 uint32_t    latency_l() const;
    569 
    570                 void        setMasterVolume(float value);
    571                 void        setMasterMute(bool muted);
    572 
    573                 void        setStreamVolume(audio_stream_type_t stream, float value);
    574                 void        setStreamMute(audio_stream_type_t stream, bool muted);
    575 
    576                 float       streamVolume(audio_stream_type_t stream) const;
    577 
    578                 sp<Track>   createTrack_l(
    579                                 const sp<AudioFlinger::Client>& client,
    580                                 audio_stream_type_t streamType,
    581                                 uint32_t sampleRate,
    582                                 audio_format_t format,
    583                                 audio_channel_mask_t channelMask,
    584                                 size_t *pFrameCount,
    585                                 const sp<IMemory>& sharedBuffer,
    586                                 audio_session_t sessionId,
    587                                 audio_output_flags_t *flags,
    588                                 pid_t tid,
    589                                 int uid,
    590                                 status_t *status /*non-NULL*/);
    591 
    592                 AudioStreamOut* getOutput() const;
    593                 AudioStreamOut* clearOutput();
    594                 virtual audio_stream_t* stream() const;
    595 
    596                 // a very large number of suspend() will eventually wraparound, but unlikely
    597                 void        suspend() { (void) android_atomic_inc(&mSuspended); }
    598                 void        restore()
    599                                 {
    600                                     // if restore() is done without suspend(), get back into
    601                                     // range so that the next suspend() will operate correctly
    602                                     if (android_atomic_dec(&mSuspended) <= 0) {
    603                                         android_atomic_release_store(0, &mSuspended);
    604                                     }
    605                                 }
    606                 bool        isSuspended() const
    607                                 { return android_atomic_acquire_load(&mSuspended) > 0; }
    608 
    609     virtual     String8     getParameters(const String8& keys);
    610     virtual     void        ioConfigChanged(audio_io_config_event event, pid_t pid = 0);
    611                 status_t    getRenderPosition(uint32_t *halFrames, uint32_t *dspFrames);
    612                 // FIXME rename mixBuffer() to sinkBuffer() and remove int16_t* dependency.
    613                 // Consider also removing and passing an explicit mMainBuffer initialization
    614                 // parameter to AF::PlaybackThread::Track::Track().
    615                 int16_t     *mixBuffer() const {
    616                     return reinterpret_cast<int16_t *>(mSinkBuffer); };
    617 
    618     virtual     void detachAuxEffect_l(int effectId);
    619                 status_t attachAuxEffect(const sp<AudioFlinger::PlaybackThread::Track> track,
    620                         int EffectId);
    621                 status_t attachAuxEffect_l(const sp<AudioFlinger::PlaybackThread::Track> track,
    622                         int EffectId);
    623 
    624                 virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
    625                 virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
    626                 virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const;
    627                 virtual uint32_t getStrategyForSession_l(audio_session_t sessionId);
    628 
    629 
    630                 virtual status_t setSyncEvent(const sp<SyncEvent>& event);
    631                 virtual bool     isValidSyncEvent(const sp<SyncEvent>& event) const;
    632 
    633                 // called with AudioFlinger lock held
    634                         bool     invalidateTracks_l(audio_stream_type_t streamType);
    635                 virtual void     invalidateTracks(audio_stream_type_t streamType);
    636 
    637     virtual     size_t      frameCount() const { return mNormalFrameCount; }
    638 
    639                 status_t    getTimestamp_l(AudioTimestamp& timestamp);
    640 
    641                 void        addPatchTrack(const sp<PatchTrack>& track);
    642                 void        deletePatchTrack(const sp<PatchTrack>& track);
    643 
    644     virtual     void        getAudioPortConfig(struct audio_port_config *config);
    645 
    646 protected:
    647     // updated by readOutputParameters_l()
    648     size_t                          mNormalFrameCount;  // normal mixer and effects
    649 
    650     bool                            mThreadThrottle;     // throttle the thread processing
    651     uint32_t                        mThreadThrottleTimeMs; // throttle time for MIXER threads
    652     uint32_t                        mThreadThrottleEndMs;  // notify once per throttling
    653     uint32_t                        mHalfBufferMs;       // half the buffer size in milliseconds
    654 
    655     void*                           mSinkBuffer;         // frame size aligned sink buffer
    656 
    657     // TODO:
    658     // Rearrange the buffer info into a struct/class with
    659     // clear, copy, construction, destruction methods.
    660     //
    661     // mSinkBuffer also has associated with it:
    662     //
    663     // mSinkBufferSize: Sink Buffer Size
    664     // mFormat: Sink Buffer Format
    665 
    666     // Mixer Buffer (mMixerBuffer*)
    667     //
    668     // In the case of floating point or multichannel data, which is not in the
    669     // sink format, it is required to accumulate in a higher precision or greater channel count
    670     // buffer before downmixing or data conversion to the sink buffer.
    671 
    672     // Set to "true" to enable the Mixer Buffer otherwise mixer output goes to sink buffer.
    673     bool                            mMixerBufferEnabled;
    674 
    675     // Storage, 32 byte aligned (may make this alignment a requirement later).
    676     // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
    677     void*                           mMixerBuffer;
    678 
    679     // Size of mMixerBuffer in bytes: mNormalFrameCount * #channels * sampsize.
    680     size_t                          mMixerBufferSize;
    681 
    682     // The audio format of mMixerBuffer. Set to AUDIO_FORMAT_PCM_(FLOAT|16_BIT) only.
    683     audio_format_t                  mMixerBufferFormat;
    684 
    685     // An internal flag set to true by MixerThread::prepareTracks_l()
    686     // when mMixerBuffer contains valid data after mixing.
    687     bool                            mMixerBufferValid;
    688 
    689     // Effects Buffer (mEffectsBuffer*)
    690     //
    691     // In the case of effects data, which is not in the sink format,
    692     // it is required to accumulate in a different buffer before data conversion
    693     // to the sink buffer.
    694 
    695     // Set to "true" to enable the Effects Buffer otherwise effects output goes to sink buffer.
    696     bool                            mEffectBufferEnabled;
    697 
    698     // Storage, 32 byte aligned (may make this alignment a requirement later).
    699     // Due to constraints on mNormalFrameCount, the buffer size is a multiple of 16 frames.
    700     void*                           mEffectBuffer;
    701 
    702     // Size of mEffectsBuffer in bytes: mNormalFrameCount * #channels * sampsize.
    703     size_t                          mEffectBufferSize;
    704 
    705     // The audio format of mEffectsBuffer. Set to AUDIO_FORMAT_PCM_16_BIT only.
    706     audio_format_t                  mEffectBufferFormat;
    707 
    708     // An internal flag set to true by MixerThread::prepareTracks_l()
    709     // when mEffectsBuffer contains valid data after mixing.
    710     //
    711     // When this is set, all mixer data is routed into the effects buffer
    712     // for any processing (including output processing).
    713     bool                            mEffectBufferValid;
    714 
    715     // suspend count, > 0 means suspended.  While suspended, the thread continues to pull from
    716     // tracks and mix, but doesn't write to HAL.  A2DP and SCO HAL implementations can't handle
    717     // concurrent use of both of them, so Audio Policy Service suspends one of the threads to
    718     // workaround that restriction.
    719     // 'volatile' means accessed via atomic operations and no lock.
    720     volatile int32_t                mSuspended;
    721 
    722     int64_t                         mBytesWritten;
    723     int64_t                         mFramesWritten; // not reset on standby
    724     int64_t                         mSuspendedFrames; // not reset on standby
    725 private:
    726     // mMasterMute is in both PlaybackThread and in AudioFlinger.  When a
    727     // PlaybackThread needs to find out if master-muted, it checks it's local
    728     // copy rather than the one in AudioFlinger.  This optimization saves a lock.
    729     bool                            mMasterMute;
    730                 void        setMasterMute_l(bool muted) { mMasterMute = muted; }
    731 protected:
    732     SortedVector< wp<Track> >       mActiveTracks;  // FIXME check if this could be sp<>
    733     SortedVector<int>               mWakeLockUids;
    734     int                             mActiveTracksGeneration;
    735     wp<Track>                       mLatestActiveTrack; // latest track added to mActiveTracks
    736 
    737     // Allocate a track name for a given channel mask.
    738     //   Returns name >= 0 if successful, -1 on failure.
    739     virtual int             getTrackName_l(audio_channel_mask_t channelMask,
    740                                            audio_format_t format, audio_session_t sessionId) = 0;
    741     virtual void            deleteTrackName_l(int name) = 0;
    742 
    743     // Time to sleep between cycles when:
    744     virtual uint32_t        activeSleepTimeUs() const;      // mixer state MIXER_TRACKS_ENABLED
    745     virtual uint32_t        idleSleepTimeUs() const = 0;    // mixer state MIXER_IDLE
    746     virtual uint32_t        suspendSleepTimeUs() const = 0; // audio policy manager suspended us
    747     // No sleep when mixer state == MIXER_TRACKS_READY; relies on audio HAL stream->write()
    748     // No sleep in standby mode; waits on a condition
    749 
    750     // Code snippets that are temporarily lifted up out of threadLoop() until the merge
    751                 void        checkSilentMode_l();
    752 
    753     // Non-trivial for DUPLICATING only
    754     virtual     void        saveOutputTracks() { }
    755     virtual     void        clearOutputTracks() { }
    756 
    757     // Cache various calculated values, at threadLoop() entry and after a parameter change
    758     virtual     void        cacheParameters_l();
    759 
    760     virtual     uint32_t    correctLatency_l(uint32_t latency) const;
    761 
    762     virtual     status_t    createAudioPatch_l(const struct audio_patch *patch,
    763                                    audio_patch_handle_t *handle);
    764     virtual     status_t    releaseAudioPatch_l(const audio_patch_handle_t handle);
    765 
    766                 bool        usesHwAvSync() const { return (mType == DIRECT) && (mOutput != NULL)
    767                                     && mHwSupportsPause
    768                                     && (mOutput->flags & AUDIO_OUTPUT_FLAG_HW_AV_SYNC); }
    769 
    770 private:
    771 
    772     friend class AudioFlinger;      // for numerous
    773 
    774     PlaybackThread& operator = (const PlaybackThread&);
    775 
    776     status_t    addTrack_l(const sp<Track>& track);
    777     bool        destroyTrack_l(const sp<Track>& track);
    778     void        removeTrack_l(const sp<Track>& track);
    779     void        broadcast_l();
    780 
    781     void        readOutputParameters_l();
    782 
    783     virtual void dumpInternals(int fd, const Vector<String16>& args);
    784     void        dumpTracks(int fd, const Vector<String16>& args);
    785 
    786     SortedVector< sp<Track> >       mTracks;
    787     stream_type_t                   mStreamTypes[AUDIO_STREAM_CNT];
    788     AudioStreamOut                  *mOutput;
    789 
    790     float                           mMasterVolume;
    791     nsecs_t                         mLastWriteTime;
    792     int                             mNumWrites;
    793     int                             mNumDelayedWrites;
    794     bool                            mInWrite;
    795 
    796     // FIXME rename these former local variables of threadLoop to standard "m" names
    797     nsecs_t                         mStandbyTimeNs;
    798     size_t                          mSinkBufferSize;
    799 
    800     // cached copies of activeSleepTimeUs() and idleSleepTimeUs() made by cacheParameters_l()
    801     uint32_t                        mActiveSleepTimeUs;
    802     uint32_t                        mIdleSleepTimeUs;
    803 
    804     uint32_t                        mSleepTimeUs;
    805 
    806     // mixer status returned by prepareTracks_l()
    807     mixer_state                     mMixerStatus; // current cycle
    808                                                   // previous cycle when in prepareTracks_l()
    809     mixer_state                     mMixerStatusIgnoringFastTracks;
    810                                                   // FIXME or a separate ready state per track
    811 
    812     // FIXME move these declarations into the specific sub-class that needs them
    813     // MIXER only
    814     uint32_t                        sleepTimeShift;
    815 
    816     // same as AudioFlinger::mStandbyTimeInNsecs except for DIRECT which uses a shorter value
    817     nsecs_t                         mStandbyDelayNs;
    818 
    819     // MIXER only
    820     nsecs_t                         maxPeriod;
    821 
    822     // DUPLICATING only
    823     uint32_t                        writeFrames;
    824 
    825     size_t                          mBytesRemaining;
    826     size_t                          mCurrentWriteLength;
    827     bool                            mUseAsyncWrite;
    828     // mWriteAckSequence contains current write sequence on bits 31-1. The write sequence is
    829     // incremented each time a write(), a flush() or a standby() occurs.
    830     // Bit 0 is set when a write blocks and indicates a callback is expected.
    831     // Bit 0 is reset by the async callback thread calling resetWriteBlocked(). Out of sequence
    832     // callbacks are ignored.
    833     uint32_t                        mWriteAckSequence;
    834     // mDrainSequence contains current drain sequence on bits 31-1. The drain sequence is
    835     // incremented each time a drain is requested or a flush() or standby() occurs.
    836     // Bit 0 is set when the drain() command is called at the HAL and indicates a callback is
    837     // expected.
    838     // Bit 0 is reset by the async callback thread calling resetDraining(). Out of sequence
    839     // callbacks are ignored.
    840     uint32_t                        mDrainSequence;
    841     // A condition that must be evaluated by prepareTrack_l() has changed and we must not wait
    842     // for async write callback in the thread loop before evaluating it
    843     bool                            mSignalPending;
    844     sp<AsyncCallbackThread>         mCallbackThread;
    845 
    846 private:
    847     // The HAL output sink is treated as non-blocking, but current implementation is blocking
    848     sp<NBAIO_Sink>          mOutputSink;
    849     // If a fast mixer is present, the blocking pipe sink, otherwise clear
    850     sp<NBAIO_Sink>          mPipeSink;
    851     // The current sink for the normal mixer to write it's (sub)mix, mOutputSink or mPipeSink
    852     sp<NBAIO_Sink>          mNormalSink;
    853 #ifdef TEE_SINK
    854     // For dumpsys
    855     sp<NBAIO_Sink>          mTeeSink;
    856     sp<NBAIO_Source>        mTeeSource;
    857 #endif
    858     uint32_t                mScreenState;   // cached copy of gScreenState
    859     static const size_t     kFastMixerLogSize = 4 * 1024;
    860     sp<NBLog::Writer>       mFastMixerNBLogWriter;
    861 public:
    862     virtual     bool        hasFastMixer() const = 0;
    863     virtual     FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex __unused) const
    864                                 { FastTrackUnderruns dummy; return dummy; }
    865 
    866 protected:
    867                 // accessed by both binder threads and within threadLoop(), lock on mutex needed
    868                 unsigned    mFastTrackAvailMask;    // bit i set if fast track [i] is available
    869                 bool        mHwSupportsPause;
    870                 bool        mHwPaused;
    871                 bool        mFlushPending;
    872 };
    873 
    874 class MixerThread : public PlaybackThread {
    875 public:
    876     MixerThread(const sp<AudioFlinger>& audioFlinger,
    877                 AudioStreamOut* output,
    878                 audio_io_handle_t id,
    879                 audio_devices_t device,
    880                 bool systemReady,
    881                 type_t type = MIXER);
    882     virtual             ~MixerThread();
    883 
    884     // Thread virtuals
    885 
    886     virtual     bool        checkForNewParameter_l(const String8& keyValuePair,
    887                                                    status_t& status);
    888     virtual     void        dumpInternals(int fd, const Vector<String16>& args);
    889 
    890 protected:
    891     virtual     mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
    892     virtual     int         getTrackName_l(audio_channel_mask_t channelMask,
    893                                            audio_format_t format, audio_session_t sessionId);
    894     virtual     void        deleteTrackName_l(int name);
    895     virtual     uint32_t    idleSleepTimeUs() const;
    896     virtual     uint32_t    suspendSleepTimeUs() const;
    897     virtual     void        cacheParameters_l();
    898 
    899     virtual void acquireWakeLock_l(int uid = -1) {
    900         PlaybackThread::acquireWakeLock_l(uid);
    901         if (hasFastMixer()) {
    902             mFastMixer->setBoottimeOffset(
    903                     mTimestamp.mTimebaseOffset[ExtendedTimestamp::TIMEBASE_BOOTTIME]);
    904         }
    905     }
    906 
    907     // threadLoop snippets
    908     virtual     ssize_t     threadLoop_write();
    909     virtual     void        threadLoop_standby();
    910     virtual     void        threadLoop_mix();
    911     virtual     void        threadLoop_sleepTime();
    912     virtual     void        threadLoop_removeTracks(const Vector< sp<Track> >& tracksToRemove);
    913     virtual     uint32_t    correctLatency_l(uint32_t latency) const;
    914 
    915     virtual     status_t    createAudioPatch_l(const struct audio_patch *patch,
    916                                    audio_patch_handle_t *handle);
    917     virtual     status_t    releaseAudioPatch_l(const audio_patch_handle_t handle);
    918 
    919                 AudioMixer* mAudioMixer;    // normal mixer
    920 private:
    921                 // one-time initialization, no locks required
    922                 sp<FastMixer>     mFastMixer;     // non-0 if there is also a fast mixer
    923                 sp<AudioWatchdog> mAudioWatchdog; // non-0 if there is an audio watchdog thread
    924 
    925                 // contents are not guaranteed to be consistent, no locks required
    926                 FastMixerDumpState mFastMixerDumpState;
    927 #ifdef STATE_QUEUE_DUMP
    928                 StateQueueObserverDump mStateQueueObserverDump;
    929                 StateQueueMutatorDump  mStateQueueMutatorDump;
    930 #endif
    931                 AudioWatchdogDump mAudioWatchdogDump;
    932 
    933                 // accessible only within the threadLoop(), no locks required
    934                 //          mFastMixer->sq()    // for mutating and pushing state
    935                 int32_t     mFastMixerFutex;    // for cold idle
    936 
    937                 std::atomic_bool mMasterMono;
    938 public:
    939     virtual     bool        hasFastMixer() const { return mFastMixer != 0; }
    940     virtual     FastTrackUnderruns getFastTrackUnderruns(size_t fastIndex) const {
    941                               ALOG_ASSERT(fastIndex < FastMixerState::sMaxFastTracks);
    942                               return mFastMixerDumpState.mTracks[fastIndex].mUnderruns;
    943                             }
    944 
    945 protected:
    946     virtual     void       setMasterMono_l(bool mono) {
    947                                mMasterMono.store(mono);
    948                                if (mFastMixer != nullptr) { /* hasFastMixer() */
    949                                    mFastMixer->setMasterMono(mMasterMono);
    950                                }
    951                            }
    952                 // the FastMixer performs mono blend if it exists.
    953                 // Blending with limiter is not idempotent,
    954                 // and blending without limiter is idempotent but inefficient to do twice.
    955     virtual     bool       requireMonoBlend() { return mMasterMono.load() && !hasFastMixer(); }
    956 };
    957 
    958 class DirectOutputThread : public PlaybackThread {
    959 public:
    960 
    961     DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
    962                        audio_io_handle_t id, audio_devices_t device, bool systemReady);
    963     virtual                 ~DirectOutputThread();
    964 
    965     // Thread virtuals
    966 
    967     virtual     bool        checkForNewParameter_l(const String8& keyValuePair,
    968                                                    status_t& status);
    969     virtual     void        flushHw_l();
    970 
    971 protected:
    972     virtual     int         getTrackName_l(audio_channel_mask_t channelMask,
    973                                            audio_format_t format, audio_session_t sessionId);
    974     virtual     void        deleteTrackName_l(int name);
    975     virtual     uint32_t    activeSleepTimeUs() const;
    976     virtual     uint32_t    idleSleepTimeUs() const;
    977     virtual     uint32_t    suspendSleepTimeUs() const;
    978     virtual     void        cacheParameters_l();
    979 
    980     // threadLoop snippets
    981     virtual     mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
    982     virtual     void        threadLoop_mix();
    983     virtual     void        threadLoop_sleepTime();
    984     virtual     void        threadLoop_exit();
    985     virtual     bool        shouldStandby_l();
    986 
    987     virtual     void        onAddNewTrack_l();
    988 
    989     // volumes last sent to audio HAL with stream->set_volume()
    990     float mLeftVolFloat;
    991     float mRightVolFloat;
    992 
    993     DirectOutputThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
    994                         audio_io_handle_t id, uint32_t device, ThreadBase::type_t type,
    995                         bool systemReady);
    996     void processVolume_l(Track *track, bool lastTrack);
    997 
    998     // prepareTracks_l() tells threadLoop_mix() the name of the single active track
    999     sp<Track>               mActiveTrack;
   1000 
   1001     wp<Track>               mPreviousTrack;         // used to detect track switch
   1002 
   1003 public:
   1004     virtual     bool        hasFastMixer() const { return false; }
   1005 };
   1006 
   1007 class OffloadThread : public DirectOutputThread {
   1008 public:
   1009 
   1010     OffloadThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output,
   1011                         audio_io_handle_t id, uint32_t device, bool systemReady);
   1012     virtual                 ~OffloadThread() {};
   1013     virtual     void        flushHw_l();
   1014 
   1015 protected:
   1016     // threadLoop snippets
   1017     virtual     mixer_state prepareTracks_l(Vector< sp<Track> > *tracksToRemove);
   1018     virtual     void        threadLoop_exit();
   1019 
   1020     virtual     bool        waitingAsyncCallback();
   1021     virtual     bool        waitingAsyncCallback_l();
   1022     virtual     void        invalidateTracks(audio_stream_type_t streamType);
   1023 
   1024     virtual     bool        keepWakeLock() const { return (mKeepWakeLock || (mDrainSequence & 1)); }
   1025 
   1026 private:
   1027     size_t      mPausedWriteLength;     // length in bytes of write interrupted by pause
   1028     size_t      mPausedBytesRemaining;  // bytes still waiting in mixbuffer after resume
   1029     bool        mKeepWakeLock;          // keep wake lock while waiting for write callback
   1030     uint64_t    mOffloadUnderrunPosition; // Current frame position for offloaded playback
   1031                                           // used and valid only during underrun.  ~0 if
   1032                                           // no underrun has occurred during playback and
   1033                                           // is not reset on standby.
   1034 };
   1035 
   1036 class AsyncCallbackThread : public Thread {
   1037 public:
   1038 
   1039     AsyncCallbackThread(const wp<PlaybackThread>& playbackThread);
   1040 
   1041     virtual             ~AsyncCallbackThread();
   1042 
   1043     // Thread virtuals
   1044     virtual bool        threadLoop();
   1045 
   1046     // RefBase
   1047     virtual void        onFirstRef();
   1048 
   1049             void        exit();
   1050             void        setWriteBlocked(uint32_t sequence);
   1051             void        resetWriteBlocked();
   1052             void        setDraining(uint32_t sequence);
   1053             void        resetDraining();
   1054             void        setAsyncError();
   1055 
   1056 private:
   1057     const wp<PlaybackThread>   mPlaybackThread;
   1058     // mWriteAckSequence corresponds to the last write sequence passed by the offload thread via
   1059     // setWriteBlocked(). The sequence is shifted one bit to the left and the lsb is used
   1060     // to indicate that the callback has been received via resetWriteBlocked()
   1061     uint32_t                   mWriteAckSequence;
   1062     // mDrainSequence corresponds to the last drain sequence passed by the offload thread via
   1063     // setDraining(). The sequence is shifted one bit to the left and the lsb is used
   1064     // to indicate that the callback has been received via resetDraining()
   1065     uint32_t                   mDrainSequence;
   1066     Condition                  mWaitWorkCV;
   1067     Mutex                      mLock;
   1068     bool                       mAsyncError;
   1069 };
   1070 
   1071 class DuplicatingThread : public MixerThread {
   1072 public:
   1073     DuplicatingThread(const sp<AudioFlinger>& audioFlinger, MixerThread* mainThread,
   1074                       audio_io_handle_t id, bool systemReady);
   1075     virtual                 ~DuplicatingThread();
   1076 
   1077     // Thread virtuals
   1078                 void        addOutputTrack(MixerThread* thread);
   1079                 void        removeOutputTrack(MixerThread* thread);
   1080                 uint32_t    waitTimeMs() const { return mWaitTimeMs; }
   1081 protected:
   1082     virtual     uint32_t    activeSleepTimeUs() const;
   1083 
   1084 private:
   1085                 bool        outputsReady(const SortedVector< sp<OutputTrack> > &outputTracks);
   1086 protected:
   1087     // threadLoop snippets
   1088     virtual     void        threadLoop_mix();
   1089     virtual     void        threadLoop_sleepTime();
   1090     virtual     ssize_t     threadLoop_write();
   1091     virtual     void        threadLoop_standby();
   1092     virtual     void        cacheParameters_l();
   1093 
   1094 private:
   1095     // called from threadLoop, addOutputTrack, removeOutputTrack
   1096     virtual     void        updateWaitTime_l();
   1097 protected:
   1098     virtual     void        saveOutputTracks();
   1099     virtual     void        clearOutputTracks();
   1100 private:
   1101 
   1102                 uint32_t    mWaitTimeMs;
   1103     SortedVector < sp<OutputTrack> >  outputTracks;
   1104     SortedVector < sp<OutputTrack> >  mOutputTracks;
   1105 public:
   1106     virtual     bool        hasFastMixer() const { return false; }
   1107 };
   1108 
   1109 
   1110 // record thread
   1111 class RecordThread : public ThreadBase
   1112 {
   1113 public:
   1114 
   1115     class RecordTrack;
   1116 
   1117     /* The ResamplerBufferProvider is used to retrieve recorded input data from the
   1118      * RecordThread.  It maintains local state on the relative position of the read
   1119      * position of the RecordTrack compared with the RecordThread.
   1120      */
   1121     class ResamplerBufferProvider : public AudioBufferProvider
   1122     {
   1123     public:
   1124         ResamplerBufferProvider(RecordTrack* recordTrack) :
   1125             mRecordTrack(recordTrack),
   1126             mRsmpInUnrel(0), mRsmpInFront(0) { }
   1127         virtual ~ResamplerBufferProvider() { }
   1128 
   1129         // called to set the ResamplerBufferProvider to head of the RecordThread data buffer,
   1130         // skipping any previous data read from the hal.
   1131         virtual void reset();
   1132 
   1133         /* Synchronizes RecordTrack position with the RecordThread.
   1134          * Calculates available frames and handle overruns if the RecordThread
   1135          * has advanced faster than the ResamplerBufferProvider has retrieved data.
   1136          * TODO: why not do this for every getNextBuffer?
   1137          *
   1138          * Parameters
   1139          * framesAvailable:  pointer to optional output size_t to store record track
   1140          *                   frames available.
   1141          *      hasOverrun:  pointer to optional boolean, returns true if track has overrun.
   1142          */
   1143 
   1144         virtual void sync(size_t *framesAvailable = NULL, bool *hasOverrun = NULL);
   1145 
   1146         // AudioBufferProvider interface
   1147         virtual status_t    getNextBuffer(AudioBufferProvider::Buffer* buffer);
   1148         virtual void        releaseBuffer(AudioBufferProvider::Buffer* buffer);
   1149     private:
   1150         RecordTrack * const mRecordTrack;
   1151         size_t              mRsmpInUnrel;   // unreleased frames remaining from
   1152                                             // most recent getNextBuffer
   1153                                             // for debug only
   1154         int32_t             mRsmpInFront;   // next available frame
   1155                                             // rolling counter that is never cleared
   1156     };
   1157 
   1158     /* The RecordBufferConverter is used for format, channel, and sample rate
   1159      * conversion for a RecordTrack.
   1160      *
   1161      * TODO: Self contained, so move to a separate file later.
   1162      *
   1163      * RecordBufferConverter uses the convert() method rather than exposing a
   1164      * buffer provider interface; this is to save a memory copy.
   1165      */
   1166     class RecordBufferConverter
   1167     {
   1168     public:
   1169         RecordBufferConverter(
   1170                 audio_channel_mask_t srcChannelMask, audio_format_t srcFormat,
   1171                 uint32_t srcSampleRate,
   1172                 audio_channel_mask_t dstChannelMask, audio_format_t dstFormat,
   1173                 uint32_t dstSampleRate);
   1174 
   1175         ~RecordBufferConverter();
   1176 
   1177         /* Converts input data from an AudioBufferProvider by format, channelMask,
   1178          * and sampleRate to a destination buffer.
   1179          *
   1180          * Parameters
   1181          *      dst:  buffer to place the converted data.
   1182          * provider:  buffer provider to obtain source data.
   1183          *   frames:  number of frames to convert
   1184          *
   1185          * Returns the number of frames converted.
   1186          */
   1187         size_t convert(void *dst, AudioBufferProvider *provider, size_t frames);
   1188 
   1189         // returns NO_ERROR if constructor was successful
   1190         status_t initCheck() const {
   1191             // mSrcChannelMask set on successful updateParameters
   1192             return mSrcChannelMask != AUDIO_CHANNEL_INVALID ? NO_ERROR : NO_INIT;
   1193         }
   1194 
   1195         // allows dynamic reconfigure of all parameters
   1196         status_t updateParameters(
   1197                 audio_channel_mask_t srcChannelMask, audio_format_t srcFormat,
   1198                 uint32_t srcSampleRate,
   1199                 audio_channel_mask_t dstChannelMask, audio_format_t dstFormat,
   1200                 uint32_t dstSampleRate);
   1201 
   1202         // called to reset resampler buffers on record track discontinuity
   1203         void reset() {
   1204             if (mResampler != NULL) {
   1205                 mResampler->reset();
   1206             }
   1207         }
   1208 
   1209     private:
   1210         // format conversion when not using resampler
   1211         void convertNoResampler(void *dst, const void *src, size_t frames);
   1212 
   1213         // format conversion when using resampler; modifies src in-place
   1214         void convertResampler(void *dst, /*not-a-const*/ void *src, size_t frames);
   1215 
   1216         // user provided information
   1217         audio_channel_mask_t mSrcChannelMask;
   1218         audio_format_t       mSrcFormat;
   1219         uint32_t             mSrcSampleRate;
   1220         audio_channel_mask_t mDstChannelMask;
   1221         audio_format_t       mDstFormat;
   1222         uint32_t             mDstSampleRate;
   1223 
   1224         // derived information
   1225         uint32_t             mSrcChannelCount;
   1226         uint32_t             mDstChannelCount;
   1227         size_t               mDstFrameSize;
   1228 
   1229         // format conversion buffer
   1230         void                *mBuf;
   1231         size_t               mBufFrames;
   1232         size_t               mBufFrameSize;
   1233 
   1234         // resampler info
   1235         AudioResampler      *mResampler;
   1236 
   1237         bool                 mIsLegacyDownmix;  // legacy stereo to mono conversion needed
   1238         bool                 mIsLegacyUpmix;    // legacy mono to stereo conversion needed
   1239         bool                 mRequiresFloat;    // data processing requires float (e.g. resampler)
   1240         PassthruBufferProvider *mInputConverterProvider;    // converts input to float
   1241         int8_t               mIdxAry[sizeof(uint32_t) * 8]; // used for channel mask conversion
   1242     };
   1243 
   1244 #include "RecordTracks.h"
   1245 
   1246             RecordThread(const sp<AudioFlinger>& audioFlinger,
   1247                     AudioStreamIn *input,
   1248                     audio_io_handle_t id,
   1249                     audio_devices_t outDevice,
   1250                     audio_devices_t inDevice,
   1251                     bool systemReady
   1252 #ifdef TEE_SINK
   1253                     , const sp<NBAIO_Sink>& teeSink
   1254 #endif
   1255                     );
   1256             virtual     ~RecordThread();
   1257 
   1258     // no addTrack_l ?
   1259     void        destroyTrack_l(const sp<RecordTrack>& track);
   1260     void        removeTrack_l(const sp<RecordTrack>& track);
   1261 
   1262     void        dumpInternals(int fd, const Vector<String16>& args);
   1263     void        dumpTracks(int fd, const Vector<String16>& args);
   1264 
   1265     // Thread virtuals
   1266     virtual bool        threadLoop();
   1267 
   1268     // RefBase
   1269     virtual void        onFirstRef();
   1270 
   1271     virtual status_t    initCheck() const { return (mInput == NULL) ? NO_INIT : NO_ERROR; }
   1272 
   1273     virtual sp<MemoryDealer>    readOnlyHeap() const { return mReadOnlyHeap; }
   1274 
   1275     virtual sp<IMemory> pipeMemory() const { return mPipeMemory; }
   1276 
   1277             sp<AudioFlinger::RecordThread::RecordTrack>  createRecordTrack_l(
   1278                     const sp<AudioFlinger::Client>& client,
   1279                     uint32_t sampleRate,
   1280                     audio_format_t format,
   1281                     audio_channel_mask_t channelMask,
   1282                     size_t *pFrameCount,
   1283                     audio_session_t sessionId,
   1284                     size_t *notificationFrames,
   1285                     int uid,
   1286                     audio_input_flags_t *flags,
   1287                     pid_t tid,
   1288                     status_t *status /*non-NULL*/);
   1289 
   1290             status_t    start(RecordTrack* recordTrack,
   1291                               AudioSystem::sync_event_t event,
   1292                               audio_session_t triggerSession);
   1293 
   1294             // ask the thread to stop the specified track, and
   1295             // return true if the caller should then do it's part of the stopping process
   1296             bool        stop(RecordTrack* recordTrack);
   1297 
   1298             void        dump(int fd, const Vector<String16>& args);
   1299             AudioStreamIn* clearInput();
   1300             virtual audio_stream_t* stream() const;
   1301 
   1302 
   1303     virtual bool        checkForNewParameter_l(const String8& keyValuePair,
   1304                                                status_t& status);
   1305     virtual void        cacheParameters_l() {}
   1306     virtual String8     getParameters(const String8& keys);
   1307     virtual void        ioConfigChanged(audio_io_config_event event, pid_t pid = 0);
   1308     virtual status_t    createAudioPatch_l(const struct audio_patch *patch,
   1309                                            audio_patch_handle_t *handle);
   1310     virtual status_t    releaseAudioPatch_l(const audio_patch_handle_t handle);
   1311 
   1312             void        addPatchRecord(const sp<PatchRecord>& record);
   1313             void        deletePatchRecord(const sp<PatchRecord>& record);
   1314 
   1315             void        readInputParameters_l();
   1316     virtual uint32_t    getInputFramesLost();
   1317 
   1318     virtual status_t addEffectChain_l(const sp<EffectChain>& chain);
   1319     virtual size_t removeEffectChain_l(const sp<EffectChain>& chain);
   1320     virtual uint32_t hasAudioSession_l(audio_session_t sessionId) const;
   1321 
   1322             // Return the set of unique session IDs across all tracks.
   1323             // The keys are the session IDs, and the associated values are meaningless.
   1324             // FIXME replace by Set [and implement Bag/Multiset for other uses].
   1325             KeyedVector<audio_session_t, bool> sessionIds() const;
   1326 
   1327     virtual status_t setSyncEvent(const sp<SyncEvent>& event);
   1328     virtual bool     isValidSyncEvent(const sp<SyncEvent>& event) const;
   1329 
   1330     static void syncStartEventCallback(const wp<SyncEvent>& event);
   1331 
   1332     virtual size_t      frameCount() const { return mFrameCount; }
   1333             bool        hasFastCapture() const { return mFastCapture != 0; }
   1334     virtual void        getAudioPortConfig(struct audio_port_config *config);
   1335 
   1336     virtual status_t    checkEffectCompatibility_l(const effect_descriptor_t *desc,
   1337                                                    audio_session_t sessionId);
   1338 
   1339 private:
   1340             // Enter standby if not already in standby, and set mStandby flag
   1341             void    standbyIfNotAlreadyInStandby();
   1342 
   1343             // Call the HAL standby method unconditionally, and don't change mStandby flag
   1344             void    inputStandBy();
   1345 
   1346             AudioStreamIn                       *mInput;
   1347             SortedVector < sp<RecordTrack> >    mTracks;
   1348             // mActiveTracks has dual roles:  it indicates the current active track(s), and
   1349             // is used together with mStartStopCond to indicate start()/stop() progress
   1350             SortedVector< sp<RecordTrack> >     mActiveTracks;
   1351             // generation counter for mActiveTracks
   1352             int                                 mActiveTracksGen;
   1353             Condition                           mStartStopCond;
   1354 
   1355             // resampler converts input at HAL Hz to output at AudioRecord client Hz
   1356             void                               *mRsmpInBuffer; //
   1357             size_t                              mRsmpInFrames;  // size of resampler input in frames
   1358             size_t                              mRsmpInFramesP2;// size rounded up to a power-of-2
   1359 
   1360             // rolling index that is never cleared
   1361             int32_t                             mRsmpInRear;    // last filled frame + 1
   1362 
   1363             // For dumpsys
   1364             const sp<NBAIO_Sink>                mTeeSink;
   1365 
   1366             const sp<MemoryDealer>              mReadOnlyHeap;
   1367 
   1368             // one-time initialization, no locks required
   1369             sp<FastCapture>                     mFastCapture;   // non-0 if there is also
   1370                                                                 // a fast capture
   1371 
   1372             // FIXME audio watchdog thread
   1373 
   1374             // contents are not guaranteed to be consistent, no locks required
   1375             FastCaptureDumpState                mFastCaptureDumpState;
   1376 #ifdef STATE_QUEUE_DUMP
   1377             // FIXME StateQueue observer and mutator dump fields
   1378 #endif
   1379             // FIXME audio watchdog dump
   1380 
   1381             // accessible only within the threadLoop(), no locks required
   1382             //          mFastCapture->sq()      // for mutating and pushing state
   1383             int32_t     mFastCaptureFutex;      // for cold idle
   1384 
   1385             // The HAL input source is treated as non-blocking,
   1386             // but current implementation is blocking
   1387             sp<NBAIO_Source>                    mInputSource;
   1388             // The source for the normal capture thread to read from: mInputSource or mPipeSource
   1389             sp<NBAIO_Source>                    mNormalSource;
   1390             // If a fast capture is present, the non-blocking pipe sink written to by fast capture,
   1391             // otherwise clear
   1392             sp<NBAIO_Sink>                      mPipeSink;
   1393             // If a fast capture is present, the non-blocking pipe source read by normal thread,
   1394             // otherwise clear
   1395             sp<NBAIO_Source>                    mPipeSource;
   1396             // Depth of pipe from fast capture to normal thread and fast clients, always power of 2
   1397             size_t                              mPipeFramesP2;
   1398             // If a fast capture is present, the Pipe as IMemory, otherwise clear
   1399             sp<IMemory>                         mPipeMemory;
   1400 
   1401             static const size_t                 kFastCaptureLogSize = 4 * 1024;
   1402             sp<NBLog::Writer>                   mFastCaptureNBLogWriter;
   1403 
   1404             bool                                mFastTrackAvail;    // true if fast track available
   1405 };
   1406