eclair snapshot (cc8c35ce) · Commits · e / os / platform_frameworks_native

camera/libcameraservice/Android.mk

+10 −1

Original line number	Diff line number	Diff line
		@@ -25,6 +25,10 @@ LOCAL_SRC_FILES:= \

		LOCAL_MODULE:= libcamerastub

		ifeq ($(TARGET_SIMULATOR),true)
		LOCAL_CFLAGS += -DSINGLE_PROCESS
		endif

		LOCAL_SHARED_LIBRARIES:= libui

		include $(BUILD_STATIC_LIBRARY)
		@@ -42,6 +46,7 @@ LOCAL_SRC_FILES:= \
		LOCAL_SHARED_LIBRARIES:= \
		libui \
		libutils \
		libbinder \
		libcutils \
		libmedia

		@@ -49,6 +54,10 @@ LOCAL_MODULE:= libcameraservice

		LOCAL_CFLAGS += -DLOG_TAG=\"CameraService\"

		ifeq ($(TARGET_SIMULATOR),true)
		LOCAL_CFLAGS += -DSINGLE_PROCESS
		endif

		ifeq ($(USE_CAMERA_STUB), true)
		LOCAL_STATIC_LIBRARIES += libcamerastub
		LOCAL_CFLAGS += -include CameraHardwareStub.h

camera/libcameraservice/CameraHardwareStub.cpp

+62 −49

Original line number	Diff line number	Diff line
		@@ -33,13 +33,11 @@ CameraHardwareStub::CameraHardwareStub()
		mRawHeap(0),
		mFakeCamera(0),
		mPreviewFrameSize(0),
		mRawPictureCallback(0),
		mJpegPictureCallback(0),
		mPictureCallbackCookie(0),
		mPreviewCallback(0),
		mPreviewCallbackCookie(0),
		mAutoFocusCallback(0),
		mAutoFocusCallbackCookie(0),
		mNotifyCb(0),
		mDataCb(0),
		mDataCbTimestamp(0),
		mCallbackCookie(0),
		mMsgEnabled(0),
		mCurrentPreviewFrame(0)
		{
		initDefaultParameters();
		@@ -112,6 +110,36 @@ sp<IMemoryHeap> CameraHardwareStub::getRawHeap() const
		return mRawHeap;
		}

		void CameraHardwareStub::setCallbacks(notify_callback notify_cb,
		data_callback data_cb,
		data_callback_timestamp data_cb_timestamp,
		void* user)
		{
		Mutex::Autolock lock(mLock);
		mNotifyCb = notify_cb;
		mDataCb = data_cb;
		mDataCbTimestamp = data_cb_timestamp;
		mCallbackCookie = user;
		}

		void CameraHardwareStub::enableMsgType(int32_t msgType)
		{
		Mutex::Autolock lock(mLock);
		mMsgEnabled \|= msgType;
		}

		void CameraHardwareStub::disableMsgType(int32_t msgType)
		{
		Mutex::Autolock lock(mLock);
		mMsgEnabled &= ~msgType;
		}

		bool CameraHardwareStub::msgTypeEnabled(int32_t msgType)
		{
		Mutex::Autolock lock(mLock);
		return (mMsgEnabled & msgType);
		}

		// ---------------------------------------------------------------------------

		int CameraHardwareStub::previewThread()
		@@ -150,7 +178,8 @@ int CameraHardwareStub::previewThread()
		//LOGV("previewThread: generated frame to buffer %d", mCurrentPreviewFrame);

		// Notify the client of a new frame.
		mPreviewCallback(buffer, mPreviewCallbackCookie);
		if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME)
		mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie);

		// Advance the buffer pointer.
		mCurrentPreviewFrame = (mCurrentPreviewFrame + 1) % kBufferCount;
		@@ -162,15 +191,13 @@ int CameraHardwareStub::previewThread()
		return NO_ERROR;
		}

		status_t CameraHardwareStub::startPreview(preview_callback cb, void* user)
		status_t CameraHardwareStub::startPreview()
		{
		Mutex::Autolock lock(mLock);
		if (mPreviewThread != 0) {
		// already running
		return INVALID_OPERATION;
		}
		mPreviewCallback = cb;
		mPreviewCallbackCookie = user;
		mPreviewThread = new PreviewThread(this);
		return NO_ERROR;
		}
		@@ -197,7 +224,7 @@ bool CameraHardwareStub::previewEnabled() {
		return mPreviewThread != 0;
		}

		status_t CameraHardwareStub::startRecording(recording_callback cb, void* user)
		status_t CameraHardwareStub::startRecording()
		{
		return UNKNOWN_ERROR;
		}
		@@ -225,30 +252,24 @@ int CameraHardwareStub::beginAutoFocusThread(void *cookie)

		int CameraHardwareStub::autoFocusThread()
		{
		if (mAutoFocusCallback != NULL) {
		mAutoFocusCallback(true, mAutoFocusCallbackCookie);
		mAutoFocusCallback = NULL;
		if (mMsgEnabled & CAMERA_MSG_FOCUS)
		mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
		return NO_ERROR;
		}
		return UNKNOWN_ERROR;
		}

		status_t CameraHardwareStub::autoFocus(autofocus_callback af_cb,
		void *user)
		status_t CameraHardwareStub::autoFocus()
		{
		Mutex::Autolock lock(mLock);

		if (mAutoFocusCallback != NULL) {
		return mAutoFocusCallback == af_cb ? NO_ERROR : INVALID_OPERATION;
		}

		mAutoFocusCallback = af_cb;
		mAutoFocusCallbackCookie = user;
		if (createThread(beginAutoFocusThread, this) == false)
		return UNKNOWN_ERROR;
		return NO_ERROR;
		}

		status_t CameraHardwareStub::cancelAutoFocus()
		{
		return NO_ERROR;
		}

		/static/ int CameraHardwareStub::beginPictureThread(void *cookie)
		{
		CameraHardwareStub c = (CameraHardwareStub )cookie;
		@@ -257,10 +278,10 @@ status_t CameraHardwareStub::autoFocus(autofocus_callback af_cb,

		int CameraHardwareStub::pictureThread()
		{
		if (mShutterCallback)
		mShutterCallback(mPictureCallbackCookie);
		if (mMsgEnabled & CAMERA_MSG_SHUTTER)
		mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie);

		if (mRawPictureCallback) {
		if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
		//FIXME: use a canned YUV image!
		// In the meantime just make another fake camera picture.
		int w, h;
		@@ -268,42 +289,28 @@ int CameraHardwareStub::pictureThread()
		sp<MemoryBase> mem = new MemoryBase(mRawHeap, 0, w * 2 * h);
		FakeCamera cam(w, h);
		cam.getNextFrameAsYuv422((uint8_t *)mRawHeap->base());
		if (mRawPictureCallback)
		mRawPictureCallback(mem, mPictureCallbackCookie);
		mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);
		}

		if (mJpegPictureCallback) {
		if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) {
		sp<MemoryHeapBase> heap = new MemoryHeapBase(kCannedJpegSize);
		sp<MemoryBase> mem = new MemoryBase(heap, 0, kCannedJpegSize);
		memcpy(heap->base(), kCannedJpeg, kCannedJpegSize);
		if (mJpegPictureCallback)
		mJpegPictureCallback(mem, mPictureCallbackCookie);
		mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
		}
		return NO_ERROR;
		}

		status_t CameraHardwareStub::takePicture(shutter_callback shutter_cb,
		raw_callback raw_cb,
		jpeg_callback jpeg_cb,
		void* user)
		status_t CameraHardwareStub::takePicture()
		{
		stopPreview();
		mShutterCallback = shutter_cb;
		mRawPictureCallback = raw_cb;
		mJpegPictureCallback = jpeg_cb;
		mPictureCallbackCookie = user;
		if (createThread(beginPictureThread, this) == false)
		return -1;
		return NO_ERROR;
		}

		status_t CameraHardwareStub::cancelPicture(bool cancel_shutter,
		bool cancel_raw,
		bool cancel_jpeg)
		status_t CameraHardwareStub::cancelPicture()
		{
		if (cancel_shutter) mShutterCallback = NULL;
		if (cancel_raw) mRawPictureCallback = NULL;
		if (cancel_jpeg) mJpegPictureCallback = NULL;
		return NO_ERROR;
		}

		@@ -361,6 +368,12 @@ CameraParameters CameraHardwareStub::getParameters() const
		return mParameters;
		}

		status_t CameraHardwareStub::sendCommand(int32_t command, int32_t arg1,
		int32_t arg2)
		{
		return BAD_VALUE;
		}

		void CameraHardwareStub::release()
		{
		}

camera/libcameraservice/CameraHardwareStub.h

+34 −23

Original line number	Diff line number	Diff line
		@@ -21,8 +21,8 @@
		#include "FakeCamera.h"
		#include <utils/threads.h>
		#include <ui/CameraHardwareInterface.h>
		#include <utils/MemoryBase.h>
		#include <utils/MemoryHeapBase.h>
		#include <binder/MemoryBase.h>
		#include <binder/MemoryHeapBase.h>
		#include <utils/threads.h>

		namespace android {
		@@ -32,26 +32,33 @@ public:
		virtual sp<IMemoryHeap> getPreviewHeap() const;
		virtual sp<IMemoryHeap> getRawHeap() const;

		virtual status_t startPreview(preview_callback cb, void* user);
		virtual void setCallbacks(notify_callback notify_cb,
		data_callback data_cb,
		data_callback_timestamp data_cb_timestamp,
		void* user);

		virtual void enableMsgType(int32_t msgType);
		virtual void disableMsgType(int32_t msgType);
		virtual bool msgTypeEnabled(int32_t msgType);

		virtual status_t startPreview();
		virtual void stopPreview();
		virtual bool previewEnabled();

		virtual status_t startRecording(recording_callback cb, void* user);
		virtual status_t startRecording();
		virtual void stopRecording();
		virtual bool recordingEnabled();
		virtual void releaseRecordingFrame(const sp<IMemory>& mem);

		virtual status_t autoFocus(autofocus_callback, void *user);
		virtual status_t takePicture(shutter_callback,
		raw_callback,
		jpeg_callback,
		void* user);
		virtual status_t cancelPicture(bool cancel_shutter,
		bool cancel_raw,
		bool cancel_jpeg);
		virtual status_t autoFocus();
		virtual status_t cancelAutoFocus();
		virtual status_t takePicture();
		virtual status_t cancelPicture();
		virtual status_t dump(int fd, const Vector<String16>& args) const;
		virtual status_t setParameters(const CameraParameters& params);
		virtual CameraParameters getParameters() const;
		virtual status_t sendCommand(int32_t command, int32_t arg1,
		int32_t arg2);
		virtual void release();

		static sp<CameraHardwareInterface> createInstance();
		@@ -67,8 +74,15 @@ private:
		class PreviewThread : public Thread {
		CameraHardwareStub* mHardware;
		public:
		PreviewThread(CameraHardwareStub* hw)
		: Thread(false), mHardware(hw) { }
		PreviewThread(CameraHardwareStub* hw) :
		#ifdef SINGLE_PROCESS
		// In single process mode this thread needs to be a java thread,
		// since we won't be calling through the binder.
		Thread(true),
		#else
		Thread(false),
		#endif
		mHardware(hw) { }
		virtual void onFirstRef() {
		run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY);
		}
		@@ -102,18 +116,15 @@ private:
		bool mPreviewRunning;
		int mPreviewFrameSize;

		shutter_callback mShutterCallback;
		raw_callback mRawPictureCallback;
		jpeg_callback mJpegPictureCallback;
		void *mPictureCallbackCookie;

		// protected by mLock
		sp<PreviewThread> mPreviewThread;
		preview_callback mPreviewCallback;
		void *mPreviewCallbackCookie;

		autofocus_callback mAutoFocusCallback;
		void *mAutoFocusCallbackCookie;
		notify_callback mNotifyCb;
		data_callback mDataCb;
		data_callback_timestamp mDataCbTimestamp;
		void *mCallbackCookie;

		int32_t mMsgEnabled;

		// only used from PreviewThread
		int mCurrentPreviewFrame;