merge from eclair (daeaa536) · Commits · e / os / android_frameworks_native-old

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;

camera/libcameraservice/CameraService.cpp

+392 −269

File changed.

Preview size limit exceeded, changes collapsed.

camera/libcameraservice/CameraService.h

+27 −17

Original line number	Diff line number	Diff line
		@@ -23,10 +23,9 @@
		#include <ui/CameraHardwareInterface.h>
		#include <ui/Camera.h>

		class android::MemoryHeapBase;

		namespace android {

		class MemoryHeapBase;
		class MediaPlayer;

		// ----------------------------------------------------------------------------
		@@ -110,6 +109,9 @@ private:
		// auto focus
		virtual status_t autoFocus();

		// cancel auto focus
		virtual status_t cancelAutoFocus();

		// take a picture - returns an IMemory (ref-counted mmap)
		virtual status_t takePicture();

		@@ -119,6 +121,9 @@ private:
		// get preview/capture parameters - key/value pairs
		virtual String8 getParameters() const;

		// send command to camera driver
		virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);

		// our client...
		const sp<ICameraClient>& getCameraClient() const { return mCameraClient; }

		@@ -132,22 +137,21 @@ private:

		status_t checkPid();

		static void recordingCallback(nsecs_t timestamp, const sp<IMemory>& mem, void* user);
		static void previewCallback(const sp<IMemory>& mem, void* user);
		static void shutterCallback(void *user);
		static void yuvPictureCallback(const sp<IMemory>& mem, void* user);
		static void jpegPictureCallback(const sp<IMemory>& mem, void* user);
		static void autoFocusCallback(bool focused, void* user);
		static void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user);
		static void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, void* user);
		static void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType,
		const sp<IMemory>& dataPtr, void* user);

		static sp<Client> getClientFromCookie(void* user);

		void postShutter();
		void postRaw(const sp<IMemory>& mem);
		void postJpeg(const sp<IMemory>& mem);
		void postPreviewFrame(const sp<IMemory>& mem);
		void postRecordingFrame(nsecs_t timestamp, const sp<IMemory>& frame);
		void copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, size_t offset, size_t size);
		void postError(status_t error);
		void postAutoFocus(bool focused);
		void handlePreviewData(const sp<IMemory>&);
		void handleShutter(image_rect_type *image);
		void handlePostview(const sp<IMemory>&);
		void handleRawPicture(const sp<IMemory>&);
		void handleCompressedPicture(const sp<IMemory>&);

		void copyFrameAndPostCopiedFrame(const sp<ICameraClient>& client,
		const sp<IMemoryHeap>& heap, size_t offset, size_t size);

		// camera operation mode
		enum camera_mode {
		@@ -177,7 +181,6 @@ private:
		mutable Condition mReady;
		sp<CameraService> mCameraService;
		sp<ISurface> mSurface;
		sp<MemoryHeapBase> mPreviewBuffer;
		int mPreviewCallbackFlag;

		sp<MediaPlayer> mMediaPlayerClick;
		@@ -189,6 +192,13 @@ private:
		sp<CameraHardwareInterface> mHardware;
		pid_t mClientPid;
		bool mUseOverlay;

		sp<OverlayRef> mOverlayRef;
		int mOverlayW;
		int mOverlayH;

		mutable Mutex mPreviewLock;
		sp<MemoryHeapBase> mPreviewBuffer;
		};

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