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