TrackBase.h revision e3aa659e9cee7df5c12a80d285cc29ab3b2cbb39 
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// base for record and playback
23class TrackBase : public ExtendedAudioBufferProvider, public RefBase {
24
25public:
26    enum track_state {
27        IDLE,
28        TERMINATED,
29        FLUSHED,
30        STOPPED,
31        // next 2 states are currently used for fast tracks only
32        STOPPING_1,     // waiting for first underrun
33        STOPPING_2,     // waiting for presentation complete
34        RESUMING,
35        ACTIVE,
36        PAUSING,
37        PAUSED
38    };
39
40                        TrackBase(ThreadBase *thread,
41                                const sp<Client>& client,
42                                uint32_t sampleRate,
43                                audio_format_t format,
44                                audio_channel_mask_t channelMask,
45                                size_t frameCount,
46                                const sp<IMemory>& sharedBuffer,
47                                int sessionId,
48                                bool isOut);
49    virtual             ~TrackBase();
50
51    virtual status_t    start(AudioSystem::sync_event_t event,
52                             int triggerSession) = 0;
53    virtual void        stop() = 0;
54            sp<IMemory> getCblk() const { return mCblkMemory; }
55            audio_track_cblk_t* cblk() const { return mCblk; }
56            int         sessionId() const { return mSessionId; }
57    virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
58
59protected:
60                        TrackBase(const TrackBase&);
61                        TrackBase& operator = (const TrackBase&);
62
63    // AudioBufferProvider interface
64    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0;
65    virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
66
67    // ExtendedAudioBufferProvider interface is only needed for Track,
68    // but putting it in TrackBase avoids the complexity of virtual inheritance
69    virtual size_t  framesReady() const { return SIZE_MAX; }
70
71    audio_format_t format() const {
72        return mFormat;
73    }
74
75    uint32_t channelCount() const { return mChannelCount; }
76
77    audio_channel_mask_t channelMask() const { return mChannelMask; }
78
79    uint32_t sampleRate() const; // FIXME inline after cblk sr moved
80
81    // Return a pointer to the start of a contiguous slice of the track buffer.
82    // Parameter 'offset' is the requested start position, expressed in
83    // monotonically increasing frame units relative to the track epoch.
84    // Parameter 'frames' is the requested length, also in frame units.
85    // Always returns non-NULL.  It is the caller's responsibility to
86    // verify that this will be successful; the result of calling this
87    // function with invalid 'offset' or 'frames' is undefined.
88    void* getBuffer(uint32_t offset, uint32_t frames) const;
89
90    bool isStopped() const {
91        return (mState == STOPPED || mState == FLUSHED);
92    }
93
94    // for fast tracks only
95    bool isStopping() const {
96        return mState == STOPPING_1 || mState == STOPPING_2;
97    }
98    bool isStopping_1() const {
99        return mState == STOPPING_1;
100    }
101    bool isStopping_2() const {
102        return mState == STOPPING_2;
103    }
104
105    bool isTerminated() const {
106        return mState == TERMINATED;
107    }
108
109    bool step();    // mStepCount is an implicit input
110    void reset();
111
112    bool isOut() const { return mIsOut; }
113                                    // true for Track and TimedTrack, false for RecordTrack,
114                                    // this could be a track type if needed later
115
116    const wp<ThreadBase> mThread;
117    /*const*/ sp<Client> mClient;   // see explanation at ~TrackBase() why not const
118    sp<IMemory>         mCblkMemory;
119    audio_track_cblk_t* mCblk;
120    void*               mBuffer;    // start of track buffer, typically in shared memory
121                                    // except for OutputTrack when it is in local memory
122    void*               mBufferEnd; // &mBuffer[mFrameCount * frameSize], where frameSize
123                                    //   is based on mChannelCount and 16-bit samples
124    uint32_t            mStepCount; // saves AudioBufferProvider::Buffer::frameCount as of
125                                    // time of releaseBuffer() for later use by step()
126    // we don't really need a lock for these
127    track_state         mState;
128    const uint32_t      mSampleRate;    // initial sample rate only; for tracks which
129                        // support dynamic rates, the current value is in control block
130    const audio_format_t mFormat;
131    const audio_channel_mask_t mChannelMask;
132    const uint8_t       mChannelCount;
133    const size_t        mFrameSize; // AudioFlinger's view of frame size in shared memory,
134                                    // where for AudioTrack (but not AudioRecord),
135                                    // 8-bit PCM samples are stored as 16-bit
136    const size_t        mFrameCount;// size of track buffer given at createTrack() or
137                                    // openRecord(), and then adjusted as needed
138
139    bool                mStepServerFailed;
140    const int           mSessionId;
141    Vector < sp<SyncEvent> >mSyncEvents;
142    const bool          mIsOut;
143    ServerProxy*        mServerProxy;
144};
145