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// playback track
23class Track : public TrackBase, public VolumeProvider {
24public:
25                        Track(  PlaybackThread *thread,
26                                const sp<Client>& client,
27                                audio_stream_type_t streamType,
28                                uint32_t sampleRate,
29                                audio_format_t format,
30                                audio_channel_mask_t channelMask,
31                                size_t frameCount,
32                                void *buffer,
33                                const sp<IMemory>& sharedBuffer,
34                                audio_session_t sessionId,
35                                int uid,
36                                IAudioFlinger::track_flags_t flags,
37                                track_type type);
38    virtual             ~Track();
39    virtual status_t    initCheck() const;
40
41    static  void        appendDumpHeader(String8& result);
42            void        dump(char* buffer, size_t size, bool active);
43    virtual status_t    start(AudioSystem::sync_event_t event =
44                                    AudioSystem::SYNC_EVENT_NONE,
45                             audio_session_t triggerSession = AUDIO_SESSION_NONE);
46    virtual void        stop();
47            void        pause();
48
49            void        flush();
50            void        destroy();
51            int         name() const { return mName; }
52
53    virtual uint32_t    sampleRate() const;
54
55            audio_stream_type_t streamType() const {
56                return mStreamType;
57            }
58            bool        isOffloaded() const { return (mFlags & IAudioFlinger::TRACK_OFFLOAD) != 0; }
59            bool        isDirect() const { return (mFlags & IAudioFlinger::TRACK_DIRECT) != 0; }
60            status_t    setParameters(const String8& keyValuePairs);
61            status_t    attachAuxEffect(int EffectId);
62            void        setAuxBuffer(int EffectId, int32_t *buffer);
63            int32_t     *auxBuffer() const { return mAuxBuffer; }
64            void        setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; }
65            int16_t     *mainBuffer() const { return mMainBuffer; }
66            int         auxEffectId() const { return mAuxEffectId; }
67    virtual status_t    getTimestamp(AudioTimestamp& timestamp);
68            void        signal();
69
70// implement FastMixerState::VolumeProvider interface
71    virtual gain_minifloat_packed_t getVolumeLR();
72
73    virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
74
75protected:
76    // for numerous
77    friend class PlaybackThread;
78    friend class MixerThread;
79    friend class DirectOutputThread;
80    friend class OffloadThread;
81
82                        Track(const Track&);
83                        Track& operator = (const Track&);
84
85    // AudioBufferProvider interface
86    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
87    // releaseBuffer() not overridden
88
89    // ExtendedAudioBufferProvider interface
90    virtual size_t framesReady() const;
91    virtual int64_t framesReleased() const;
92    virtual void onTimestamp(const ExtendedTimestamp &timestamp);
93
94    bool isPausing() const { return mState == PAUSING; }
95    bool isPaused() const { return mState == PAUSED; }
96    bool isResuming() const { return mState == RESUMING; }
97    bool isReady() const;
98    void setPaused() { mState = PAUSED; }
99    void reset();
100    bool isFlushPending() const { return mFlushHwPending; }
101    void flushAck();
102    bool isResumePending();
103    void resumeAck();
104    void updateTrackFrameInfo(int64_t trackFramesReleased, int64_t sinkFramesWritten,
105            const ExtendedTimestamp &timeStamp);
106
107    sp<IMemory> sharedBuffer() const { return mSharedBuffer; }
108
109    // framesWritten is cumulative, never reset, and is shared all tracks
110    // audioHalFrames is derived from output latency
111    // FIXME parameters not needed, could get them from the thread
112    bool presentationComplete(int64_t framesWritten, size_t audioHalFrames);
113    void signalClientFlag(int32_t flag);
114
115public:
116    void triggerEvents(AudioSystem::sync_event_t type);
117    void invalidate();
118    void disable();
119
120    bool isInvalid() const { return mIsInvalid; }
121    int fastIndex() const { return mFastIndex; }
122
123protected:
124
125    // FILLED state is used for suppressing volume ramp at begin of playing
126    enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE};
127    mutable uint8_t     mFillingUpStatus;
128    int8_t              mRetryCount;
129
130    // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const
131    sp<IMemory>         mSharedBuffer;
132
133    bool                mResetDone;
134    const audio_stream_type_t mStreamType;
135    int                 mName;      // track name on the normal mixer,
136                                    // allocated statically at track creation time,
137                                    // and is even allocated (though unused) for fast tracks
138                                    // FIXME don't allocate track name for fast tracks
139    int16_t             *mMainBuffer;
140    int32_t             *mAuxBuffer;
141    int                 mAuxEffectId;
142    bool                mHasVolumeController;
143    size_t              mPresentationCompleteFrames; // number of frames written to the
144                                    // audio HAL when this track will be fully rendered
145                                    // zero means not monitoring
146
147    // access these three variables only when holding thread lock.
148    LinearMap<int64_t> mFrameMap;           // track frame to server frame mapping
149
150    ExtendedTimestamp  mSinkTimestamp;
151
152private:
153    // The following fields are only for fast tracks, and should be in a subclass
154    int                 mFastIndex; // index within FastMixerState::mFastTracks[];
155                                    // either mFastIndex == -1 if not isFastTrack()
156                                    // or 0 < mFastIndex < FastMixerState::kMaxFast because
157                                    // index 0 is reserved for normal mixer's submix;
158                                    // index is allocated statically at track creation time
159                                    // but the slot is only used if track is active
160    FastTrackUnderruns  mObservedUnderruns; // Most recently observed value of
161                                    // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
162    volatile float      mCachedVolume;  // combined master volume and stream type volume;
163                                        // 'volatile' means accessed without lock or
164                                        // barrier, but is read/written atomically
165    bool                mIsInvalid; // non-resettable latch, set by invalidate()
166    AudioTrackServerProxy*  mAudioTrackServerProxy;
167    bool                mResumeToStopping; // track was paused in stopping state.
168    bool                mFlushHwPending; // track requests for thread flush
169
170};  // end of Track
171
172
173// playback track, used by DuplicatingThread
174class OutputTrack : public Track {
175public:
176
177    class Buffer : public AudioBufferProvider::Buffer {
178    public:
179        void *mBuffer;
180    };
181
182                        OutputTrack(PlaybackThread *thread,
183                                DuplicatingThread *sourceThread,
184                                uint32_t sampleRate,
185                                audio_format_t format,
186                                audio_channel_mask_t channelMask,
187                                size_t frameCount,
188                                int uid);
189    virtual             ~OutputTrack();
190
191    virtual status_t    start(AudioSystem::sync_event_t event =
192                                    AudioSystem::SYNC_EVENT_NONE,
193                             audio_session_t triggerSession = AUDIO_SESSION_NONE);
194    virtual void        stop();
195            bool        write(void* data, uint32_t frames);
196            bool        bufferQueueEmpty() const { return mBufferQueue.size() == 0; }
197            bool        isActive() const { return mActive; }
198    const wp<ThreadBase>& thread() const { return mThread; }
199
200private:
201
202    status_t            obtainBuffer(AudioBufferProvider::Buffer* buffer,
203                                     uint32_t waitTimeMs);
204    void                clearBufferQueue();
205
206    void                restartIfDisabled();
207
208    // Maximum number of pending buffers allocated by OutputTrack::write()
209    static const uint8_t kMaxOverFlowBuffers = 10;
210
211    Vector < Buffer* >          mBufferQueue;
212    AudioBufferProvider::Buffer mOutBuffer;
213    bool                        mActive;
214    DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
215    AudioTrackClientProxy*      mClientProxy;
216};  // end of OutputTrack
217
218// playback track, used by PatchPanel
219class PatchTrack : public Track, public PatchProxyBufferProvider {
220public:
221
222                        PatchTrack(PlaybackThread *playbackThread,
223                                   audio_stream_type_t streamType,
224                                   uint32_t sampleRate,
225                                   audio_channel_mask_t channelMask,
226                                   audio_format_t format,
227                                   size_t frameCount,
228                                   void *buffer,
229                                   IAudioFlinger::track_flags_t flags);
230    virtual             ~PatchTrack();
231
232    virtual status_t    start(AudioSystem::sync_event_t event =
233                                    AudioSystem::SYNC_EVENT_NONE,
234                             audio_session_t triggerSession = AUDIO_SESSION_NONE);
235
236    // AudioBufferProvider interface
237    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer);
238    virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
239
240    // PatchProxyBufferProvider interface
241    virtual status_t    obtainBuffer(Proxy::Buffer* buffer,
242                                     const struct timespec *timeOut = NULL);
243    virtual void        releaseBuffer(Proxy::Buffer* buffer);
244
245            void setPeerProxy(PatchProxyBufferProvider *proxy) { mPeerProxy = proxy; }
246
247private:
248            void restartIfDisabled();
249
250    sp<ClientProxy>             mProxy;
251    PatchProxyBufferProvider*   mPeerProxy;
252    struct timespec             mPeerTimeout;
253};  // end of PatchTrack
254