include/media/stagefright/SurfaceMediaSource.h - platform/frameworks/base - Git at Google

 /*
  * 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 = 4 };
     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() { return reset(); }
     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;

     // mFirstFrameTimestamp is the timestamp of the first received frame.
     // It is used to offset the output timestamps so recording starts at time 0.
     int64_t mFirstFrameTimestamp;
     // mStartTimeNs is the start time passed into the source at start, used to
     // offset timestamps.
     int64_t mStartTimeNs;

     // mFrameAvailableCondition condition used to indicate whether there
     // is a frame available for dequeuing
     Condition mFrameAvailableCondition;
     Condition mFrameCompleteCondition;

     status_t reset();

     // Avoid copying and equating and default constructor
     DISALLOW_IMPLICIT_CONSTRUCTORS(SurfaceMediaSource);
 };

 // ----------------------------------------------------------------------------
 }; // namespace android

 #endif // ANDROID_GUI_SURFACEMEDIASOURCE_H
	/*
	* 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 = 4 };
	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() { return reset(); }
	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;

	// mFirstFrameTimestamp is the timestamp of the first received frame.
	// It is used to offset the output timestamps so recording starts at time 0.
	int64_t mFirstFrameTimestamp;
	// mStartTimeNs is the start time passed into the source at start, used to
	// offset timestamps.
	int64_t mStartTimeNs;

	// mFrameAvailableCondition condition used to indicate whether there
	// is a frame available for dequeuing
	Condition mFrameAvailableCondition;
	Condition mFrameCompleteCondition;

	status_t reset();

	// Avoid copying and equating and default constructor
	DISALLOW_IMPLICIT_CONSTRUCTORS(SurfaceMediaSource);
	};

	// ----------------------------------------------------------------------------
	}; // namespace android

	#endif // ANDROID_GUI_SURFACEMEDIASOURCE_H