Merge "Removed unused class and its test" (faa72184) · Commits · e / os / android_frameworks_av

media/libstagefright/Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -100,7 +100,6 @@ cc_library_shared {
		"SkipCutBuffer.cpp",
		"StagefrightMediaScanner.cpp",
		"StagefrightMetadataRetriever.cpp",
		"SurfaceMediaSource.cpp",
		"SurfaceUtils.cpp",
		"Utils.cpp",
		"ThrottledSource.cpp",

media/libstagefright/SurfaceMediaSource.cpp

deleted100644 → 0

+0 −477

Original line number	Diff line number	Diff line
		/*
		* 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.
		*/
		//#define LOG_NDEBUG 0
		#define LOG_TAG "SurfaceMediaSource"

		#include <inttypes.h>

		#include <media/stagefright/foundation/ADebug.h>
		#include <media/stagefright/SurfaceMediaSource.h>
		#include <media/stagefright/MediaDefs.h>
		#include <media/stagefright/MetaData.h>
		#include <OMX_IVCommon.h>
		#include <media/hardware/HardwareAPI.h>
		#include <media/hardware/MetadataBufferType.h>

		#include <ui/GraphicBuffer.h>
		#include <gui/BufferItem.h>
		#include <gui/ISurfaceComposer.h>
		#include <OMX_Component.h>

		#include <utils/Log.h>
		#include <utils/String8.h>

		#include <private/gui/ComposerService.h>

		namespace android {

		SurfaceMediaSource::SurfaceMediaSource(uint32_t bufferWidth, uint32_t bufferHeight) :
		mWidth(bufferWidth),
		mHeight(bufferHeight),
		mCurrentSlot(BufferQueue::INVALID_BUFFER_SLOT),
		mNumPendingBuffers(0),
		mCurrentTimestamp(0),
		mFrameRate(30),
		mStarted(false),
		mNumFramesReceived(0),
		mNumFramesEncoded(0),
		mFirstFrameTimestamp(0),
		mMaxAcquiredBufferCount(4), // XXX double-check the default
		mUseAbsoluteTimestamps(false) {
		ALOGV("SurfaceMediaSource");

		if (bufferWidth == 0 \|\| bufferHeight == 0) {
		ALOGE("Invalid dimensions %dx%d", bufferWidth, bufferHeight);
		}

		BufferQueue::createBufferQueue(&mProducer, &mConsumer);
		mConsumer->setDefaultBufferSize(bufferWidth, bufferHeight);
		mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_VIDEO_ENCODER \|
		GRALLOC_USAGE_HW_TEXTURE);

		sp<ISurfaceComposer> composer(ComposerService::getComposerService());

		// Note that we can't create an sp<...>(this) in a ctor that will not keep a
		// reference once the ctor ends, as that would cause the refcount of 'this'
		// dropping to 0 at the end of the ctor. Since all we need is a wp<...>
		// that's what we create.
		wp<ConsumerListener> listener = static_cast<ConsumerListener*>(this);
		sp<BufferQueue::ProxyConsumerListener> proxy = new BufferQueue::ProxyConsumerListener(listener);

		status_t err = mConsumer->consumerConnect(proxy, false);
		if (err != NO_ERROR) {
		ALOGE("SurfaceMediaSource: error connecting to BufferQueue: %s (%d)",
		strerror(-err), err);
		}
		}

		SurfaceMediaSource::~SurfaceMediaSource() {
		ALOGV("~SurfaceMediaSource");
		CHECK(!mStarted);
		}

		nsecs_t SurfaceMediaSource::getTimestamp() {
		ALOGV("getTimestamp");
		Mutex::Autolock lock(mMutex);
		return mCurrentTimestamp;
		}

		void SurfaceMediaSource::setFrameAvailableListener(
		const sp<FrameAvailableListener>& listener) {
		ALOGV("setFrameAvailableListener");
		Mutex::Autolock lock(mMutex);
		mFrameAvailableListener = listener;
		}

		void SurfaceMediaSource::dumpState(String8& result) const
		{
		char buffer[1024];
		dumpState(result, "", buffer, 1024);
		}

		void SurfaceMediaSource::dumpState(
		String8& result,
		const char* /* prefix */,
		char* buffer,
		size_t /* SIZE */) const
		{
		Mutex::Autolock lock(mMutex);

		result.append(buffer);
		mConsumer->dumpState(result, "");
		}

		status_t SurfaceMediaSource::setFrameRate(int32_t fps)
		{
		ALOGV("setFrameRate");
		Mutex::Autolock lock(mMutex);
		const int MAX_FRAME_RATE = 60;
		if (fps < 0 \|\| fps > MAX_FRAME_RATE) {
		return BAD_VALUE;
		}
		mFrameRate = fps;
		return OK;
		}

		MetadataBufferType SurfaceMediaSource::metaDataStoredInVideoBuffers() const {
		ALOGV("isMetaDataStoredInVideoBuffers");
		return kMetadataBufferTypeANWBuffer;
		}

		int32_t SurfaceMediaSource::getFrameRate( ) const {
		ALOGV("getFrameRate");
		Mutex::Autolock lock(mMutex);
		return mFrameRate;
		}

		status_t SurfaceMediaSource::start(MetaData *params)
		{
		ALOGV("start");

		Mutex::Autolock lock(mMutex);

		CHECK(!mStarted);

		mStartTimeNs = 0;
		int64_t startTimeUs;
		int32_t bufferCount = 0;
		if (params) {
		if (params->findInt64(kKeyTime, &startTimeUs)) {
		mStartTimeNs = startTimeUs * 1000;
		}

		if (!params->findInt32(kKeyNumBuffers, &bufferCount)) {
		ALOGE("Failed to find the advertised buffer count");
		return UNKNOWN_ERROR;
		}

		if (bufferCount <= 1) {
		ALOGE("bufferCount %d is too small", bufferCount);
		return BAD_VALUE;
		}

		mMaxAcquiredBufferCount = bufferCount;
		}

		CHECK_GT(mMaxAcquiredBufferCount, 1u);

		status_t err =
		mConsumer->setMaxAcquiredBufferCount(mMaxAcquiredBufferCount);

		if (err != OK) {
		return err;
		}

		mNumPendingBuffers = 0;
		mStarted = true;

		return OK;
		}

		status_t SurfaceMediaSource::setMaxAcquiredBufferCount(size_t count) {
		ALOGV("setMaxAcquiredBufferCount(%zu)", count);
		Mutex::Autolock lock(mMutex);

		CHECK_GT(count, 1u);
		mMaxAcquiredBufferCount = count;

		return OK;
		}

		status_t SurfaceMediaSource::setUseAbsoluteTimestamps() {
		ALOGV("setUseAbsoluteTimestamps");
		Mutex::Autolock lock(mMutex);
		mUseAbsoluteTimestamps = true;

		return OK;
		}

		status_t SurfaceMediaSource::stop()
		{
		ALOGV("stop");
		Mutex::Autolock lock(mMutex);

		if (!mStarted) {
		return OK;
		}

		mStarted = false;
		mFrameAvailableCondition.signal();

		while (mNumPendingBuffers > 0) {
		ALOGI("Still waiting for %zu buffers to be returned.",
		mNumPendingBuffers);

		#if DEBUG_PENDING_BUFFERS
		for (size_t i = 0; i < mPendingBuffers.size(); ++i) {
		ALOGI("%d: %p", i, mPendingBuffers.itemAt(i));
		}
		#endif

		mMediaBuffersAvailableCondition.wait(mMutex);
		}

		mMediaBuffersAvailableCondition.signal();

		return mConsumer->consumerDisconnect();
		}

		sp<MetaData> SurfaceMediaSource::getFormat()
		{
		ALOGV("getFormat");

		Mutex::Autolock lock(mMutex);
		sp<MetaData> meta = new MetaData;

		meta->setInt32(kKeyWidth, mWidth);
		meta->setInt32(kKeyHeight, mHeight);
		// The encoder format is set as an opaque colorformat
		// The encoder will later find out the actual colorformat
		// from the GL Frames itself.
		meta->setInt32(kKeyColorFormat, OMX_COLOR_FormatAndroidOpaque);
		meta->setInt32(kKeyStride, mWidth);
		meta->setInt32(kKeySliceHeight, mHeight);
		meta->setInt32(kKeyFrameRate, mFrameRate);
		meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_RAW);
		return meta;
		}

		// Pass the data to the MediaBuffer. Pass in only the metadata
		// Note: Call only when you have the lock
		void SurfaceMediaSource::passMetadataBuffer_l(MediaBufferBase **buffer,
		ANativeWindowBuffer *bufferHandle) const {
		*buffer = new MediaBuffer(sizeof(VideoNativeMetadata));
		VideoNativeMetadata data = (VideoNativeMetadata )(*buffer)->data();
		if (data == NULL) {
		ALOGE("Cannot allocate memory for metadata buffer!");
		return;
		}
		data->eType = metaDataStoredInVideoBuffers();
		data->pBuffer = bufferHandle;
		data->nFenceFd = -1;
		ALOGV("handle = %p, offset = %zu, length = %zu",
		bufferHandle, (buffer)->range_length(), (buffer)->range_offset());
		}

		status_t SurfaceMediaSource::read(
		MediaBufferBase *buffer, const ReadOptions /* options */) {
		ALOGV("read");
		Mutex::Autolock lock(mMutex);

		*buffer = NULL;

		while (mStarted && mNumPendingBuffers == mMaxAcquiredBufferCount) {
		mMediaBuffersAvailableCondition.wait(mMutex);
		}

		// Update the current buffer info
		// TODO: mCurrentSlot can be made a bufferstate since there
		// can be more than one "current" slots.

		BufferItem item;
		// If the recording has started and the queue is empty, then just
		// wait here till the frames come in from the client side
		while (mStarted) {

		status_t err = mConsumer->acquireBuffer(&item, 0);
		if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
		// wait for a buffer to be queued
		mFrameAvailableCondition.wait(mMutex);
		} else if (err == OK) {
		err = item.mFence->waitForever("SurfaceMediaSource::read");
		if (err) {
		ALOGW("read: failed to wait for buffer fence: %d", err);
		}

		// First time seeing the buffer? Added it to the SMS slot
		if (item.mGraphicBuffer != NULL) {
		mSlots[item.mSlot].mGraphicBuffer = item.mGraphicBuffer;
		}
		mSlots[item.mSlot].mFrameNumber = item.mFrameNumber;

		// check for the timing of this buffer
		if (mNumFramesReceived == 0 && !mUseAbsoluteTimestamps) {
		mFirstFrameTimestamp = item.mTimestamp;
		// Initial delay
		if (mStartTimeNs > 0) {
		if (item.mTimestamp < mStartTimeNs) {
		// This frame predates start of record, discard
		mConsumer->releaseBuffer(
		item.mSlot, item.mFrameNumber, EGL_NO_DISPLAY,
		EGL_NO_SYNC_KHR, Fence::NO_FENCE);
		continue;
		}
		mStartTimeNs = item.mTimestamp - mStartTimeNs;
		}
		}
		item.mTimestamp = mStartTimeNs + (item.mTimestamp - mFirstFrameTimestamp);

		mNumFramesReceived++;

		break;
		} else {
		ALOGE("read: acquire failed with error code %d", err);
		return ERROR_END_OF_STREAM;
		}

		}

		// If the loop was exited as a result of stopping the recording,
		// it is OK
		if (!mStarted) {
		ALOGV("Read: SurfaceMediaSource is stopped. Returning ERROR_END_OF_STREAM.");
		return ERROR_END_OF_STREAM;
		}

		mCurrentSlot = item.mSlot;

		// First time seeing the buffer? Added it to the SMS slot
		if (item.mGraphicBuffer != NULL) {
		mSlots[item.mSlot].mGraphicBuffer = item.mGraphicBuffer;
		}
		mSlots[item.mSlot].mFrameNumber = item.mFrameNumber;

		mCurrentBuffers.push_back(mSlots[mCurrentSlot].mGraphicBuffer);
		int64_t prevTimeStamp = mCurrentTimestamp;
		mCurrentTimestamp = item.mTimestamp;

		mNumFramesEncoded++;
		// Pass the data to the MediaBuffer. Pass in only the metadata

		passMetadataBuffer_l(buffer, mSlots[mCurrentSlot].mGraphicBuffer->getNativeBuffer());

		(*buffer)->setObserver(this);
		(*buffer)->add_ref();
		(*buffer)->meta_data()->setInt64(kKeyTime, mCurrentTimestamp / 1000);
		ALOGV("Frames encoded = %d, timestamp = %" PRId64 ", time diff = %" PRId64,
		mNumFramesEncoded, mCurrentTimestamp / 1000,
		mCurrentTimestamp / 1000 - prevTimeStamp / 1000);

		++mNumPendingBuffers;

		#if DEBUG_PENDING_BUFFERS
		mPendingBuffers.push_back(*buffer);
		#endif

		ALOGV("returning mbuf %p", *buffer);

		return OK;
		}

		static buffer_handle_t getMediaBufferHandle(MediaBufferBase *buffer) {
		// need to convert to char* for pointer arithmetic and then
		// copy the byte stream into our handle
		buffer_handle_t bufferHandle;
		memcpy(&bufferHandle, (char*)(buffer->data()) + 4, sizeof(buffer_handle_t));
		return bufferHandle;
		}

		void SurfaceMediaSource::signalBufferReturned(MediaBufferBase *buffer) {
		ALOGV("signalBufferReturned");

		bool foundBuffer = false;

		Mutex::Autolock lock(mMutex);

		buffer_handle_t bufferHandle = getMediaBufferHandle(buffer);

		for (size_t i = 0; i < mCurrentBuffers.size(); i++) {
		if (mCurrentBuffers[i]->handle == bufferHandle) {
		mCurrentBuffers.removeAt(i);
		foundBuffer = true;
		break;
		}
		}

		if (!foundBuffer) {
		ALOGW("returned buffer was not found in the current buffer list");
		}

		for (int id = 0; id < BufferQueue::NUM_BUFFER_SLOTS; id++) {
		if (mSlots[id].mGraphicBuffer == NULL) {
		continue;
		}

		if (bufferHandle == mSlots[id].mGraphicBuffer->handle) {
		ALOGV("Slot %d returned, matches handle = %p", id,
		mSlots[id].mGraphicBuffer->handle);

		mConsumer->releaseBuffer(id, mSlots[id].mFrameNumber,
		EGL_NO_DISPLAY, EGL_NO_SYNC_KHR,
		Fence::NO_FENCE);

		buffer->setObserver(0);
		buffer->release();

		foundBuffer = true;
		break;
		}
		}

		if (!foundBuffer) {
		CHECK(!"signalBufferReturned: bogus buffer");
		}

		#if DEBUG_PENDING_BUFFERS
		for (size_t i = 0; i < mPendingBuffers.size(); ++i) {
		if (mPendingBuffers.itemAt(i) == buffer) {
		mPendingBuffers.removeAt(i);
		break;
		}
		}
		#endif

		--mNumPendingBuffers;
		mMediaBuffersAvailableCondition.broadcast();
		}

		// Part of the BufferQueue::ConsumerListener
		void SurfaceMediaSource::onFrameAvailable(const BufferItem& /* item */) {
		ALOGV("onFrameAvailable");

		sp<FrameAvailableListener> listener;
		{ // scope for the lock
		Mutex::Autolock lock(mMutex);
		mFrameAvailableCondition.broadcast();
		listener = mFrameAvailableListener;
		}

		if (listener != NULL) {
		ALOGV("actually calling onFrameAvailable");
		listener->onFrameAvailable();
		}
		}

		// SurfaceMediaSource hijacks this event to assume
		// the prodcuer is disconnecting from the BufferQueue
		// and that it should stop the recording
		void SurfaceMediaSource::onBuffersReleased() {
		ALOGV("onBuffersReleased");

		Mutex::Autolock lock(mMutex);

		mFrameAvailableCondition.signal();

		for (int i = 0; i < BufferQueue::NUM_BUFFER_SLOTS; i++) {
		mSlots[i].mGraphicBuffer = 0;
		}
		}

		void SurfaceMediaSource::onSidebandStreamChanged() {
		ALOG_ASSERT(false, "SurfaceMediaSource can't consume sideband streams");
		}

		} // end of namespace android

media/libstagefright/include/media/stagefright/SurfaceMediaSource.h

deleted100644 → 0

+0 −248

Original line number	Diff line number	Diff line
		/*
		* 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/IGraphicBufferProducer.h>
		#include <gui/BufferQueue.h>

		#include <utils/threads.h>
		#include <utils/Vector.h>
		#include <media/MediaSource.h>
		#include <media/stagefright/MediaBuffer.h>

		#include <media/hardware/MetadataBufferType.h>

		#include "foundation/ABase.h"

		namespace android {
		// ----------------------------------------------------------------------------

		class String8;
		class GraphicBuffer;

		// ASSUMPTIONS
		// 1. SurfaceMediaSource is initialized with width*height which
		// can never change. However, deqeueue buffer does not currently
		// enforce this as in BufferQueue, dequeue can be used by Surface
		// which can modify the default width and heght. Also neither the width
		// nor height can be 0.
		// 2. setSynchronousMode is never used (basically no one should call
		// setSynchronousMode(false)
		// 3. setCrop, setTransform, setScalingMode should never be used
		// 4. 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.
		// 5. Once disconnected, SurfaceMediaSource can be reused (can not
		// connect again)
		// 6. Stop is a hard stop, the last few frames held by the encoder
		// may be dropped. It is possible to wait for the buffers to be
		// returned (but not implemented)

		#define DEBUG_PENDING_BUFFERS 0

		class SurfaceMediaSource : public MediaSource,
		public MediaBufferObserver,
		protected ConsumerListener {
		public:
		enum { MIN_UNDEQUEUED_BUFFERS = 4};

		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 bufferWidth, uint32_t bufferHeight);

		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(MediaBufferBase **buffer,
		const ReadOptions *options = NULL);
		virtual sp<MetaData> getFormat();

		// 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(MediaBufferBase* buffer);
		// end of MediaSource interface

		// 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);

		// dump our state in a String
		void dumpState(String8& result) const;
		void dumpState(String8& result, const char* prefix, char* buffer,
		size_t SIZE) const;

		// metaDataStoredInVideoBuffers tells the encoder what kind of metadata
		// is passed through the buffers. Currently, it is set to ANWBuffer
		MetadataBufferType metaDataStoredInVideoBuffers() const;

		sp<IGraphicBufferProducer> getProducer() const { return mProducer; }

		// To be called before start()
		status_t setMaxAcquiredBufferCount(size_t count);

		// To be called before start()
		status_t setUseAbsoluteTimestamps();

		protected:

		// Implementation of the BufferQueue::ConsumerListener interface. These
		// calls are used to notify the Surface of asynchronous events in the
		// BufferQueue.
		virtual void onFrameAvailable(const BufferItem& item);

		// Used as a hook to BufferQueue::disconnect()
		// This is called by the client side when it is done
		// TODO: Currently, this also sets mStopped to true which
		// is needed for unblocking the encoder which might be
		// waiting to read more frames. So if on the client side,
		// the same thread supplies the frames and also calls stop
		// on the encoder, the client has to call disconnect before
		// it calls stop.
		// In the case of the camera,
		// that need not be required since the thread supplying the
		// frames is separate than the one calling stop.
		virtual void onBuffersReleased();

		// SurfaceMediaSource can't handle sideband streams, so this is not expected
		// to ever be called. Does nothing.
		virtual void onSidebandStreamChanged();

		static bool isExternalFormat(uint32_t format);

		private:
		// A BufferQueue, represented by these interfaces, is the exchange point
		// between the producer and this consumer
		sp<IGraphicBufferProducer> mProducer;
		sp<IGraphicBufferConsumer> mConsumer;

		struct SlotData {
		sp<GraphicBuffer> mGraphicBuffer;
		uint64_t mFrameNumber;
		};

		// mSlots caches GraphicBuffers and frameNumbers from the buffer queue
		SlotData mSlots[BufferQueue::NUM_BUFFER_SLOTS];

		// The permenent width and height of SMS buffers
		int mWidth;
		int mHeight;

		// 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 Surface).
		// 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;

		// mCurrentBuffers is a list of the graphic buffers that are being used by
		// buffer consumer (i.e. the video encoder). It's possible that these
		// buffers are not associated with any buffer slots, so we must track them
		// separately. Buffers are added to this list in read, and removed from
		// this list in signalBufferReturned
		Vector<sp<GraphicBuffer> > mCurrentBuffers;

		size_t mNumPendingBuffers;

		#if DEBUG_PENDING_BUFFERS
		Vector<MediaBuffer *> mPendingBuffers;
		#endif

		// mCurrentTimestamp is the timestamp for the current texture. It
		// gets set to mLastQueuedTimestamp each time updateTexImage is called.
		int64_t mCurrentTimestamp;

		// 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;

		// 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;

		// mStarted is a flag to check if the recording is going on
		bool mStarted;

		// 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;

		size_t mMaxAcquiredBufferCount;

		bool mUseAbsoluteTimestamps;

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

		Condition mMediaBuffersAvailableCondition;

		// Allocate and return a new MediaBuffer and pass the ANW buffer as metadata into it.
		void passMetadataBuffer_l(MediaBufferBase *buffer, ANativeWindowBuffer bufferHandle) const;

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

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

		#endif // ANDROID_GUI_SURFACEMEDIASOURCE_H