move native services under services/ (81bac09f) · Commits · e / os / android_frameworks_native

camera/libcameraservice/Android.mk

deleted100644 → 0

+0 −66

Original line number	Diff line number	Diff line
		LOCAL_PATH:= $(call my-dir)

		# Set USE_CAMERA_STUB if you don't want to use the hardware camera.

		# force these builds to use camera stub only
		ifneq ($(filter sooner generic sim,$(TARGET_DEVICE)),)
		USE_CAMERA_STUB:=true
		endif

		ifeq ($(USE_CAMERA_STUB),)
		USE_CAMERA_STUB:=false
		endif

		ifeq ($(USE_CAMERA_STUB),true)
		#
		# libcamerastub
		#

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		CameraHardwareStub.cpp \
		FakeCamera.cpp

		LOCAL_MODULE:= libcamerastub

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

		LOCAL_SHARED_LIBRARIES:= libui

		include $(BUILD_STATIC_LIBRARY)
		endif # USE_CAMERA_STUB

		#
		# libcameraservice
		#

		include $(CLEAR_VARS)

		LOCAL_SRC_FILES:= \
		CameraService.cpp

		LOCAL_SHARED_LIBRARIES:= \
		libui \
		libutils \
		libbinder \
		libcutils \
		libmedia \
		libcamera_client \
		libsurfaceflinger_client

		LOCAL_MODULE:= libcameraservice

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

		ifeq ($(USE_CAMERA_STUB), true)
		LOCAL_STATIC_LIBRARIES += libcamerastub
		else
		LOCAL_SHARED_LIBRARIES += libcamera
		endif

		include $(BUILD_SHARED_LIBRARY)

camera/libcameraservice/CameraHardwareStub.cpp

deleted100644 → 0

+0 −410

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2008, 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_TAG "CameraHardwareStub"
		#include <utils/Log.h>

		#include "CameraHardwareStub.h"
		#include <utils/threads.h>
		#include <fcntl.h>
		#include <sys/mman.h>

		#include "CannedJpeg.h"

		namespace android {

		CameraHardwareStub::CameraHardwareStub()
		: mParameters(),
		mPreviewHeap(0),
		mRawHeap(0),
		mFakeCamera(0),
		mPreviewFrameSize(0),
		mNotifyCb(0),
		mDataCb(0),
		mDataCbTimestamp(0),
		mCallbackCookie(0),
		mMsgEnabled(0),
		mCurrentPreviewFrame(0)
		{
		initDefaultParameters();
		}

		void CameraHardwareStub::initDefaultParameters()
		{
		CameraParameters p;

		p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, "320x240");
		p.setPreviewSize(320, 240);
		p.setPreviewFrameRate(15);
		p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP);

		p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, "320x240");
		p.setPictureSize(320, 240);
		p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG);

		if (setParameters(p) != NO_ERROR) {
		LOGE("Failed to set default parameters?!");
		}
		}

		void CameraHardwareStub::initHeapLocked()
		{
		// Create raw heap.
		int picture_width, picture_height;
		mParameters.getPictureSize(&picture_width, &picture_height);
		mRawHeap = new MemoryHeapBase(picture_width * picture_height * 3 / 2);

		int preview_width, preview_height;
		mParameters.getPreviewSize(&preview_width, &preview_height);
		LOGD("initHeapLocked: preview size=%dx%d", preview_width, preview_height);

		// Note that we enforce yuv420sp in setParameters().
		int how_big = preview_width * preview_height * 3 / 2;

		// If we are being reinitialized to the same size as before, no
		// work needs to be done.
		if (how_big == mPreviewFrameSize)
		return;

		mPreviewFrameSize = how_big;

		// Make a new mmap'ed heap that can be shared across processes.
		// use code below to test with pmem
		mPreviewHeap = new MemoryHeapBase(mPreviewFrameSize * kBufferCount);
		// Make an IMemory for each frame so that we can reuse them in callbacks.
		for (int i = 0; i < kBufferCount; i++) {
		mBuffers[i] = new MemoryBase(mPreviewHeap, i * mPreviewFrameSize, mPreviewFrameSize);
		}

		// Recreate the fake camera to reflect the current size.
		delete mFakeCamera;
		mFakeCamera = new FakeCamera(preview_width, preview_height);
		}

		CameraHardwareStub::~CameraHardwareStub()
		{
		delete mFakeCamera;
		mFakeCamera = 0; // paranoia
		}

		sp<IMemoryHeap> CameraHardwareStub::getPreviewHeap() const
		{
		return mPreviewHeap;
		}

		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()
		{
		mLock.lock();
		// the attributes below can change under our feet...

		int previewFrameRate = mParameters.getPreviewFrameRate();

		// Find the offset within the heap of the current buffer.
		ssize_t offset = mCurrentPreviewFrame * mPreviewFrameSize;

		sp<MemoryHeapBase> heap = mPreviewHeap;

		// this assumes the internal state of fake camera doesn't change
		// (or is thread safe)
		FakeCamera* fakeCamera = mFakeCamera;

		sp<MemoryBase> buffer = mBuffers[mCurrentPreviewFrame];

		mLock.unlock();

		// TODO: here check all the conditions that could go wrong
		if (buffer != 0) {
		// Calculate how long to wait between frames.
		int delay = (int)(1000000.0f / float(previewFrameRate));

		// This is always valid, even if the client died -- the memory
		// is still mapped in our process.
		void *base = heap->base();

		// Fill the current frame with the fake camera.
		uint8_t frame = ((uint8_t )base) + offset;
		fakeCamera->getNextFrameAsYuv420(frame);

		//LOGV("previewThread: generated frame to buffer %d", mCurrentPreviewFrame);

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

		// Advance the buffer pointer.
		mCurrentPreviewFrame = (mCurrentPreviewFrame + 1) % kBufferCount;

		// Wait for it...
		usleep(delay);
		}

		return NO_ERROR;
		}

		status_t CameraHardwareStub::startPreview()
		{
		Mutex::Autolock lock(mLock);
		if (mPreviewThread != 0) {
		// already running
		return INVALID_OPERATION;
		}
		mPreviewThread = new PreviewThread(this);
		return NO_ERROR;
		}

		void CameraHardwareStub::stopPreview()
		{
		sp<PreviewThread> previewThread;

		{ // scope for the lock
		Mutex::Autolock lock(mLock);
		previewThread = mPreviewThread;
		}

		// don't hold the lock while waiting for the thread to quit
		if (previewThread != 0) {
		previewThread->requestExitAndWait();
		}

		Mutex::Autolock lock(mLock);
		mPreviewThread.clear();
		}

		bool CameraHardwareStub::previewEnabled() {
		return mPreviewThread != 0;
		}

		status_t CameraHardwareStub::startRecording()
		{
		return UNKNOWN_ERROR;
		}

		void CameraHardwareStub::stopRecording()
		{
		}

		bool CameraHardwareStub::recordingEnabled()
		{
		return false;
		}

		void CameraHardwareStub::releaseRecordingFrame(const sp<IMemory>& mem)
		{
		}

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

		int CameraHardwareStub::beginAutoFocusThread(void *cookie)
		{
		CameraHardwareStub c = (CameraHardwareStub )cookie;
		return c->autoFocusThread();
		}

		int CameraHardwareStub::autoFocusThread()
		{
		if (mMsgEnabled & CAMERA_MSG_FOCUS)
		mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie);
		return NO_ERROR;
		}

		status_t CameraHardwareStub::autoFocus()
		{
		Mutex::Autolock lock(mLock);
		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;
		return c->pictureThread();
		}

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

		if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) {
		//FIXME: use a canned YUV image!
		// In the meantime just make another fake camera picture.
		int w, h;
		mParameters.getPictureSize(&w, &h);
		sp<MemoryBase> mem = new MemoryBase(mRawHeap, 0, w * h * 3 / 2);
		FakeCamera cam(w, h);
		cam.getNextFrameAsYuv420((uint8_t *)mRawHeap->base());
		mDataCb(CAMERA_MSG_RAW_IMAGE, mem, mCallbackCookie);
		}

		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);
		mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);
		}
		return NO_ERROR;
		}

		status_t CameraHardwareStub::takePicture()
		{
		stopPreview();
		if (createThread(beginPictureThread, this) == false)
		return UNKNOWN_ERROR;
		return NO_ERROR;
		}

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

		status_t CameraHardwareStub::dump(int fd, const Vector<String16>& args) const
		{
		const size_t SIZE = 256;
		char buffer[SIZE];
		String8 result;
		AutoMutex lock(&mLock);
		if (mFakeCamera != 0) {
		mFakeCamera->dump(fd);
		mParameters.dump(fd, args);
		snprintf(buffer, 255, " preview frame(%d), size (%d), running(%s)\n", mCurrentPreviewFrame, mPreviewFrameSize, mPreviewRunning?"true": "false");
		result.append(buffer);
		} else {
		result.append("No camera client yet.\n");
		}
		write(fd, result.string(), result.size());
		return NO_ERROR;
		}

		status_t CameraHardwareStub::setParameters(const CameraParameters& params)
		{
		Mutex::Autolock lock(mLock);
		// XXX verify params

		if (strcmp(params.getPreviewFormat(),
		CameraParameters::PIXEL_FORMAT_YUV420SP) != 0) {
		LOGE("Only yuv420sp preview is supported");
		return -1;
		}

		if (strcmp(params.getPictureFormat(),
		CameraParameters::PIXEL_FORMAT_JPEG) != 0) {
		LOGE("Only jpeg still pictures are supported");
		return -1;
		}

		int w, h;
		params.getPictureSize(&w, &h);
		if (w != kCannedJpegWidth && h != kCannedJpegHeight) {
		LOGE("Still picture size must be size of canned JPEG (%dx%d)",
		kCannedJpegWidth, kCannedJpegHeight);
		return -1;
		}

		mParameters = params;
		initHeapLocked();

		return NO_ERROR;
		}

		CameraParameters CameraHardwareStub::getParameters() const
		{
		Mutex::Autolock lock(mLock);
		return mParameters;
		}

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

		void CameraHardwareStub::release()
		{
		}

		sp<CameraHardwareInterface> CameraHardwareStub::createInstance()
		{
		return new CameraHardwareStub();
		}

		static CameraInfo sCameraInfo[] = {
		{
		CAMERA_FACING_BACK,
		90, /* orientation */
		}
		};

		extern "C" int HAL_getNumberOfCameras()
		{
		return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]);
		}

		extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo)
		{
		memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo));
		}

		extern "C" sp<CameraHardwareInterface> HAL_openCameraHardware(int cameraId)
		{
		return CameraHardwareStub::createInstance();
		}

		}; // namespace android

camera/libcameraservice/CameraHardwareStub.h

deleted100644 → 0

+0 −133

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2008, 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_HARDWARE_CAMERA_HARDWARE_STUB_H
		#define ANDROID_HARDWARE_CAMERA_HARDWARE_STUB_H

		#include "FakeCamera.h"
		#include <utils/threads.h>
		#include <camera/CameraHardwareInterface.h>
		#include <binder/MemoryBase.h>
		#include <binder/MemoryHeapBase.h>
		#include <utils/threads.h>

		namespace android {

		class CameraHardwareStub : public CameraHardwareInterface {
		public:
		virtual sp<IMemoryHeap> getPreviewHeap() const;
		virtual sp<IMemoryHeap> getRawHeap() const;

		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();
		virtual void stopRecording();
		virtual bool recordingEnabled();
		virtual void releaseRecordingFrame(const sp<IMemory>& mem);

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

		private:
		CameraHardwareStub();
		virtual ~CameraHardwareStub();

		static const int kBufferCount = 4;

		class PreviewThread : public Thread {
		CameraHardwareStub* mHardware;
		public:
		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);
		}
		virtual bool threadLoop() {
		mHardware->previewThread();
		// loop until we need to quit
		return true;
		}
		};

		void initDefaultParameters();
		void initHeapLocked();

		int previewThread();

		static int beginAutoFocusThread(void *cookie);
		int autoFocusThread();

		static int beginPictureThread(void *cookie);
		int pictureThread();

		mutable Mutex mLock;

		CameraParameters mParameters;

		sp<MemoryHeapBase> mPreviewHeap;
		sp<MemoryHeapBase> mRawHeap;
		sp<MemoryBase> mBuffers[kBufferCount];

		FakeCamera *mFakeCamera;
		bool mPreviewRunning;
		int mPreviewFrameSize;

		// protected by mLock
		sp<PreviewThread> mPreviewThread;

		notify_callback mNotifyCb;
		data_callback mDataCb;
		data_callback_timestamp mDataCbTimestamp;
		void *mCallbackCookie;

		int32_t mMsgEnabled;

		// only used from PreviewThread
		int mCurrentPreviewFrame;
		};

		}; // namespace android

		#endif