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