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