1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
|
/*
* Copyright (C) 2011 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_GUI_SURFACEMEDIASOURCE_H
#define ANDROID_GUI_SURFACEMEDIASOURCE_H
#include <gui/ISurfaceTexture.h>
#include <utils/threads.h>
#include <utils/Vector.h>
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/MediaBuffer.h>
namespace android {
// ----------------------------------------------------------------------------
class IGraphicBufferAlloc;
class String8;
class GraphicBuffer;
class SurfaceMediaSource : public BnSurfaceTexture, public MediaSource,
public MediaBufferObserver {
public:
enum { MIN_UNDEQUEUED_BUFFERS = 3 };
enum {
MIN_ASYNC_BUFFER_SLOTS = MIN_UNDEQUEUED_BUFFERS + 1,
MIN_SYNC_BUFFER_SLOTS = MIN_UNDEQUEUED_BUFFERS
};
enum { NUM_BUFFER_SLOTS = 32 };
enum { NO_CONNECTED_API = 0 };
struct FrameAvailableListener : public virtual RefBase {
// onFrameAvailable() is called from queueBuffer() is the FIFO is
// empty. You can use SurfaceMediaSource::getQueuedCount() to
// figure out if there are more frames waiting.
// This is called without any lock held can be called concurrently by
// multiple threads.
virtual void onFrameAvailable() = 0;
};
SurfaceMediaSource(uint32_t bufW, uint32_t bufH);
virtual ~SurfaceMediaSource();
// For the MediaSource interface for use by StageFrightRecorder:
virtual status_t start(MetaData *params = NULL);
virtual status_t stop();
virtual status_t read(
MediaBuffer **buffer, const ReadOptions *options = NULL);
virtual sp<MetaData> getFormat();
// Pass the metadata over to the buffer, call when you have the lock
void passMetadataBufferLocked(MediaBuffer **buffer);
bool checkBufferMatchesSlot(int slot, MediaBuffer *buffer);
// Get / Set the frame rate used for encoding. Default fps = 30
status_t setFrameRate(int32_t fps) ;
int32_t getFrameRate( ) const;
// The call for the StageFrightRecorder to tell us that
// it is done using the MediaBuffer data so that its state
// can be set to FREE for dequeuing
virtual void signalBufferReturned(MediaBuffer* buffer);
// end of MediaSource interface
uint32_t getBufferCount( ) const { return mBufferCount;}
// setBufferCount updates the number of available buffer slots. After
// calling this all buffer slots are both unallocated and owned by the
// SurfaceMediaSource object (i.e. they are not owned by the client).
virtual status_t setBufferCount(int bufferCount);
virtual status_t requestBuffer(int slot, sp<GraphicBuffer>* buf);
// dequeueBuffer gets the next buffer slot index for the client to use. If a
// buffer slot is available then that slot index is written to the location
// pointed to by the buf argument and a status of OK is returned. If no
// slot is available then a status of -EBUSY is returned and buf is
// unmodified.
virtual status_t dequeueBuffer(int *buf, uint32_t w, uint32_t h,
uint32_t format, uint32_t usage);
// queueBuffer returns a filled buffer to the SurfaceMediaSource. In addition, a
// timestamp must be provided for the buffer. The timestamp is in
// nanoseconds, and must be monotonically increasing. Its other semantics
// (zero point, etc) are client-dependent and should be documented by the
// client.
virtual status_t queueBuffer(int buf, int64_t timestamp,
uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform);
virtual void cancelBuffer(int buf);
// onFrameReceivedLocked informs the buffer consumers (StageFrightRecorder)
// or listeners that a frame has been received
// The buffer is not made available for dequeueing immediately. We need to
// wait to hear from StageFrightRecorder to set the buffer FREE
// Make sure this is called when the mutex is locked
virtual status_t onFrameReceivedLocked();
virtual status_t setScalingMode(int mode) { } // no op for encoding
virtual int query(int what, int* value);
// Just confirming to the ISurfaceTexture interface as of now
virtual status_t setCrop(const Rect& reg) { return OK; }
virtual status_t setTransform(uint32_t transform) {return OK;}
// setSynchronousMode set whether dequeueBuffer is synchronous or
// asynchronous. In synchronous mode, dequeueBuffer blocks until
// a buffer is available, the currently bound buffer can be dequeued and
// queued buffers will be retired in order.
// The default mode is synchronous.
// TODO: Clarify the minute differences bet sycn /async
// modes (S.Encoder vis-a-vis SurfaceTexture)
virtual status_t setSynchronousMode(bool enabled);
// connect attempts to connect a client API to the SurfaceMediaSource. This
// must be called before any other ISurfaceTexture methods are called except
// for getAllocator.
//
// This method will fail if the connect was previously called on the
// SurfaceMediaSource and no corresponding disconnect call was made.
virtual status_t connect(int api,
uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform);
// disconnect attempts to disconnect a client API from the SurfaceMediaSource.
// Calling this method will cause any subsequent calls to other
// ISurfaceTexture methods to fail except for getAllocator and connect.
// Successfully calling connect after this will allow the other methods to
// succeed again.
//
// This method will fail if the the SurfaceMediaSource is not currently
// connected to the specified client API.
virtual status_t disconnect(int api);
// getqueuedCount returns the number of queued frames waiting in the
// FIFO. In asynchronous mode, this always returns 0 or 1 since
// frames are not accumulating in the FIFO.
size_t getQueuedCount() const;
// setBufferCountServer set the buffer count. If the client has requested
// a buffer count using setBufferCount, the server-buffer count will
// take effect once the client sets the count back to zero.
status_t setBufferCountServer(int bufferCount);
// getTimestamp retrieves the timestamp associated with the image
// set by the most recent call to read()
//
// The timestamp is in nanoseconds, and is monotonically increasing. Its
// other semantics (zero point, etc) are source-dependent and should be
// documented by the source.
int64_t getTimestamp();
// setFrameAvailableListener sets the listener object that will be notified
// when a new frame becomes available.
void setFrameAvailableListener(const sp<FrameAvailableListener>& listener);
// getCurrentBuffer returns the buffer associated with the current image.
sp<GraphicBuffer> getCurrentBuffer() const;
// dump our state in a String
void dump(String8& result) const;
void dump(String8& result, const char* prefix, char* buffer,
size_t SIZE) const;
// isMetaDataStoredInVideoBuffers tells the encoder whether we will
// pass metadata through the buffers. Currently, it is force set to true
bool isMetaDataStoredInVideoBuffers() const;
protected:
// freeAllBuffersLocked frees the resources (both GraphicBuffer and EGLImage) for
// all slots.
void freeAllBuffersLocked();
static bool isExternalFormat(uint32_t format);
private:
status_t setBufferCountServerLocked(int bufferCount);
enum { INVALID_BUFFER_SLOT = -1 };
struct BufferSlot {
BufferSlot()
: mBufferState(BufferSlot::FREE),
mRequestBufferCalled(false),
mTimestamp(0) {
}
// mGraphicBuffer points to the buffer allocated for this slot or is
// NULL if no buffer has been allocated.
sp<GraphicBuffer> mGraphicBuffer;
// BufferState represents the different states in which a buffer slot
// can be.
enum BufferState {
// FREE indicates that the buffer is not currently being used and
// will not be used in the future until it gets dequeued and
// subseqently queued by the client.
FREE = 0,
// DEQUEUED indicates that the buffer has been dequeued by the
// client, but has not yet been queued or canceled. The buffer is
// considered 'owned' by the client, and the server should not use
// it for anything.
//
// Note that when in synchronous-mode (mSynchronousMode == true),
// the buffer that's currently attached to the texture may be
// dequeued by the client. That means that the current buffer can
// be in either the DEQUEUED or QUEUED state. In asynchronous mode,
// however, the current buffer is always in the QUEUED state.
DEQUEUED = 1,
// QUEUED indicates that the buffer has been queued by the client,
// and has not since been made available for the client to dequeue.
// Attaching the buffer to the texture does NOT transition the
// buffer away from the QUEUED state. However, in Synchronous mode
// the current buffer may be dequeued by the client under some
// circumstances. See the note about the current buffer in the
// documentation for DEQUEUED.
QUEUED = 2,
};
// mBufferState is the current state of this buffer slot.
BufferState mBufferState;
// mRequestBufferCalled is used for validating that the client did
// call requestBuffer() when told to do so. Technically this is not
// needed but useful for debugging and catching client bugs.
bool mRequestBufferCalled;
// mTimestamp is the current timestamp for this buffer slot. This gets
// to set by queueBuffer each time this slot is queued.
int64_t mTimestamp;
};
// mSlots is the array of buffer slots that must be mirrored on the client
// side. This allows buffer ownership to be transferred between the client
// and server without sending a GraphicBuffer over binder. The entire array
// is initialized to NULL at construction time, and buffers are allocated
// for a slot when requestBuffer is called with that slot's index.
BufferSlot mSlots[NUM_BUFFER_SLOTS];
// mDefaultWidth holds the default width of allocated buffers. It is used
// in requestBuffers() if a width and height of zero is specified.
uint32_t mDefaultWidth;
// mDefaultHeight holds the default height of allocated buffers. It is used
// in requestBuffers() if a width and height of zero is specified.
uint32_t mDefaultHeight;
// mPixelFormat holds the pixel format of allocated buffers. It is used
// in requestBuffers() if a format of zero is specified.
uint32_t mPixelFormat;
// mBufferCount is the number of buffer slots that the client and server
// must maintain. It defaults to MIN_ASYNC_BUFFER_SLOTS and can be changed
// by calling setBufferCount or setBufferCountServer
int mBufferCount;
// mClientBufferCount is the number of buffer slots requested by the
// client. The default is zero, which means the client doesn't care how
// many buffers there are
int mClientBufferCount;
// mServerBufferCount buffer count requested by the server-side
int mServerBufferCount;
// mCurrentSlot is the buffer slot index of the buffer that is currently
// being used by buffer consumer
// (e.g. StageFrightRecorder in the case of SurfaceMediaSource or GLTexture
// in the case of SurfaceTexture).
// It is initialized to INVALID_BUFFER_SLOT,
// indicating that no buffer slot is currently bound to the texture. Note,
// however, that a value of INVALID_BUFFER_SLOT does not necessarily mean
// that no buffer is bound to the texture. A call to setBufferCount will
// reset mCurrentTexture to INVALID_BUFFER_SLOT.
int mCurrentSlot;
// mCurrentBuf is the graphic buffer of the current slot to be used by
// buffer consumer. It's possible that this buffer is not associated
// with any buffer slot, so we must track it separately in order to
// properly use IGraphicBufferAlloc::freeAllGraphicBuffersExcept.
sp<GraphicBuffer> mCurrentBuf;
// mCurrentTimestamp is the timestamp for the current texture. It
// gets set to mLastQueuedTimestamp each time updateTexImage is called.
int64_t mCurrentTimestamp;
// mGraphicBufferAlloc is the connection to SurfaceFlinger that is used to
// allocate new GraphicBuffer objects.
sp<IGraphicBufferAlloc> mGraphicBufferAlloc;
// mFrameAvailableListener is the listener object that will be called when a
// new frame becomes available. If it is not NULL it will be called from
// queueBuffer.
sp<FrameAvailableListener> mFrameAvailableListener;
// mSynchronousMode whether we're in synchronous mode or not
bool mSynchronousMode;
// mConnectedApi indicates the API that is currently connected to this
// SurfaceTexture. It defaults to NO_CONNECTED_API (= 0), and gets updated
// by the connect and disconnect methods.
int mConnectedApi;
// mDequeueCondition condition used for dequeueBuffer in synchronous mode
mutable Condition mDequeueCondition;
// mQueue is a FIFO of queued buffers used in synchronous mode
typedef Vector<int> Fifo;
Fifo mQueue;
// mMutex is the mutex used to prevent concurrent access to the member
// variables of SurfaceMediaSource objects. It must be locked whenever the
// member variables are accessed.
mutable Mutex mMutex;
////////////////////////// For MediaSource
// Set to a default of 30 fps if not specified by the client side
int32_t mFrameRate;
// mStopped is a flag to check if the recording is going on
bool mStopped;
// mNumFramesReceived indicates the number of frames recieved from
// the client side
int mNumFramesReceived;
// mNumFramesEncoded indicates the number of frames passed on to the
// encoder
int mNumFramesEncoded;
// mFrameAvailableCondition condition used to indicate whether there
// is a frame available for dequeuing
Condition mFrameAvailableCondition;
Condition mFrameCompleteCondition;
// Avoid copying and equating and default constructor
DISALLOW_IMPLICIT_CONSTRUCTORS(SurfaceMediaSource);
};
// ----------------------------------------------------------------------------
}; // namespace android
#endif // ANDROID_GUI_SURFACEMEDIASOURCE_H
|