PlaybackTracks.h revision ab5cdbaf65ca509681d2726aacdf3ac8bfb6b3fa 
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                                const sp<IMemory>& sharedBuffer,
33                                int sessionId,
34                                int uid,
35                                IAudioFlinger::track_flags_t flags);
36    virtual             ~Track();
37    virtual status_t    initCheck() const;
38
39    static  void        appendDumpHeader(String8& result);
40            void        dump(char* buffer, size_t size, bool active);
41    virtual status_t    start(AudioSystem::sync_event_t event =
42                                    AudioSystem::SYNC_EVENT_NONE,
43                             int triggerSession = 0);
44    virtual void        stop();
45            void        pause();
46
47            void        flush();
48            void        destroy();
49            int         name() const { return mName; }
50
51    virtual uint32_t    sampleRate() const;
52
53            audio_stream_type_t streamType() const {
54                return mStreamType;
55            }
56            bool        isOffloaded() const { return (mFlags & IAudioFlinger::TRACK_OFFLOAD) != 0; }
57            bool        isDirect() const { return (mFlags & IAudioFlinger::TRACK_DIRECT) != 0; }
58            status_t    setParameters(const String8& keyValuePairs);
59            status_t    attachAuxEffect(int EffectId);
60            void        setAuxBuffer(int EffectId, int32_t *buffer);
61            int32_t     *auxBuffer() const { return mAuxBuffer; }
62            void        setMainBuffer(int16_t *buffer) { mMainBuffer = buffer; }
63            int16_t     *mainBuffer() const { return mMainBuffer; }
64            int         auxEffectId() const { return mAuxEffectId; }
65    virtual status_t    getTimestamp(AudioTimestamp& timestamp);
66            void        signal();
67
68// implement FastMixerState::VolumeProvider interface
69    virtual gain_minifloat_packed_t getVolumeLR();
70
71    virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
72
73protected:
74    // for numerous
75    friend class PlaybackThread;
76    friend class MixerThread;
77    friend class DirectOutputThread;
78    friend class OffloadThread;
79
80                        Track(const Track&);
81                        Track& operator = (const Track&);
82
83    // AudioBufferProvider interface
84    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer,
85                                   int64_t pts = kInvalidPTS);
86    // releaseBuffer() not overridden
87
88    // ExtendedAudioBufferProvider interface
89    virtual size_t framesReady() const;
90    virtual size_t framesReleased() const;
91
92    bool isPausing() const { return mState == PAUSING; }
93    bool isPaused() const { return mState == PAUSED; }
94    bool isResuming() const { return mState == RESUMING; }
95    bool isReady() const;
96    void setPaused() { mState = PAUSED; }
97    void reset();
98    bool isFlushPending() const { return mFlushHwPending; }
99    void flushAck();
100    bool isResumePending();
101    void resumeAck();
102
103    bool isOutputTrack() const {
104        return (mStreamType == AUDIO_STREAM_CNT);
105    }
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(size_t framesWritten, size_t audioHalFrames);
113
114public:
115    void triggerEvents(AudioSystem::sync_event_t type);
116    void invalidate();
117    bool isInvalid() const { return mIsInvalid; }
118    virtual bool isTimedTrack() const { return false; }
119    int fastIndex() const { return mFastIndex; }
120
121protected:
122
123    // FILLED state is used for suppressing volume ramp at begin of playing
124    enum {FS_INVALID, FS_FILLING, FS_FILLED, FS_ACTIVE};
125    mutable uint8_t     mFillingUpStatus;
126    int8_t              mRetryCount;
127
128    // see comment at AudioFlinger::PlaybackThread::Track::~Track for why this can't be const
129    sp<IMemory>         mSharedBuffer;
130
131    bool                mResetDone;
132    const audio_stream_type_t mStreamType;
133    int                 mName;      // track name on the normal mixer,
134                                    // allocated statically at track creation time,
135                                    // and is even allocated (though unused) for fast tracks
136                                    // FIXME don't allocate track name for fast tracks
137    int16_t             *mMainBuffer;
138    int32_t             *mAuxBuffer;
139    int                 mAuxEffectId;
140    bool                mHasVolumeController;
141    size_t              mPresentationCompleteFrames; // number of frames written to the
142                                    // audio HAL when this track will be fully rendered
143                                    // zero means not monitoring
144private:
145    // The following fields are only for fast tracks, and should be in a subclass
146    int                 mFastIndex; // index within FastMixerState::mFastTracks[];
147                                    // either mFastIndex == -1 if not isFastTrack()
148                                    // or 0 < mFastIndex < FastMixerState::kMaxFast because
149                                    // index 0 is reserved for normal mixer's submix;
150                                    // index is allocated statically at track creation time
151                                    // but the slot is only used if track is active
152    FastTrackUnderruns  mObservedUnderruns; // Most recently observed value of
153                                    // mFastMixerDumpState.mTracks[mFastIndex].mUnderruns
154    volatile float      mCachedVolume;  // combined master volume and stream type volume;
155                                        // 'volatile' means accessed without lock or
156                                        // barrier, but is read/written atomically
157    bool                mIsInvalid; // non-resettable latch, set by invalidate()
158    AudioTrackServerProxy*  mAudioTrackServerProxy;
159    bool                mResumeToStopping; // track was paused in stopping state.
160    bool                mFlushHwPending; // track requests for thread flush
161
162    // for last call to getTimestamp
163    bool                mPreviousValid;
164    uint32_t            mPreviousFramesWritten;
165    AudioTimestamp      mPreviousTimestamp;
166
167};  // end of Track
168
169class TimedTrack : public Track {
170  public:
171    static sp<TimedTrack> create(PlaybackThread *thread,
172                                 const sp<Client>& client,
173                                 audio_stream_type_t streamType,
174                                 uint32_t sampleRate,
175                                 audio_format_t format,
176                                 audio_channel_mask_t channelMask,
177                                 size_t frameCount,
178                                 const sp<IMemory>& sharedBuffer,
179                                 int sessionId,
180                                 int uid);
181    virtual ~TimedTrack();
182
183    class TimedBuffer {
184      public:
185        TimedBuffer();
186        TimedBuffer(const sp<IMemory>& buffer, int64_t pts);
187        const sp<IMemory>& buffer() const { return mBuffer; }
188        int64_t pts() const { return mPTS; }
189        uint32_t position() const { return mPosition; }
190        void setPosition(uint32_t pos) { mPosition = pos; }
191      private:
192        sp<IMemory> mBuffer;
193        int64_t     mPTS;
194        uint32_t    mPosition;
195    };
196
197    // Mixer facing methods.
198    virtual bool isTimedTrack() const { return true; }
199    virtual size_t framesReady() const;
200
201    // AudioBufferProvider interface
202    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer,
203                                   int64_t pts);
204    virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
205
206    // Client/App facing methods.
207    status_t    allocateTimedBuffer(size_t size,
208                                    sp<IMemory>* buffer);
209    status_t    queueTimedBuffer(const sp<IMemory>& buffer,
210                                 int64_t pts);
211    status_t    setMediaTimeTransform(const LinearTransform& xform,
212                                      TimedAudioTrack::TargetTimeline target);
213
214  private:
215    TimedTrack(PlaybackThread *thread,
216               const sp<Client>& client,
217               audio_stream_type_t streamType,
218               uint32_t sampleRate,
219               audio_format_t format,
220               audio_channel_mask_t channelMask,
221               size_t frameCount,
222               const sp<IMemory>& sharedBuffer,
223               int sessionId,
224               int uid);
225
226    void timedYieldSamples_l(AudioBufferProvider::Buffer* buffer);
227    void timedYieldSilence_l(uint32_t numFrames,
228                             AudioBufferProvider::Buffer* buffer);
229    void trimTimedBufferQueue_l();
230    void trimTimedBufferQueueHead_l(const char* logTag);
231    void updateFramesPendingAfterTrim_l(const TimedBuffer& buf,
232                                        const char* logTag);
233
234    uint64_t            mLocalTimeFreq;
235    LinearTransform     mLocalTimeToSampleTransform;
236    LinearTransform     mMediaTimeToSampleTransform;
237    sp<MemoryDealer>    mTimedMemoryDealer;
238
239    Vector<TimedBuffer> mTimedBufferQueue;
240    bool                mQueueHeadInFlight;
241    bool                mTrimQueueHeadOnRelease;
242    uint32_t            mFramesPendingInQueue;
243
244    uint8_t*            mTimedSilenceBuffer;
245    uint32_t            mTimedSilenceBufferSize;
246    mutable Mutex       mTimedBufferQueueLock;
247    bool                mTimedAudioOutputOnTime;
248    CCHelper            mCCHelper;
249
250    Mutex               mMediaTimeTransformLock;
251    LinearTransform     mMediaTimeTransform;
252    bool                mMediaTimeTransformValid;
253    TimedAudioTrack::TargetTimeline mMediaTimeTransformTarget;
254};
255
256
257// playback track, used by DuplicatingThread
258class OutputTrack : public Track {
259public:
260
261    class Buffer : public AudioBufferProvider::Buffer {
262    public:
263        int16_t *mBuffer;
264    };
265
266                        OutputTrack(PlaybackThread *thread,
267                                DuplicatingThread *sourceThread,
268                                uint32_t sampleRate,
269                                audio_format_t format,
270                                audio_channel_mask_t channelMask,
271                                size_t frameCount,
272                                int uid);
273    virtual             ~OutputTrack();
274
275    virtual status_t    start(AudioSystem::sync_event_t event =
276                                    AudioSystem::SYNC_EVENT_NONE,
277                             int triggerSession = 0);
278    virtual void        stop();
279            bool        write(int16_t* data, uint32_t frames);
280            bool        bufferQueueEmpty() const { return mBufferQueue.size() == 0; }
281            bool        isActive() const { return mActive; }
282    const wp<ThreadBase>& thread() const { return mThread; }
283
284private:
285
286    status_t            obtainBuffer(AudioBufferProvider::Buffer* buffer,
287                                     uint32_t waitTimeMs);
288    void                clearBufferQueue();
289
290    // Maximum number of pending buffers allocated by OutputTrack::write()
291    static const uint8_t kMaxOverFlowBuffers = 10;
292
293    Vector < Buffer* >          mBufferQueue;
294    AudioBufferProvider::Buffer mOutBuffer;
295    bool                        mActive;
296    DuplicatingThread* const mSourceThread; // for waitTimeMs() in write()
297    AudioTrackClientProxy*      mClientProxy;
298};  // end of OutputTrack
299