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        ALLOC_LOCAL,    // allocate a local buffer
48        ALLOC_NONE,     // do not allocate:use the buffer passed to TrackBase constructor
49    };
50
51    enum track_type {
52        TYPE_DEFAULT,
53        TYPE_OUTPUT,
54        TYPE_PATCH,
55    };
56
57                        TrackBase(ThreadBase *thread,
58                                const sp<Client>& client,
59                                uint32_t sampleRate,
60                                audio_format_t format,
61                                audio_channel_mask_t channelMask,
62                                size_t frameCount,
63                                void *buffer,
64                                audio_session_t sessionId,
65                                uid_t uid,
66                                bool isOut,
67                                alloc_type alloc = ALLOC_CBLK,
68                                track_type type = TYPE_DEFAULT,
69                                audio_port_handle_t portId = AUDIO_PORT_HANDLE_NONE);
70    virtual             ~TrackBase();
71    virtual status_t    initCheck() const;
72
73    virtual status_t    start(AudioSystem::sync_event_t event,
74                             audio_session_t triggerSession) = 0;
75    virtual void        stop() = 0;
76            sp<IMemory> getCblk() const { return mCblkMemory; }
77            audio_track_cblk_t* cblk() const { return mCblk; }
78            audio_session_t sessionId() const { return mSessionId; }
79            uid_t       uid() const { return mUid; }
80            audio_port_handle_t portId() const { return mPortId; }
81    virtual status_t    setSyncEvent(const sp<SyncEvent>& event);
82
83            sp<IMemory> getBuffers() const { return mBufferMemory; }
84            void*       buffer() const { return mBuffer; }
85    virtual bool        isFastTrack() const = 0;
86            bool        isOutputTrack() const { return (mType == TYPE_OUTPUT); }
87            bool        isPatchTrack() const { return (mType == TYPE_PATCH); }
88            bool        isExternalTrack() const { return !isOutputTrack() && !isPatchTrack(); }
89
90    virtual void        invalidate() { mIsInvalid = true; }
91            bool        isInvalid() const { return mIsInvalid; }
92
93
94protected:
95                        TrackBase(const TrackBase&);
96                        TrackBase& operator = (const TrackBase&);
97
98    // AudioBufferProvider interface
99    virtual status_t getNextBuffer(AudioBufferProvider::Buffer* buffer) = 0;
100    virtual void releaseBuffer(AudioBufferProvider::Buffer* buffer);
101
102    // ExtendedAudioBufferProvider interface is only needed for Track,
103    // but putting it in TrackBase avoids the complexity of virtual inheritance
104    virtual size_t  framesReady() const { return SIZE_MAX; }
105
106    audio_format_t format() const { return mFormat; }
107
108    uint32_t channelCount() const { return mChannelCount; }
109
110    audio_channel_mask_t channelMask() const { return mChannelMask; }
111
112    virtual uint32_t sampleRate() const { return mSampleRate; }
113
114    bool isStopped() const {
115        return (mState == STOPPED || mState == FLUSHED);
116    }
117
118    // for fast tracks and offloaded tracks only
119    bool isStopping() const {
120        return mState == STOPPING_1 || mState == STOPPING_2;
121    }
122    bool isStopping_1() const {
123        return mState == STOPPING_1;
124    }
125    bool isStopping_2() const {
126        return mState == STOPPING_2;
127    }
128
129    bool isTerminated() const {
130        return mTerminated;
131    }
132
133    void terminate() {
134        mTerminated = true;
135    }
136
137    bool isOut() const { return mIsOut; }
138                                    // true for Track, false for RecordTrack,
139                                    // this could be a track type if needed later
140
141    const wp<ThreadBase> mThread;
142    /*const*/ sp<Client> mClient;   // see explanation at ~TrackBase() why not const
143    sp<IMemory>         mCblkMemory;
144    audio_track_cblk_t* mCblk;
145    sp<IMemory>         mBufferMemory;  // currently non-0 for fast RecordTrack only
146    void*               mBuffer;    // start of track buffer, typically in shared memory
147                                    // except for OutputTrack when it is in local memory
148    // we don't really need a lock for these
149    track_state         mState;
150    const uint32_t      mSampleRate;    // initial sample rate only; for tracks which
151                        // support dynamic rates, the current value is in control block
152    const audio_format_t mFormat;
153    const audio_channel_mask_t mChannelMask;
154    const uint32_t      mChannelCount;
155    const size_t        mFrameSize; // AudioFlinger's view of frame size in shared memory,
156                                    // where for AudioTrack (but not AudioRecord),
157                                    // 8-bit PCM samples are stored as 16-bit
158    const size_t        mFrameCount;// size of track buffer given at createTrack() or
159                                    // openRecord(), and then adjusted as needed
160
161    const audio_session_t mSessionId;
162    uid_t               mUid;
163    Vector < sp<SyncEvent> >mSyncEvents;
164    const bool          mIsOut;
165    sp<ServerProxy>     mServerProxy;
166    const int           mId;
167    sp<NBAIO_Sink>      mTeeSink;
168    sp<NBAIO_Source>    mTeeSource;
169    bool                mTerminated;
170    track_type          mType;      // must be one of TYPE_DEFAULT, TYPE_OUTPUT, TYPE_PATCH ...
171    audio_io_handle_t   mThreadIoHandle; // I/O handle of the thread the track is attached to
172    audio_port_handle_t mPortId; // unique ID for this track used by audio policy
173    bool                mIsInvalid; // non-resettable latch, set by invalidate()
174};
175
176// PatchProxyBufferProvider interface is implemented by PatchTrack and PatchRecord.
177// it provides buffer access methods that map those of a ClientProxy (see AudioTrackShared.h)
178class PatchProxyBufferProvider
179{
180public:
181
182    virtual ~PatchProxyBufferProvider() {}
183
184    virtual status_t    obtainBuffer(Proxy::Buffer* buffer,
185                                     const struct timespec *requested = NULL) = 0;
186    virtual void        releaseBuffer(Proxy::Buffer* buffer) = 0;
187};
188