Modified the camera HAL interface to use the same generic callback architecture as camera services (4c8fb0a1) · Commits · e / os / platform_frameworks_native

camera/libcameraservice/CameraHardwareStub.cpp

+51 −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,25 +252,14 @@ 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;
		@@ -257,10 +273,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 +284,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;
		}

camera/libcameraservice/CameraHardwareStub.h

+20 −19

Original line number	Diff line number	Diff line
		@@ -32,23 +32,27 @@ 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 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;
		@@ -109,18 +113,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

+210 −210

File changed.

Preview size limit exceeded, changes collapsed.

camera/libcameraservice/CameraService.h

+11 −13

Original line number	Diff line number	Diff line
		@@ -132,22 +132,20 @@ 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 handlePreviewData(const sp<IMemory>&);
		void handleShutter();
		void handlePostview(const sp<IMemory>&);
		void handleRawPicture(const sp<IMemory>&);
		void handleCompressedPicture(const sp<IMemory>&);

		void copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, size_t offset, size_t size);
		void postError(status_t error);
		void postAutoFocus(bool focused);

		// camera operation mode
		enum camera_mode {

include/ui/Camera.h

+10 −9

Original line number	Diff line number	Diff line
		@@ -66,15 +66,16 @@ namespace android {

		// msgType in notifyCallback and dataCallback functions
		enum {
		CAMERA_MSG_ERROR = 0,
		CAMERA_MSG_SHUTTER,
		CAMERA_MSG_FOCUS,
		CAMERA_MSG_ZOOM,
		CAMERA_MSG_PREVIEW_FRAME,
		CAMERA_MSG_VIDEO_FRAME,
		CAMERA_MSG_POSTVIEW_FRAME,
		CAMERA_MSG_RAW_IMAGE,
		CAMERA_MSG_COMPRESSED_IMAGE
		CAMERA_MSG_ERROR = 0x001,
		CAMERA_MSG_SHUTTER = 0x002,
		CAMERA_MSG_FOCUS = 0x004,
		CAMERA_MSG_ZOOM = 0x008,
		CAMERA_MSG_PREVIEW_FRAME = 0x010,
		CAMERA_MSG_VIDEO_FRAME = 0x020,
		CAMERA_MSG_POSTVIEW_FRAME = 0x040,
		CAMERA_MSG_RAW_IMAGE = 0x080,
		CAMERA_MSG_COMPRESSED_IMAGE = 0x100,
		CAMERA_MSG_ALL_MSGS = 0x1FF
		};

		// camera fatal errors