TrackBase.h revision c263ca0ad8b6bdf5b0693996bc5f2f5916e0cd49 
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        FLUSHED,
29        STOPPED,
30        // next 2 states are currently used for fast tracks
31        // and offloaded 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        STARTING_1,     // for RecordTrack only
39        STARTING_2,     // for RecordTrack only
40    };
41
42    // where to allocate the data buffer
43    enum alloc_type {
44        ALLOC_CBLK,     // allocate immediately after control block
45        ALLOC_READONLY, // allocate from a separate read-only heap per thread
46        ALLOC_PIPE,     // do not allocate; use the pipe buffer
47    };
48
49                        TrackBase(ThreadBase *thread,
50                                const sp<Client>& client,
51                                uint32_t sampleRate,
52                                audio_format_t format,
53                                audio_channel_mask_t channelMask,
54                                size_t frameCount,
55                                const sp<IMemory>& sharedBuffer,
56                                int sessionId,
57                                int uid,
58                                IAudioFlinger::track_flags_t flags,
59                                bool isOut,
60                                alloc_type alloc = ALLOC_CBLK);
61    virtual             ~TrackBase();
62    virtual status_t    initCheck() const { return getCblk() != 0 ? NO_ERROR : NO_MEMORY; }
63
64    virtual status_t    start(AudioSystem::sync_event_t event,
65                             int triggerSession) = 0;
66    virtual void        stop() = 0;
67            sp<IMemory> getCblk() const { return mCblkMemory; }
68            audio_track_cblk_t* cblk() const { return mCblk; }
69            int         sessionId() const { return mSessionId; }
70            int         uid() const { return mUid; }
71    virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
72
73            sp<IMemory> getBuffers() const { return mBufferMemory; }
74            bool        isFastTrack() const { return (mFlags & IAudioFlinger::TRACK_FAST) != 0; }
75
76protected:
77                        TrackBase(const TrackBase&);
78                        TrackBase& operator = (const TrackBase&);
79
80    // AudioBufferProvider interface
81    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer, int64_t pts) = 0;
82    virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
83
84    // ExtendedAudioBufferProvider interface is only needed for Track,
85    // but putting it in TrackBase avoids the complexity of virtual inheritance
86    virtual size_t  framesReady() const { return SIZE_MAX; }
87
88    audio_format_t format() const { return mFormat; }
89
90    uint32_t channelCount() const { return mChannelCount; }
91
92    audio_channel_mask_t channelMask() const { return mChannelMask; }
93
94    virtual uint32_t sampleRate() const { return mSampleRate; }
95
96    bool isStopped() const {
97        return (mState == STOPPED || mState == FLUSHED);
98    }
99
100    // for fast tracks and offloaded tracks only
101    bool isStopping() const {
102        return mState == STOPPING_1 || mState == STOPPING_2;
103    }
104    bool isStopping_1() const {
105        return mState == STOPPING_1;
106    }
107    bool isStopping_2() const {
108        return mState == STOPPING_2;
109    }
110
111    bool isTerminated() const {
112        return mTerminated;
113    }
114
115    void terminate() {
116        mTerminated = true;
117    }
118
119    bool isOut() const { return mIsOut; }
120                                    // true for Track and TimedTrack, false for RecordTrack,
121                                    // this could be a track type if needed later
122
123    const wp<ThreadBase> mThread;
124    /*const*/ sp<Client> mClient;   // see explanation at ~TrackBase() why not const
125    sp<IMemory>         mCblkMemory;
126    audio_track_cblk_t* mCblk;
127    sp<IMemory>         mBufferMemory;  // currently non-0 for fast RecordTrack only
128    void*               mBuffer;    // start of track buffer, typically in shared memory
129                                    // except for OutputTrack when it is in local memory
130    // we don't really need a lock for these
131    track_state         mState;
132    const uint32_t      mSampleRate;    // initial sample rate only; for tracks which
133                        // support dynamic rates, the current value is in control block
134    const audio_format_t mFormat;
135    const audio_channel_mask_t mChannelMask;
136    const uint32_t      mChannelCount;
137    const size_t        mFrameSize; // AudioFlinger's view of frame size in shared memory,
138                                    // where for AudioTrack (but not AudioRecord),
139                                    // 8-bit PCM samples are stored as 16-bit
140    const size_t        mFrameCount;// size of track buffer given at createTrack() or
141                                    // openRecord(), and then adjusted as needed
142
143    const int           mSessionId;
144    int                 mUid;
145    Vector < sp<SyncEvent> >mSyncEvents;
146    const IAudioFlinger::track_flags_t mFlags;
147    const bool          mIsOut;
148    ServerProxy*        mServerProxy;
149    const int           mId;
150    sp<NBAIO_Sink>      mTeeSink;
151    sp<NBAIO_Source>    mTeeSource;
152    bool                mTerminated;
153};
154