From bb5c28f6349e0b1f53fc27a6c3b66e57d5767edd Mon Sep 17 00:00:00 2001 From: Pawit Pornkitprasan Date: Mon, 8 Aug 2011 14:33:55 +0700 Subject: Replaced libcamera.so with a wrapper Features: - Continuous AF - ISO - Metering - Scene-modes - Focus-modes - Touch to focus (dependent on Iafc575a5) - Additional FFC Preview sizes (was hacked in on the old libcamera.so) - Disabled Samsung hacks in Camera.apk because it's no longer needed Note: - I believe that the same libcamera.so (now renamed libsamsungcamera.so) can be used for all variants now that the wrapper returns the correct number of comera (correct me if I'm wrong) - The vendor_samsung will need to be updated with libcamera.so removed for all models and http://www.mediafire.com/?3h7p4m0932l1dbv added as a proprietary file (renamed as libsamsungcamera.so). except for fascinatemtd, mesmerizemtd and showcasemtd and they require their libcamera.so with flash support. (Just rename the old one to libsamsungcamera.so) - This new libcamera.so requires a new prebuilt kernel (with pull request #41, which is already merged) for FFC to work. (only on models with FFC) Change-Id: I1f179068bf9d5295a48d118be191cf65c834fe7b --- libcamera/Android.mk | 46 +- libcamera/LibCameraWrapper.cpp | 414 +++++ libcamera/LibCameraWrapper.h | 64 + libcamera/NOTICE | 190 --- libcamera/SecCamera.cpp | 3142 ------------------------------------ libcamera/SecCamera.h | 538 ------ libcamera/SecCameraHWInterface.cpp | 2142 ------------------------ libcamera/SecCameraHWInterface.h | 212 --- 8 files changed, 485 insertions(+), 6263 deletions(-) create mode 100644 libcamera/LibCameraWrapper.cpp create mode 100644 libcamera/LibCameraWrapper.h delete mode 100644 libcamera/NOTICE delete mode 100644 libcamera/SecCamera.cpp delete mode 100644 libcamera/SecCamera.h delete mode 100644 libcamera/SecCameraHWInterface.cpp delete mode 100644 libcamera/SecCameraHWInterface.h (limited to 'libcamera') diff --git a/libcamera/Android.mk b/libcamera/Android.mk index f4b41bb..fb274e8 100644 --- a/libcamera/Android.mk +++ b/libcamera/Android.mk @@ -1,51 +1,19 @@ -ifeq ($(Y_U_NO_HAVE_CAMERA),true) +LOCAL_PATH:= $(call my-dir) -# When zero we link against libqcamera; when 1, we dlopen libqcamera. -ifeq ($(BOARD_CAMERA_LIBRARIES),libcamera) +include $(CLEAR_VARS) -DLOPEN_LIBSECCAMERA:=1 +LOCAL_SRC_FILES:= LibCameraWrapper.cpp -LOCAL_PATH:= $(call my-dir) -include $(CLEAR_VARS) +LOCAL_SHARED_LIBRARIES:= libdl libutils libcutils libcamera_client -LOCAL_CFLAGS:=-fno-short-enums -LOCAL_CFLAGS+=-DDLOPEN_LIBSECCAMERA=$(DLOPEN_LIBSECCAMERA) +LOCAL_MODULE := libcamera +LOCAL_MODULE_TAGS := optional -ifdef BOARD_CAMERA_DEVICE - LOCAL_CFLAGS += -DCAMERA_DEV_NAME=\"$(BOARD_CAMERA_DEVICE)\" -endif +LOCAL_PRELINK_MODULE := false ifdef BOARD_SECOND_CAMERA_DEVICE - LOCAL_CFLAGS += -DCAMERA_DEV_NAME2=\"$(BOARD_SECOND_CAMERA_DEVICE)\" LOCAL_CFLAGS += -DFFC_PRESENT endif -LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include -LOCAL_C_INCLUDES += $(LOCAL_PATH)/../libs3cjpeg - - -LOCAL_SRC_FILES:= \ - SecCamera.cpp \ - SecCameraHWInterface.cpp - - -LOCAL_SHARED_LIBRARIES:= libutils libui liblog libbinder libcutils -LOCAL_SHARED_LIBRARIES+= libs3cjpeg.aries -LOCAL_SHARED_LIBRARIES+= libcamera_client - -ifeq ($(BOARD_USES_OVERLAY),true) -LOCAL_CFLAGS += -DBOARD_USES_OVERLAY -endif - -ifeq ($(DLOPEN_LIBSECCAMERA),1) -LOCAL_SHARED_LIBRARIES+= libdl -endif - -LOCAL_MODULE:= libcamera - -LOCAL_MODULE_TAGS := optional - include $(BUILD_SHARED_LIBRARY) -endif -endif diff --git a/libcamera/LibCameraWrapper.cpp b/libcamera/LibCameraWrapper.cpp new file mode 100644 index 0000000..3ccf332 --- /dev/null +++ b/libcamera/LibCameraWrapper.cpp @@ -0,0 +1,414 @@ +/* + * 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. + */ + +// Adapted from JordanCameraWrapper + +// We can't use CameraParameters constants because we're linking against +// Samsung's libcamera_client.so + +#define LOG_TAG "LibCameraWrapper" +//#define LOG_NDEBUG 0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include "LibCameraWrapper.h" + +namespace android { + +typedef sp (*OpenCamFunc)(int); +typedef void (*GetCamInfo)(int, struct CameraInfo*); + +static void * g_libHandle = NULL; +static OpenCamFunc g_openCameraHardware = NULL; +static GetCamInfo g_getCameraInfo = NULL; + +static const int CAMERA_CMD_SET_OBJECT_TRACKING_POSITION = 1103; +static const int CAMERA_CMD_SET_TOUCH_AF = 1105; + +static void ensureLibOpened() +{ + if (g_libHandle == NULL) { + g_libHandle = ::dlopen("libsamsungcamera.so", RTLD_NOW); + if (g_libHandle == NULL) { + assert(0); + LOGE("dlopen() error: %s\n", dlerror()); + } else { + g_openCameraHardware = (OpenCamFunc) ::dlsym(g_libHandle, "HAL_openCameraHardware"); + g_getCameraInfo = (GetCamInfo) ::dlsym(g_libHandle, "HAL_getCameraInfo"); + assert(g_openCameraHardware != NULL); + } + } +} + +extern "C" int HAL_getNumberOfCameras() +{ +#ifdef FFC_PRESENT + return 2; +#else + return 1; +#endif +} + +extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo) +{ + ensureLibOpened(); + g_getCameraInfo(cameraId, cameraInfo); +} + +extern "C" sp HAL_openCameraHardware(int cameraId) +{ + LOGV("openCameraHardware: call createInstance"); + ensureLibOpened(); + return LibCameraWrapper::createInstance(cameraId); +} + +wp LibCameraWrapper::singleton[2] = { 0 }; + +sp LibCameraWrapper::createInstance(int cameraId) +{ + LOGV("%s :", __func__); + if (singleton[cameraId] != NULL) { + sp hardware = singleton[cameraId].promote(); + if (hardware != NULL) { + return hardware; + } + } + + ensureLibOpened(); + + sp hardware(new LibCameraWrapper(cameraId)); + singleton[cameraId] = hardware; + return hardware; +} + +LibCameraWrapper::LibCameraWrapper(int cameraId) : + mLibInterface(g_openCameraHardware(cameraId)), + mCameraId(cameraId), + mVideoMode(false), + mContinuousAf(false), + mTouchFocus(false) +{ + LOGV("%s :", __func__); +} + +LibCameraWrapper::~LibCameraWrapper() +{ + LOGV("%s :", __func__); +} + +sp +LibCameraWrapper::getPreviewHeap() const +{ + LOGV("%s :", __func__); + return mLibInterface->getPreviewHeap(); +} + +sp +LibCameraWrapper::getRawHeap() const +{ + LOGV("%s :", __func__); + return mLibInterface->getRawHeap(); +} + +void +LibCameraWrapper::setCallbacks(notify_callback notify_cb, + data_callback data_cb, + data_callback_timestamp data_cb_timestamp, + void* user) +{ + LOGV("%s :", __func__); + mLibInterface->setCallbacks(notify_cb, data_cb, data_cb_timestamp, user); +} + +void +LibCameraWrapper::enableMsgType(int32_t msgType) +{ + LOGV("%s :", __func__); + mLibInterface->enableMsgType(msgType); +} + +void +LibCameraWrapper::disableMsgType(int32_t msgType) +{ + LOGV("%s :", __func__); + mLibInterface->disableMsgType(msgType); +} + +bool +LibCameraWrapper::msgTypeEnabled(int32_t msgType) +{ + LOGV("%s :", __func__); + return mLibInterface->msgTypeEnabled(msgType); +} + +status_t +LibCameraWrapper::startPreview() +{ + LOGV("%s :", __func__); + return mLibInterface->startPreview(); +} + +bool +LibCameraWrapper::useOverlay() +{ + LOGV("%s :", __func__); + return mLibInterface->useOverlay(); +} + +status_t +LibCameraWrapper::setOverlay(const sp &overlay) +{ + LOGV("%s :", __func__); + return mLibInterface->setOverlay(overlay); +} + +void +LibCameraWrapper::stopPreview() +{ + LOGV("%s :", __func__); + mLibInterface->stopPreview(); +} + +bool +LibCameraWrapper::previewEnabled() +{ + LOGV("%s :", __func__); + return mLibInterface->previewEnabled(); +} + +status_t +LibCameraWrapper::startRecording() +{ + LOGV("%s :", __func__); + return mLibInterface->startRecording(); +} + +void +LibCameraWrapper::stopRecording() +{ + LOGV("%s :", __func__); + mLibInterface->stopRecording(); +} + +bool +LibCameraWrapper::recordingEnabled() +{ + LOGV("%s :", __func__); + return mLibInterface->recordingEnabled(); +} + +void +LibCameraWrapper::releaseRecordingFrame(const sp& mem) +{ + LOGV("%s :", __func__); + return mLibInterface->releaseRecordingFrame(mem); +} + +status_t +LibCameraWrapper::autoFocus() +{ + LOGV("%s :", __func__); + return mLibInterface->autoFocus(); +} + +status_t +LibCameraWrapper::cancelAutoFocus() +{ + LOGV("%s :", __func__); + return mLibInterface->cancelAutoFocus(); +} + +status_t +LibCameraWrapper::takePicture() +{ + LOGV("%s :", __func__); + return mLibInterface->takePicture(); +} + +status_t +LibCameraWrapper::cancelPicture() +{ + LOGV("%s :", __func__); + return mLibInterface->cancelPicture(); +} + +status_t +LibCameraWrapper::setParameters(const CameraParameters& params) +{ + LOGV("%s :", __func__); + CameraParameters pars(params.flatten()); + + if (mCameraId == 0) { + const char *metering; + const char *conAf; + const char *touchCoordinate; + + /* + * getInt returns -1 if the value isn't present and 0 on parse failure, + * so if it's larger than 0, we can be sure the value was parsed properly + */ + mVideoMode = pars.getInt("cam-mode") > 0; + pars.remove("cam-mode"); + + if (mVideoMode) { + // Special settings in video mode + pars.set("video_recording_gamma", "on"); + pars.set("slow_ae", "on"); + pars.set("iso", "movie"); + pars.set("metering", "matrix"); + } + else { + pars.set("video_recording_gamma", "off"); + pars.set("slow_ae", "off"); + } + + // Parse continuous autofoucs into a format the driver understands + conAf = pars.get("enable-caf"); + mContinuousAf = (conAf != 0 && strcmp(conAf, "on") == 0); + pars.set("continuous_af", mContinuousAf ? 1 : 0); + + // Always set antibanding to 50hz + pars.set("antibanding", "50hz"); + + // Parse metering into something the driver understands + metering = pars.get("meter-mode"); + if (metering != 0) { + if (strcmp(metering, "meter-center") == 0) { + pars.set("metering", "center"); + } + else if (strcmp(metering, "meter-spot") == 0) { + pars.set("metering", "spot"); + } + else if (strcmp(metering, "meter-matrix") == 0) { + pars.set("metering", "matrix"); + } + pars.remove("auto-exposure"); + } + + // Read touch-to-focus + touchCoordinate = pars.get("touch-focus"); + if (touchCoordinate != 0) { + int width, height; + int x, y; + char *comma; + x = mTouchFocusX = strtol(touchCoordinate, &comma, 10); + y = mTouchFocusY = strtol(comma + 1, NULL, 10); + + pars.getPreviewSize(&width, &height); + if (fabs((float)width/height - 1.66) > 0.1) { + LOGV("Non-widescreen touch focus"); + x += 80; // Only aries' Camera needs this for non-widescreen + } + + sendCommand(CAMERA_CMD_SET_TOUCH_AF, 0, 0); + sendCommand(CAMERA_CMD_SET_OBJECT_TRACKING_POSITION, x, y); + sendCommand(CAMERA_CMD_SET_TOUCH_AF, 1, 0); + + mTouchFocus = true; + pars.remove("touch-focus"); + } + else if (mTouchFocus) { + LOGV("Disabling touch focus"); + sendCommand(CAMERA_CMD_SET_TOUCH_AF, 0, 0); + mTouchFocus = false; + } + + } + + return mLibInterface->setParameters(pars); +} + +CameraParameters +LibCameraWrapper::getParameters() const +{ + LOGV("%s :", __func__); + CameraParameters ret = mLibInterface->getParameters(); + + if (mCameraId == 0) { + // The only value of antibanding supported is 50hz. Let's not say we support anything + ret.remove("antibanding-values"); + + // We support facedetect as well + ret.set("focus-mode-values", "auto,macro,facedetect"); + + // Auto-exposure modes. NOTE: matrix isn't a value supported in stock android + ret.set("meter-mode-values", "meter-center,meter-spot,meter-matrix"); + + // ISO values. The driver fails to return any of this. + ret.set("iso-values", "auto,50,100,200,400,800,1600,3200,sports,night,movie"); + + // Scene modes. The driver fails to return its proper supported values. + ret.set("scene-mode-values", "auto,portrait,landscape,sports,sunset,dusk-dawn,fireworks,beach,party,night,fall-color,text,candlelight,back-light"); + + // This is for detecting if we're in camcorder mode or not + ret.set("cam-mode", mVideoMode ? "1" : "0"); + + // Continuous AF + ret.set("enable-caf", mContinuousAf ? "on" : "off"); + + // Touch-to-focus + if (mTouchFocus) { + if (mTouchFocusX > 9999 || mTouchFocusY > 9999) { + LOGE("ERROR: Touch focus X, Y coordinate too large."); + ret.set("touch-focus", ""); + } + else { + char touchfocus[10] = ""; + sprintf(touchfocus, "%d,%d", mTouchFocusX, mTouchFocusY); + ret.set("touch-focus", touchfocus); + } + } + else { + ret.set("touch-focus", ""); + } + } + else if (mCameraId == 1) { + // FFC: We need more preview and picture size to support GTalk + ret.set("preview-size-values", "176x144,320x240,640x480"); + ret.set("picture-size-values", "176x144,320x240,640x480"); + } + + return ret; +} + +status_t +LibCameraWrapper::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) +{ + LOGV("%s :", __func__); + return mLibInterface->sendCommand(cmd, arg1, arg2); +} + +void +LibCameraWrapper::release() +{ + LOGV("%s :", __func__); + mLibInterface->release(); +} + +status_t +LibCameraWrapper::dump(int fd, const Vector& args) const +{ + LOGV("%s :", __func__); + return mLibInterface->dump(fd, args); +} + +}; //namespace android diff --git a/libcamera/LibCameraWrapper.h b/libcamera/LibCameraWrapper.h new file mode 100644 index 0000000..e999706 --- /dev/null +++ b/libcamera/LibCameraWrapper.h @@ -0,0 +1,64 @@ +#ifndef ANDROID_HARDWARE_LIB_CAMERA_WRAPPER_H +#define ANDROID_HARDWARE_LIB_CAMERA_WRAPPER_H + +#include + +namespace android { + +class LibCameraWrapper : public CameraHardwareInterface { +public: + virtual sp getPreviewHeap() const; + virtual sp 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 bool useOverlay(); + virtual status_t setOverlay(const sp &overlay); + virtual void stopPreview(); + virtual bool previewEnabled(); + + virtual status_t startRecording(); + virtual void stopRecording(); + virtual bool recordingEnabled(); + virtual void releaseRecordingFrame(const sp &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 &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 createInstance(int cameraId); + +private: + LibCameraWrapper(int CameraId); + virtual ~LibCameraWrapper(); + + sp mLibInterface; + int mCameraId; + bool mVideoMode; + bool mContinuousAf; + bool mTouchFocus; + int mTouchFocusX; + int mTouchFocusY; + + static wp singleton[2]; + +}; + +}; // namespace android + +#endif diff --git a/libcamera/NOTICE b/libcamera/NOTICE deleted file mode 100644 index f921593..0000000 --- a/libcamera/NOTICE +++ /dev/null @@ -1,190 +0,0 @@ - - Copyright (C) 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. - - 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. - - - Apache License - Version 2.0, January 2004 - http://www.apache.org/licenses/ - - TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - - 1. Definitions. - - "License" shall mean the terms and conditions for use, reproduction, - and distribution as defined by Sections 1 through 9 of this document. - - "Licensor" shall mean the copyright owner or entity authorized by - the copyright owner that is granting the License. - - "Legal Entity" shall mean the union of the acting entity and all - other entities that control, are controlled by, or are under common - control with that entity. For the purposes of this definition, - "control" means (i) the power, direct or indirect, to cause the - direction or management of such entity, whether by contract or - otherwise, or (ii) ownership of fifty percent (50%) or more of the - outstanding shares, or (iii) beneficial ownership of such entity. - - "You" (or "Your") shall mean an individual or Legal Entity - exercising permissions granted by this License. - - "Source" form shall mean the preferred form for making modifications, - including but not limited to software source code, documentation - source, and configuration files. - - "Object" form shall mean any form resulting from mechanical - transformation or translation of a Source form, including but - not limited to compiled object code, generated documentation, - and conversions to other media types. - - "Work" shall mean the work of authorship, whether in Source or - Object form, made available under the License, as indicated by a - copyright notice that is included in or attached to the work - (an example is provided in the Appendix below). - - "Derivative Works" shall mean any work, whether in Source or Object - form, that is based on (or derived from) the Work and for which the - editorial revisions, annotations, elaborations, or other modifications - represent, as a whole, an original work of authorship. For the purposes - of this License, Derivative Works shall not include works that remain - separable from, or merely link (or bind by name) to the interfaces of, - the Work and Derivative Works thereof. - - "Contribution" shall mean any work of authorship, including - the original version of the Work and any modifications or additions - to that Work or Derivative Works thereof, that is intentionally - submitted to Licensor for inclusion in the Work by the copyright owner - or by an individual or Legal Entity authorized to submit on behalf of - the copyright owner. For the purposes of this definition, "submitted" - means any form of electronic, verbal, or written communication sent - to the Licensor or its representatives, including but not limited to - communication on electronic mailing lists, source code control systems, - and issue tracking systems that are managed by, or on behalf of, the - Licensor for the purpose of discussing and improving the Work, but - excluding communication that is conspicuously marked or otherwise - designated in writing by the copyright owner as "Not a Contribution." - - "Contributor" shall mean Licensor and any individual or Legal Entity - on behalf of whom a Contribution has been received by Licensor and - subsequently incorporated within the Work. - - 2. Grant of Copyright License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - copyright license to reproduce, prepare Derivative Works of, - publicly display, publicly perform, sublicense, and distribute the - Work and such Derivative Works in Source or Object form. - - 3. Grant of Patent License. Subject to the terms and conditions of - this License, each Contributor hereby grants to You a perpetual, - worldwide, non-exclusive, no-charge, royalty-free, irrevocable - (except as stated in this section) patent license to make, have made, - use, offer to sell, sell, import, and otherwise transfer the Work, - where such license applies only to those patent claims licensable - by such Contributor that are necessarily infringed by their - Contribution(s) alone or by combination of their Contribution(s) - with the Work to which such Contribution(s) was submitted. If You - institute patent litigation against any entity (including a - cross-claim or counterclaim in a lawsuit) alleging that the Work - or a Contribution incorporated within the Work constitutes direct - or contributory patent infringement, then any patent licenses - granted to You under this License for that Work shall terminate - as of the date such litigation is filed. - - 4. Redistribution. You may reproduce and distribute copies of the - Work or Derivative Works thereof in any medium, with or without - modifications, and in Source or Object form, provided that You - meet the following conditions: - - (a) You must give any other recipients of the Work or - Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices - stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works - that You distribute, all copyright, patent, trademark, and - attribution notices from the Source form of the Work, - excluding those notices that do not pertain to any part of - the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its - distribution, then any Derivative Works that You distribute must - include a readable copy of the attribution notices contained - within such NOTICE file, excluding those notices that do not - pertain to any part of the Derivative Works, in at least one - of the following places: within a NOTICE text file distributed - as part of the Derivative Works; within the Source form or - documentation, if provided along with the Derivative Works; or, - within a display generated by the Derivative Works, if and - wherever such third-party notices normally appear. The contents - of the NOTICE file are for informational purposes only and - do not modify the License. You may add Your own attribution - notices within Derivative Works that You distribute, alongside - or as an addendum to the NOTICE text from the Work, provided - that such additional attribution notices cannot be construed - as modifying the License. - - You may add Your own copyright statement to Your modifications and - may provide additional or different license terms and conditions - for use, reproduction, or distribution of Your modifications, or - for any such Derivative Works as a whole, provided Your use, - reproduction, and distribution of the Work otherwise complies with - the conditions stated in this License. - - 5. Submission of Contributions. Unless You explicitly state otherwise, - any Contribution intentionally submitted for inclusion in the Work - by You to the Licensor shall be under the terms and conditions of - this License, without any additional terms or conditions. - Notwithstanding the above, nothing herein shall supersede or modify - the terms of any separate license agreement you may have executed - with Licensor regarding such Contributions. - - 6. Trademarks. This License does not grant permission to use the trade - names, trademarks, service marks, or product names of the Licensor, - except as required for reasonable and customary use in describing the - origin of the Work and reproducing the content of the NOTICE file. - - 7. Disclaimer of Warranty. Unless required by applicable law or - agreed to in writing, Licensor provides the Work (and each - Contributor provides its Contributions) on an "AS IS" BASIS, - WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or - implied, including, without limitation, any warranties or conditions - of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A - PARTICULAR PURPOSE. You are solely responsible for determining the - appropriateness of using or redistributing the Work and assume any - risks associated with Your exercise of permissions under this License. - - 8. Limitation of Liability. In no event and under no legal theory, - whether in tort (including negligence), contract, or otherwise, - unless required by applicable law (such as deliberate and grossly - negligent acts) or agreed to in writing, shall any Contributor be - liable to You for damages, including any direct, indirect, special, - incidental, or consequential damages of any character arising as a - result of this License or out of the use or inability to use the - Work (including but not limited to damages for loss of goodwill, - work stoppage, computer failure or malfunction, or any and all - other commercial damages or losses), even if such Contributor - has been advised of the possibility of such damages. - - 9. Accepting Warranty or Additional Liability. While redistributing - the Work or Derivative Works thereof, You may choose to offer, - and charge a fee for, acceptance of support, warranty, indemnity, - or other liability obligations and/or rights consistent with this - License. However, in accepting such obligations, You may act only - on Your own behalf and on Your sole responsibility, not on behalf - of any other Contributor, and only if You agree to indemnify, - defend, and hold each Contributor harmless for any liability - incurred by, or claims asserted against, such Contributor by reason - of your accepting any such warranty or additional liability. - - END OF TERMS AND CONDITIONS - diff --git a/libcamera/SecCamera.cpp b/libcamera/SecCamera.cpp deleted file mode 100644 index 4bd3fc7..0000000 --- a/libcamera/SecCamera.cpp +++ /dev/null @@ -1,3142 +0,0 @@ -/* - * Copyright 2008, The Android Open Source Project - * Copyright 2010, Samsung Electronics Co. LTD - * - * 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. - */ - -/* -************************************ -* Filename: SecCamera.cpp -* Author: Sachin P. Kamat -* Purpose: This file interacts with the Camera and JPEG drivers. -************************************* -*/ - -//#define LOG_NDEBUG 0 -#define LOG_TAG "SecCamera" - -#include - -#include -#include -#include -#include "SecCamera.h" -#include "cutils/properties.h" - -using namespace android; - -#define CHECK(return_value) \ - if (return_value < 0) { \ - LOGE("%s::%d fail. errno: %s, m_camera_id = %d\n", \ - __func__, __LINE__, strerror(errno), m_camera_id); \ - return -1; \ - } - - -#define CHECK_PTR(return_value) \ - if (return_value < 0) { \ - LOGE("%s::%d fail, errno: %s, m_camera_id = %d\n", \ - __func__,__LINE__, strerror(errno), m_camera_id); \ - return NULL; \ - } - -#define ALIGN_TO_32B(x) ((((x) + (1 << 5) - 1) >> 5) << 5) -#define ALIGN_TO_128B(x) ((((x) + (1 << 7) - 1) >> 7) << 7) -#define ALIGN_TO_8KB(x) ((((x) + (1 << 13) - 1) >> 13) << 13) - -namespace android { - -// ====================================================================== -// Camera controls - -static struct timeval time_start; -static struct timeval time_stop; - -unsigned long measure_time(struct timeval *start, struct timeval *stop) -{ - unsigned long sec, usec, time; - - sec = stop->tv_sec - start->tv_sec; - - if (stop->tv_usec >= start->tv_usec) { - usec = stop->tv_usec - start->tv_usec; - } else { - usec = stop->tv_usec + 1000000 - start->tv_usec; - sec--; - } - - time = (sec * 1000000) + usec; - - return time; -} - -static int get_pixel_depth(unsigned int fmt) -{ - int depth = 0; - - switch (fmt) { - case V4L2_PIX_FMT_NV12: - depth = 12; - break; - case V4L2_PIX_FMT_NV12T: - depth = 12; - break; - case V4L2_PIX_FMT_NV21: - depth = 12; - break; - case V4L2_PIX_FMT_YUV420: - depth = 12; - break; - - case V4L2_PIX_FMT_RGB565: - case V4L2_PIX_FMT_YUYV: - case V4L2_PIX_FMT_YVYU: - case V4L2_PIX_FMT_UYVY: - case V4L2_PIX_FMT_VYUY: - case V4L2_PIX_FMT_NV16: - case V4L2_PIX_FMT_NV61: - case V4L2_PIX_FMT_YUV422P: - depth = 16; - break; - - case V4L2_PIX_FMT_RGB32: - depth = 32; - break; - } - - return depth; -} - -#define ALIGN_W(x) (((x) + 0x7F) & (~0x7F)) // Set as multiple of 128 -#define ALIGN_H(x) (((x) + 0x1F) & (~0x1F)) // Set as multiple of 32 -#define ALIGN_BUF(x) (((x) + 0x1FFF)& (~0x1FFF)) // Set as multiple of 8K - -static int init_preview_buffers(struct fimc_buffer *buffers, int width, int height, unsigned int fmt) -{ - int i, len; - - if (fmt==V4L2_PIX_FMT_NV12T) { - len = ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height)) + - ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height / 2)); - } else { - len = (width * height * get_pixel_depth(fmt)) / 8; - } - - for (i = 0; i < MAX_BUFFERS; i++) { - buffers[i].length = len; - } - - return 0; -} - -static int fimc_poll(struct pollfd *events) -{ - int ret; - - /* 10 second delay is because sensor can take a long time - * to do auto focus and capture in dark settings - */ - ret = poll(events, 1, 10000); - if (ret < 0) { - LOGE("ERR(%s):poll error\n", __func__); - return ret; - } - - if (ret == 0) { - LOGE("ERR(%s):No data in 10 secs..\n", __func__); - return ret; - } - - return ret; -} - -int SecCamera::previewPoll(bool preview) -{ - int ret; - - if (preview) { -#ifdef ENABLE_ESD_PREVIEW_CHECK - int status = 0; - - if (!(++m_esd_check_count % 60)) { - status = getCameraSensorESDStatus(); - m_esd_check_count = 0; - if (status) { - LOGE("ERR(%s) ESD status(%d)", __func__, status); - return status; - } - } -#endif - - ret = poll(&m_events_c, 1, 1000); - } else { - ret = poll(&m_events_c2, 1, 1000); - } - - if (ret < 0) { - LOGE("ERR(%s):poll error\n", __func__); - return ret; - } - - if (ret == 0) { - LOGE("ERR(%s):No data in 1 secs.. Camera Device Reset \n", __func__); - return ret; - } - - return ret; -} - -static int fimc_v4l2_querycap(int fp) -{ - struct v4l2_capability cap; - int ret = 0; - - ret = ioctl(fp, VIDIOC_QUERYCAP, &cap); - - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_QUERYCAP failed\n", __func__); - return -1; - } - - if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { - LOGE("ERR(%s):no capture devices\n", __func__); - return -1; - } - - return ret; -} - -static const __u8* fimc_v4l2_enuminput(int fp, int index) -{ - static struct v4l2_input input; - - input.index = index; - if (ioctl(fp, VIDIOC_ENUMINPUT, &input) != 0) { - LOGE("ERR(%s):No matching index found\n", __func__); - return NULL; - } - LOGI("Name of input channel[%d] is %s\n", input.index, input.name); - - return input.name; -} - - -static int fimc_v4l2_s_input(int fp, int index) -{ - struct v4l2_input input; - int ret; - - input.index = index; - - ret = ioctl(fp, VIDIOC_S_INPUT, &input); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_S_INPUT failed\n", __func__); - return ret; - } - - return ret; -} - -static int fimc_v4l2_s_fmt(int fp, int width, int height, unsigned int fmt, int flag_capture) -{ - struct v4l2_format v4l2_fmt; - struct v4l2_pix_format pixfmt; - int ret; - - v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - - memset(&pixfmt, 0, sizeof(pixfmt)); - - pixfmt.width = width; - pixfmt.height = height; - pixfmt.pixelformat = fmt; - - pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8; - - pixfmt.field = V4L2_FIELD_NONE; - - v4l2_fmt.fmt.pix = pixfmt; - - /* Set up for capture */ - ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__); - return -1; - } - - return 0; -} - -static int fimc_v4l2_s_fmt_cap(int fp, int width, int height, unsigned int fmt) -{ - struct v4l2_format v4l2_fmt; - struct v4l2_pix_format pixfmt; - int ret; - - memset(&pixfmt, 0, sizeof(pixfmt)); - - v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - - pixfmt.width = width; - pixfmt.height = height; - pixfmt.pixelformat = fmt; - if (fmt == V4L2_PIX_FMT_JPEG) { - pixfmt.colorspace = V4L2_COLORSPACE_JPEG; - } - - pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8; - - v4l2_fmt.fmt.pix = pixfmt; - - LOGV("ori_w %d, ori_h %d, w %d, h %d\n", width, height, v4l2_fmt.fmt.pix.width, v4l2_fmt.fmt.pix.height); - - /* Set up for capture */ - ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__); - return ret; - } - - return ret; -} - -static int fimc_v4l2_enum_fmt(int fp, unsigned int fmt) -{ - struct v4l2_fmtdesc fmtdesc; - int found = 0; - - fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - fmtdesc.index = 0; - - while (ioctl(fp, VIDIOC_ENUM_FMT, &fmtdesc) == 0) { - if (fmtdesc.pixelformat == fmt) { - LOGV("passed fmt = %#x found pixel format[%d]: %s\n", fmt, fmtdesc.index, fmtdesc.description); - found = 1; - break; - } - - fmtdesc.index++; - } - - if (!found) { - LOGE("unsupported pixel format\n"); - return -1; - } - - return 0; -} - -static int fimc_v4l2_reqbufs(int fp, enum v4l2_buf_type type, int nr_bufs) -{ - struct v4l2_requestbuffers req; - int ret; - - req.count = nr_bufs; - req.type = type; - req.memory = V4L2_MEMORY_MMAP; - - ret = ioctl(fp, VIDIOC_REQBUFS, &req); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_REQBUFS failed\n", __func__); - return -1; - } - - return req.count; -} - -static int fimc_v4l2_querybuf(int fp, struct fimc_buffer *buffer, enum v4l2_buf_type type) -{ - struct v4l2_buffer v4l2_buf; - int ret; - - LOGI("%s :", __func__); - - v4l2_buf.type = type; - v4l2_buf.memory = V4L2_MEMORY_MMAP; - v4l2_buf.index = 0; - - ret = ioctl(fp , VIDIOC_QUERYBUF, &v4l2_buf); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_QUERYBUF failed\n", __func__); - return -1; - } - - buffer->length = v4l2_buf.length; - if ((buffer->start = (char *)mmap(0, v4l2_buf.length, - PROT_READ | PROT_WRITE, MAP_SHARED, - fp, v4l2_buf.m.offset)) < 0) { - LOGE("%s %d] mmap() failed\n",__func__, __LINE__); - return -1; - } - - LOGI("%s: buffer->start = %p v4l2_buf.length = %d", - __func__, buffer->start, v4l2_buf.length); - - return 0; -} - -static int fimc_v4l2_streamon(int fp) -{ - enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - int ret; - - ret = ioctl(fp, VIDIOC_STREAMON, &type); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_STREAMON failed\n", __func__); - return ret; - } - - return ret; -} - -static int fimc_v4l2_streamoff(int fp) -{ - enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - int ret; - - LOGV("%s :", __func__); - ret = ioctl(fp, VIDIOC_STREAMOFF, &type); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_STREAMOFF failed\n", __func__); - return ret; - } - - return ret; -} - -static int fimc_v4l2_qbuf(int fp, int index) -{ - struct v4l2_buffer v4l2_buf; - int ret; - - v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - v4l2_buf.memory = V4L2_MEMORY_MMAP; - v4l2_buf.index = index; - - ret = ioctl(fp, VIDIOC_QBUF, &v4l2_buf); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_QBUF failed\n", __func__); - return ret; - } - - return 0; -} - -static int fimc_v4l2_dqbuf(int fp) -{ - struct v4l2_buffer v4l2_buf; - int ret; - - v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - v4l2_buf.memory = V4L2_MEMORY_MMAP; - - ret = ioctl(fp, VIDIOC_DQBUF, &v4l2_buf); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame\n", __func__); - return ret; - } - - return v4l2_buf.index; -} - -static int fimc_v4l2_g_ctrl(int fp, unsigned int id) -{ - struct v4l2_control ctrl; - int ret; - - ctrl.id = id; - - ret = ioctl(fp, VIDIOC_G_CTRL, &ctrl); - if (ret < 0) { - LOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d\n", - __func__, id, id-V4L2_CID_PRIVATE_BASE, ret); - return ret; - } - - return ctrl.value; -} - -static int fimc_v4l2_s_ctrl(int fp, unsigned int id, unsigned int value) -{ - struct v4l2_control ctrl; - int ret; - - ctrl.id = id; - ctrl.value = value; - - ret = ioctl(fp, VIDIOC_S_CTRL, &ctrl); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d\n", - __func__, id, id-V4L2_CID_PRIVATE_BASE, value, ret); - - return ret; - } - - return ctrl.value; -} - -static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value) -{ - struct v4l2_ext_controls ctrls; - struct v4l2_ext_control ctrl; - int ret; - - ctrl.id = id; - ctrl.reserved = value; - - ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA; - ctrls.count = 1; - ctrls.controls = &ctrl; - - ret = ioctl(fp, VIDIOC_S_EXT_CTRLS, &ctrls); - if (ret < 0) - LOGE("ERR(%s):VIDIOC_S_EXT_CTRLS failed\n", __func__); - - return ret; -} - -static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm) -{ - int ret; - - streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - - ret = ioctl(fp, VIDIOC_G_PARM, streamparm); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_G_PARM failed\n", __func__); - return -1; - } - - LOGV("%s : timeperframe: numerator %d, denominator %d\n", __func__, - streamparm->parm.capture.timeperframe.numerator, - streamparm->parm.capture.timeperframe.denominator); - - return 0; -} - -static int fimc_v4l2_s_parm(int fp, struct v4l2_streamparm *streamparm) -{ - int ret; - - streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; - - ret = ioctl(fp, VIDIOC_S_PARM, streamparm); - if (ret < 0) { - LOGE("ERR(%s):VIDIOC_S_PARM failed\n", __func__); - return ret; - } - - return 0; -} - -// ====================================================================== -// Constructor & Destructor - -SecCamera::SecCamera() : - m_flag_init(0), - m_camera_id(CAMERA_ID_BACK), - m_preview_v4lformat(V4L2_PIX_FMT_NV21), - m_preview_width (0), - m_preview_height (0), - m_preview_max_width (MAX_BACK_CAMERA_PREVIEW_WIDTH), - m_preview_max_height (MAX_BACK_CAMERA_PREVIEW_HEIGHT), - m_snapshot_v4lformat(-1), - m_snapshot_width (0), - m_snapshot_height (0), - m_snapshot_max_width (MAX_BACK_CAMERA_SNAPSHOT_WIDTH), - m_snapshot_max_height (MAX_BACK_CAMERA_SNAPSHOT_HEIGHT), - m_angle(-1), - m_anti_banding(-1), - m_wdr(-1), - m_anti_shake(-1), - m_zoom_level(-1), - m_object_tracking(-1), - m_smart_auto(-1), - m_beauty_shot(-1), - m_vintage_mode(-1), - m_face_detect(-1), - m_gps_latitude(-1), - m_gps_longitude(-1), - m_gps_altitude(-1), - m_gps_timestamp(-1), - m_vtmode(0), - m_sensor_mode(-1), - m_shot_mode(-1), - m_exif_orientation(-1), - m_blur_level(-1), - m_chk_dataline(-1), - m_video_gamma(-1), - m_slow_ae(-1), - m_camera_af_flag(-1), - m_flag_camera_start(0), - m_jpeg_thumbnail_width (0), - m_jpeg_thumbnail_height(0), - m_jpeg_quality(100) -#ifdef ENABLE_ESD_PREVIEW_CHECK - , - m_esd_check_count(0) -#endif // ENABLE_ESD_PREVIEW_CHECK -{ - m_params = (struct sec_cam_parm*)&m_streamparm.parm.raw_data; - struct v4l2_captureparm capture; - m_params->capture.timeperframe.numerator = 1; - m_params->capture.timeperframe.denominator = 0; - m_params->contrast = -1; - m_params->effects = -1; - m_params->brightness = -1; - m_params->flash_mode = -1; - m_params->focus_mode = -1; - m_params->iso = -1; - m_params->metering = -1; - m_params->saturation = -1; - m_params->scene_mode = -1; - m_params->sharpness = -1; - m_params->white_balance = -1; - - memset(&m_capture_buf, 0, sizeof(m_capture_buf)); - - LOGV("%s :", __func__); -} - -int SecCamera::flagCreate(void) const -{ - LOGV("%s : : %d", __func__, m_flag_init); - return m_flag_init; -} - -SecCamera::~SecCamera() -{ - LOGV("%s :", __func__); -} - -int SecCamera::initCamera(int index) -{ - LOGV("%s :", __func__); - int ret = 0; - - if (!m_flag_init) { - /* Arun C - * Reset the lense position only during camera starts; don't do - * reset between shot to shot - */ - m_camera_af_flag = -1; - - m_cam_fd_temp = -1; - m_cam_fd2_temp = -1; - - m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR); - if (m_cam_fd < 0) { - LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME, strerror(errno)); - return -1; - } - - if (m_cam_fd < 3) { // for 0, 1, 2 - LOGE("ERR(%s):m_cam_fd is %d\n", __func__, m_cam_fd); - - close(m_cam_fd); - - m_cam_fd_temp = open(CAMERA_DEV_NAME_TEMP, O_CREAT); - - LOGE("ERR(%s):m_cam_fd_temp is %d\n", __func__, m_cam_fd_temp); - - m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR); - - if (m_cam_fd < 3) { // for 0, 1, 2 - LOGE("ERR(%s):retring to open %s is failed, %d\n", __func__, CAMERA_DEV_NAME, m_cam_fd); - - if (m_cam_fd < 0) { - return -1; - } else { - close(m_cam_fd); - m_cam_fd = -1; - } - - if (m_cam_fd_temp != -1){ - close(m_cam_fd_temp); - m_cam_fd_temp = -1; - } - return -1; - } - } - - LOGE("initCamera: m_cam_fd(%d), m_jpeg_fd(%d)", m_cam_fd, m_jpeg_fd); - - ret = fimc_v4l2_querycap(m_cam_fd); - CHECK(ret); - if (!fimc_v4l2_enuminput(m_cam_fd, index)) - return -1; - ret = fimc_v4l2_s_input(m_cam_fd, index); - CHECK(ret); - - m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR); - if (m_cam_fd2 < 0) { - LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME2, strerror(errno)); - return -1; - } - if (m_cam_fd2 < 3) { // for 0, 1, 2 - LOGE("ERR(%s):m_cam_fd2 is %d\n", __func__, m_cam_fd2); - - close(m_cam_fd2); - - m_cam_fd2_temp = open(CAMERA_DEV_NAME2_TEMP, O_CREAT); - - LOGE("ERR(%s):m_cam_fd2_temp is %d\n", __func__, m_cam_fd2_temp); - - m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR); - - if (m_cam_fd2 < 3) { // for 0, 1, 2 - LOGE("ERR(%s):retring to open %s is failed, %d\n", __func__, CAMERA_DEV_NAME2, m_cam_fd2); - - if (m_cam_fd2 < 0) { - return -1; - } - else{ - close(m_cam_fd2); - m_cam_fd2 = -1; - } - - if (m_cam_fd2_temp != -1) { - close(m_cam_fd2_temp); - m_cam_fd2_temp = -1; - } - - return -1; - } - } - - if (m_cam_fd_temp != -1) { - close(m_cam_fd_temp); - m_cam_fd_temp = -1; - } - - if (m_cam_fd2_temp != -1) { - close(m_cam_fd2_temp); - m_cam_fd2_temp = -1; - } - - LOGE("initCamera: m_cam_fd2(%d)", m_cam_fd2); - - ret = fimc_v4l2_querycap(m_cam_fd2); - CHECK(ret); - if (!fimc_v4l2_enuminput(m_cam_fd2, index)) - return -1; - ret = fimc_v4l2_s_input(m_cam_fd2, index); - CHECK(ret); - - m_camera_id = index; - - switch (m_camera_id) { - case CAMERA_ID_FRONT: - m_preview_max_width = MAX_FRONT_CAMERA_PREVIEW_WIDTH; - m_preview_max_height = MAX_FRONT_CAMERA_PREVIEW_HEIGHT; - m_snapshot_max_width = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH; - m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT; - break; - - case CAMERA_ID_BACK: - m_preview_max_width = MAX_BACK_CAMERA_PREVIEW_WIDTH; - m_preview_max_height = MAX_BACK_CAMERA_PREVIEW_HEIGHT; - m_snapshot_max_width = MAX_BACK_CAMERA_SNAPSHOT_WIDTH; - m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT; - break; - } - - setExifFixedAttribute(); - - m_flag_init = 1; - } - return 0; -} - -void SecCamera::resetCamera() -{ - LOGV("%s :", __func__); - DeinitCamera(); - initCamera(m_camera_id); -} - -void SecCamera::DeinitCamera() -{ - LOGV("%s :", __func__); - - if (m_flag_init) { - - stopRecord(); - - /* close m_cam_fd after stopRecord() because stopRecord() - * uses m_cam_fd to change frame rate - */ - LOGI("DeinitCamera: m_cam_fd(%d)", m_cam_fd); - if (m_cam_fd > -1) { - close(m_cam_fd); - m_cam_fd = -1; - } - - LOGI("DeinitCamera: m_cam_fd2(%d)", m_cam_fd2); - if (m_cam_fd2 > -1) { - close(m_cam_fd2); - m_cam_fd2 = -1; - } - - if (m_cam_fd_temp != -1) { - close(m_cam_fd_temp); - m_cam_fd_temp = -1; - } - - if (m_cam_fd2_temp != -1) { - close(m_cam_fd2_temp); - m_cam_fd2_temp = -1; - } - - m_flag_init = 0; - } -} - - -int SecCamera::getCameraFd(void) -{ - return m_cam_fd; -} - -// ====================================================================== -// Preview - -int SecCamera::startPreview(void) -{ - v4l2_streamparm streamparm; - struct sec_cam_parm *parms; - parms = (struct sec_cam_parm*)&streamparm.parm.raw_data; - LOGV("%s :", __func__); - - // aleady started - if (m_flag_camera_start > 0) { - LOGE("ERR(%s):Preview was already started\n", __func__); - return 0; - } - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - memset(&m_events_c, 0, sizeof(m_events_c)); - m_events_c.fd = m_cam_fd; - m_events_c.events = POLLIN | POLLERR; - - /* enum_fmt, s_fmt sample */ - int ret = fimc_v4l2_enum_fmt(m_cam_fd,m_preview_v4lformat); - CHECK(ret); - ret = fimc_v4l2_s_fmt(m_cam_fd, m_preview_width,m_preview_height,m_preview_v4lformat, 0); - CHECK(ret); - - ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); - CHECK(ret); - - LOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d\n", - __func__, m_preview_width, m_preview_height, m_angle); - - ret = fimc_v4l2_s_ctrl(m_cam_fd, - V4L2_CID_CAMERA_CHECK_DATALINE, m_chk_dataline); - CHECK(ret); - - if (m_camera_id == CAMERA_ID_FRONT) { - /* VT mode setting */ - ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VT_MODE, m_vtmode); - CHECK(ret); - } - - /* start with all buffers in queue */ - for (int i = 0; i < MAX_BUFFERS; i++) { - ret = fimc_v4l2_qbuf(m_cam_fd, i); - CHECK(ret); - } - - ret = fimc_v4l2_streamon(m_cam_fd); - CHECK(ret); - - m_flag_camera_start = 1; - - ret = fimc_v4l2_s_parm(m_cam_fd, &m_streamparm); - CHECK(ret); - - if (m_camera_id == CAMERA_ID_FRONT) { - /* Blur setting */ - LOGV("m_blur_level = %d", m_blur_level); - ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR, - m_blur_level); - CHECK(ret); - } - - // It is a delay for a new frame, not to show the previous bigger ugly picture frame. - ret = fimc_poll(&m_events_c); - CHECK(ret); - ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_RETURN_FOCUS, 0); - CHECK(ret); - - LOGV("%s: got the first frame of the preview\n", __func__); - - return 0; -} - -int SecCamera::stopPreview(void) -{ - int ret; - - LOGV("%s :", __func__); - - if (m_flag_camera_start == 0) { - LOGW("%s: doing nothing because m_flag_camera_start is zero", __func__); - return 0; - } - - if (m_params->flash_mode == FLASH_MODE_TORCH) - setFlashMode(FLASH_MODE_OFF); - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - ret = fimc_v4l2_streamoff(m_cam_fd); - CHECK(ret); - - m_flag_camera_start = 0; - - return ret; -} - -//Recording -int SecCamera::startRecord(void) -{ - int ret, i; - - LOGV("%s :", __func__); - - // aleady started - if (m_flag_record_start > 0) { - LOGE("ERR(%s):Preview was already started\n", __func__); - return 0; - } - - if (m_cam_fd2 <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - /* enum_fmt, s_fmt sample */ - ret = fimc_v4l2_enum_fmt(m_cam_fd2, V4L2_PIX_FMT_NV12T); - CHECK(ret); - - LOGI("%s: m_recording_width = %d, m_recording_height = %d\n", - __func__, m_recording_width, m_recording_height); - - ret = fimc_v4l2_s_fmt(m_cam_fd2, m_recording_width, - m_recording_height, V4L2_PIX_FMT_NV12T, 0); - CHECK(ret); - - ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, - m_params->capture.timeperframe.denominator); - CHECK(ret); - - ret = fimc_v4l2_reqbufs(m_cam_fd2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); - CHECK(ret); - - /* start with all buffers in queue */ - for (i = 0; i < MAX_BUFFERS; i++) { - ret = fimc_v4l2_qbuf(m_cam_fd2, i); - CHECK(ret); - } - - ret = fimc_v4l2_streamon(m_cam_fd2); - CHECK(ret); - - // Get and throw away the first frame since it is often garbled. - memset(&m_events_c2, 0, sizeof(m_events_c2)); - m_events_c2.fd = m_cam_fd2; - m_events_c2.events = POLLIN | POLLERR; - ret = fimc_poll(&m_events_c2); - CHECK(ret); - - m_flag_record_start = 1; - - return 0; -} - -int SecCamera::stopRecord(void) -{ - int ret; - - LOGV("%s :", __func__); - - if (m_flag_record_start == 0) { - LOGW("%s: doing nothing because m_flag_record_start is zero", __func__); - return 0; - } - - if (m_cam_fd2 <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - m_flag_record_start = 0; - - ret = fimc_v4l2_streamoff(m_cam_fd2); - CHECK(ret); - - ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, - FRAME_RATE_AUTO); - CHECK(ret); - - return 0; -} - -unsigned int SecCamera::getRecPhyAddrY(int index) -{ - unsigned int addr_y; - - addr_y = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_Y, index); - CHECK((int)addr_y); - return addr_y; -} - -unsigned int SecCamera::getRecPhyAddrC(int index) -{ - unsigned int addr_c; - - addr_c = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_CBCR, index); - CHECK((int)addr_c); - return addr_c; -} - -unsigned int SecCamera::getPhyAddrY(int index) -{ - unsigned int addr_y; - - addr_y = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_Y, index); - CHECK((int)addr_y); - return addr_y; -} - -unsigned int SecCamera::getPhyAddrC(int index) -{ - unsigned int addr_c; - - addr_c = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_CBCR, index); - CHECK((int)addr_c); - return addr_c; -} - -void SecCamera::pausePreview() -{ - fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0); -} - -int SecCamera::getPreview() -{ - int index; - int ret; - - if (m_flag_camera_start == 0 || previewPoll(true) == 0) { - LOGE("ERR(%s):Start Camera Device Reset \n", __func__); - /* GAUDI Project([arun.c@samsung.com]) 2010.05.20. [Implemented ESD code] */ - /* - * When there is no data for more than 1 second from the camera we inform - * the FIMC driver by calling fimc_v4l2_s_input() with a special value = 1000 - * FIMC driver identify that there is something wrong with the camera - * and it restarts the sensor. - */ - stopPreview(); - /* Reset Only Camera Device */ - ret = fimc_v4l2_querycap(m_cam_fd); - CHECK(ret); - if (fimc_v4l2_enuminput(m_cam_fd, m_camera_id)) - return -1; - ret = fimc_v4l2_s_input(m_cam_fd, 1000); - CHECK(ret); - ret = startPreview(); - if (ret < 0) { - LOGE("ERR(%s): startPreview() return %d\n", __func__, ret); - return 0; - } - } - - index = fimc_v4l2_dqbuf(m_cam_fd); - if (!(0 <= index && index < MAX_BUFFERS)) { - LOGE("ERR(%s):wrong index = %d\n", __func__, index); - return -1; - } - - ret = fimc_v4l2_qbuf(m_cam_fd, index); - CHECK(ret); - - return index; -} - -int SecCamera::getRecordFrame() -{ - if (m_flag_record_start == 0) { - LOGE("%s: m_flag_record_start is 0", __func__); - return -1; - } - - previewPoll(false); - return fimc_v4l2_dqbuf(m_cam_fd2); -} - -int SecCamera::releaseRecordFrame(int index) -{ - if (!m_flag_record_start) { - /* this can happen when recording frames are returned after - * the recording is stopped at the driver level. we don't - * need to return the buffers in this case and we've seen - * cases where fimc could crash if we called qbuf and it - * wasn't expecting it. - */ - LOGI("%s: recording not in progress, ignoring", __func__); - return 0; - } - - return fimc_v4l2_qbuf(m_cam_fd2, index); -} - -int SecCamera::setPreviewSize(int width, int height, int pixel_format) -{ - LOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format); - - int v4lpixelformat = pixel_format; - -#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 - if (v4lpixelformat == V4L2_PIX_FMT_YUV420) - LOGV("PreviewFormat:V4L2_PIX_FMT_YUV420"); - else if (v4lpixelformat == V4L2_PIX_FMT_NV12) - LOGV("PreviewFormat:V4L2_PIX_FMT_NV12"); - else if (v4lpixelformat == V4L2_PIX_FMT_NV12T) - LOGV("PreviewFormat:V4L2_PIX_FMT_NV12T"); - else if (v4lpixelformat == V4L2_PIX_FMT_NV21) - LOGV("PreviewFormat:V4L2_PIX_FMT_NV21"); - else if (v4lpixelformat == V4L2_PIX_FMT_YUV422P) - LOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P"); - else if (v4lpixelformat == V4L2_PIX_FMT_YUYV) - LOGV("PreviewFormat:V4L2_PIX_FMT_YUYV"); - else if (v4lpixelformat == V4L2_PIX_FMT_RGB565) - LOGV("PreviewFormat:V4L2_PIX_FMT_RGB565"); - else - LOGV("PreviewFormat:UnknownFormat"); -#endif - m_preview_width = width; - m_preview_height = height; - m_preview_v4lformat = v4lpixelformat; - - return 0; -} - -int SecCamera::getPreviewSize(int *width, int *height, int *frame_size) -{ - *width = m_preview_width; - *height = m_preview_height; - *frame_size = m_frameSize(m_preview_v4lformat, m_preview_width, m_preview_height); - - return 0; -} - -int SecCamera::getPreviewMaxSize(int *width, int *height) -{ - *width = m_preview_max_width; - *height = m_preview_max_height; - - return 0; -} - -int SecCamera::getPreviewPixelFormat(void) -{ - return m_preview_v4lformat; -} - - -// ====================================================================== -// Snapshot -/* - * Devide getJpeg() as two funcs, setSnapshotCmd() & getJpeg() because of the shutter sound timing. - * Here, just send the capture cmd to camera ISP to start JPEG capture. - */ -int SecCamera::setSnapshotCmd(void) -{ - LOGV("%s :", __func__); - - int ret = 0; - - LOG_TIME_DEFINE(0) - LOG_TIME_DEFINE(1) - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return 0; - } - - if (m_flag_camera_start > 0) { - LOG_TIME_START(0) - LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__); - stopPreview(); - LOG_TIME_END(0) - } - - memset(&m_events_c, 0, sizeof(m_events_c)); - m_events_c.fd = m_cam_fd; - m_events_c.events = POLLIN | POLLERR; - - LOG_TIME_START(1) // prepare - int nframe = 1; - - ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat); - CHECK(ret); - ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG); - CHECK(ret); - ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); - CHECK(ret); - ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE); - CHECK(ret); - - ret = fimc_v4l2_qbuf(m_cam_fd, 0); - CHECK(ret); - - ret = fimc_v4l2_streamon(m_cam_fd); - CHECK(ret); - LOG_TIME_END(1) - - return 0; -} - -int SecCamera::endSnapshot(void) -{ - int ret; - - LOGI("%s :", __func__); - if (m_capture_buf.start) { - munmap(m_capture_buf.start, m_capture_buf.length); - LOGI("munmap():virt. addr %p size = %d\n", - m_capture_buf.start, m_capture_buf.length); - m_capture_buf.start = NULL; - m_capture_buf.length = 0; - } - return 0; -} - -/* - * Set Jpeg quality & exif info and get JPEG data from camera ISP - */ -unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr) -{ - LOGV("%s :", __func__); - - int index, ret = 0; - unsigned char *addr; - - LOG_TIME_DEFINE(2) - - // capture - ret = fimc_poll(&m_events_c); - CHECK_PTR(ret); - index = fimc_v4l2_dqbuf(m_cam_fd); - if (index != 0) { - LOGE("ERR(%s):wrong index = %d\n", __func__, index); - return NULL; - } - - *jpeg_size = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_SIZE); - CHECK_PTR(*jpeg_size); - - int main_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_OFFSET); - CHECK_PTR(main_offset); - m_postview_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET); - CHECK_PTR(m_postview_offset); - - ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0); - CHECK_PTR(ret); - LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d\n\n", - index, m_snapshot_width, m_snapshot_height, *jpeg_size); - - addr = (unsigned char*)(m_capture_buf.start) + main_offset; - *phyaddr = getPhyAddrY(index) + m_postview_offset; - - LOG_TIME_START(2) // post - ret = fimc_v4l2_streamoff(m_cam_fd); - CHECK_PTR(ret); - LOG_TIME_END(2) - - return addr; -} - -int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc) -{ - JpegEncoder jpgEnc; - - LOGV("%s : m_jpeg_thumbnail_width = %d, height = %d", - __func__, m_jpeg_thumbnail_width, m_jpeg_thumbnail_height); - if ((m_jpeg_thumbnail_width > 0) && (m_jpeg_thumbnail_height > 0)) { - int inFormat = JPG_MODESEL_YCBCR; - int outFormat = JPG_422; - switch (m_snapshot_v4lformat) { - case V4L2_PIX_FMT_NV12: - case V4L2_PIX_FMT_NV21: - case V4L2_PIX_FMT_NV12T: - case V4L2_PIX_FMT_YUV420: - outFormat = JPG_420; - break; - case V4L2_PIX_FMT_YUYV: - case V4L2_PIX_FMT_UYVY: - case V4L2_PIX_FMT_YUV422P: - outFormat = JPG_422; - break; - } - - if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS) - return -1; - - if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS) - return -1; - - if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPG_SUCCESS) - return -1; - - int thumbWidth, thumbHeight, thumbSrcSize; - getThumbnailConfig(&thumbWidth, &thumbHeight, &thumbSrcSize); - if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, thumbWidth) != JPG_SUCCESS) - return -1; - - if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, thumbHeight) != JPG_SUCCESS) - return -1; - - char *pInBuf = (char *)jpgEnc.getInBuf(thumbSrcSize); - if (pInBuf == NULL) - return -1; - memcpy(pInBuf, pThumbSrc, thumbSrcSize); - - unsigned int thumbSize; - - jpgEnc.encode(&thumbSize, NULL); - - LOGV("%s : enableThumb set to true", __func__); - mExifInfo.enableThumb = true; - } else { - LOGV("%s : enableThumb set to false", __func__); - mExifInfo.enableThumb = false; - } - - unsigned int exifSize; - - setExifChangedAttribute(); - - LOGV("%s: calling jpgEnc.makeExif, mExifInfo.width set to %d, height to %d\n", - __func__, mExifInfo.width, mExifInfo.height); - - jpgEnc.makeExif(pExifDst, &mExifInfo, &exifSize, true); - - return exifSize; -} - -void SecCamera::getPostViewConfig(int *width, int *height, int *size) -{ - if (m_preview_width == 1024) { - *width = BACK_CAMERA_POSTVIEW_WIDE_WIDTH; - *height = BACK_CAMERA_POSTVIEW_HEIGHT; - *size = BACK_CAMERA_POSTVIEW_WIDE_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8; - } else { - *width = BACK_CAMERA_POSTVIEW_WIDTH; - *height = BACK_CAMERA_POSTVIEW_HEIGHT; - *size = BACK_CAMERA_POSTVIEW_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8; - } - LOGV("[5B] m_preview_width : %d, mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d", - m_preview_width, *width, *height, *size); -} - -void SecCamera::getThumbnailConfig(int *width, int *height, int *size) -{ - if (m_camera_id == CAMERA_ID_BACK) { - *width = BACK_CAMERA_THUMBNAIL_WIDTH; - *height = BACK_CAMERA_THUMBNAIL_HEIGHT; - *size = BACK_CAMERA_THUMBNAIL_WIDTH * BACK_CAMERA_THUMBNAIL_HEIGHT - * BACK_CAMERA_THUMBNAIL_BPP / 8; - } else { - *width = FRONT_CAMERA_THUMBNAIL_WIDTH; - *height = FRONT_CAMERA_THUMBNAIL_HEIGHT; - *size = FRONT_CAMERA_THUMBNAIL_WIDTH * FRONT_CAMERA_THUMBNAIL_HEIGHT - * FRONT_CAMERA_THUMBNAIL_BPP / 8; - } -} - -int SecCamera::getPostViewOffset(void) -{ - return m_postview_offset; -} - -int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf, - unsigned int *output_size) -{ - LOGV("%s :", __func__); - - int index; - //unsigned int addr; - unsigned char *addr; - int ret = 0; - - LOG_TIME_DEFINE(0) - LOG_TIME_DEFINE(1) - LOG_TIME_DEFINE(2) - LOG_TIME_DEFINE(3) - LOG_TIME_DEFINE(4) - LOG_TIME_DEFINE(5) - - //fimc_v4l2_streamoff(m_cam_fd); [zzangdol] remove - it is separate in HWInterface with camera_id - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - if (m_flag_camera_start > 0) { - LOG_TIME_START(0) - LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__); - stopPreview(); - LOG_TIME_END(0) - } - - memset(&m_events_c, 0, sizeof(m_events_c)); - m_events_c.fd = m_cam_fd; - m_events_c.events = POLLIN | POLLERR; - -#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 - if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420) - LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV420"); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12) - LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12"); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T) - LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12T"); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21) - LOGV("SnapshotFormat:V4L2_PIX_FMT_NV21"); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P) - LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV422P"); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV) - LOGV("SnapshotFormat:V4L2_PIX_FMT_YUYV"); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY) - LOGV("SnapshotFormat:V4L2_PIX_FMT_UYVY"); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) - LOGV("SnapshotFormat:V4L2_PIX_FMT_RGB565"); - else - LOGV("SnapshotFormat:UnknownFormat"); -#endif - - LOG_TIME_START(1) // prepare - int nframe = 1; - - ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat); - CHECK(ret); - ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat); - CHECK(ret); - ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); - CHECK(ret); - ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE); - CHECK(ret); - - ret = fimc_v4l2_qbuf(m_cam_fd, 0); - CHECK(ret); - - ret = fimc_v4l2_streamon(m_cam_fd); - CHECK(ret); - LOG_TIME_END(1) - - LOG_TIME_START(2) // capture - fimc_poll(&m_events_c); - index = fimc_v4l2_dqbuf(m_cam_fd); - fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0); - LOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d\n\n", - index, m_snapshot_width, m_snapshot_height); - - LOG_TIME_END(2) - - LOGI("%s : calling memcpy from m_capture_buf", __func__); - memcpy(yuv_buf, (unsigned char*)m_capture_buf.start, m_snapshot_width * m_snapshot_height * 2); - LOG_TIME_START(5) // post - fimc_v4l2_streamoff(m_cam_fd); - LOG_TIME_END(5) - - LOG_CAMERA("getSnapshotAndJpeg intervals : stopPreview(%lu), prepare(%lu)," - " capture(%lu), memcpy(%lu), yuv2Jpeg(%lu), post(%lu) us", - LOG_TIME(0), LOG_TIME(1), LOG_TIME(2), LOG_TIME(3), LOG_TIME(4), LOG_TIME(5)); - /* JPEG encoding */ - JpegEncoder jpgEnc; - int inFormat = JPG_MODESEL_YCBCR; - int outFormat = JPG_422; - - switch (m_snapshot_v4lformat) { - case V4L2_PIX_FMT_NV12: - case V4L2_PIX_FMT_NV21: - case V4L2_PIX_FMT_NV12T: - case V4L2_PIX_FMT_YUV420: - outFormat = JPG_420; - break; - case V4L2_PIX_FMT_YUYV: - case V4L2_PIX_FMT_UYVY: - case V4L2_PIX_FMT_YUV422P: - default: - outFormat = JPG_422; - break; - } - - if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS) - LOGE("[JPEG_SET_ENCODE_IN_FORMAT] Error\n"); - - if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS) - LOGE("[JPEG_SET_SAMPING_MODE] Error\n"); - - image_quality_type_t jpegQuality; - if (m_jpeg_quality >= 90) - jpegQuality = JPG_QUALITY_LEVEL_1; - else if (m_jpeg_quality >= 80) - jpegQuality = JPG_QUALITY_LEVEL_2; - else if (m_jpeg_quality >= 70) - jpegQuality = JPG_QUALITY_LEVEL_3; - else - jpegQuality = JPG_QUALITY_LEVEL_4; - - if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, jpegQuality) != JPG_SUCCESS) - LOGE("[JPEG_SET_ENCODE_QUALITY] Error\n"); - if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, m_snapshot_width) != JPG_SUCCESS) - LOGE("[JPEG_SET_ENCODE_WIDTH] Error\n"); - - if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, m_snapshot_height) != JPG_SUCCESS) - LOGE("[JPEG_SET_ENCODE_HEIGHT] Error\n"); - - unsigned int snapshot_size = m_snapshot_width * m_snapshot_height * 2; - unsigned char *pInBuf = (unsigned char *)jpgEnc.getInBuf(snapshot_size); - - if (pInBuf == NULL) { - LOGE("JPEG input buffer is NULL!!\n"); - return -1; - } - memcpy(pInBuf, yuv_buf, snapshot_size); - - setExifChangedAttribute(); - jpgEnc.encode(output_size, &mExifInfo); - - uint64_t outbuf_size; - unsigned char *pOutBuf = (unsigned char *)jpgEnc.getOutBuf(&outbuf_size); - - if (pOutBuf == NULL) { - LOGE("JPEG output buffer is NULL!!\n"); - return -1; - } - - memcpy(jpeg_buf, pOutBuf, outbuf_size); - - return 0; -} - - -int SecCamera::setSnapshotSize(int width, int height) -{ - LOGV("%s(width(%d), height(%d))", __func__, width, height); - - m_snapshot_width = width; - m_snapshot_height = height; - - return 0; -} - -int SecCamera::getSnapshotSize(int *width, int *height, int *frame_size) -{ - *width = m_snapshot_width; - *height = m_snapshot_height; - - int frame = 0; - - frame = m_frameSize(m_snapshot_v4lformat, m_snapshot_width, m_snapshot_height); - - // set it big. - if (frame == 0) - frame = m_snapshot_width * m_snapshot_height * BPP; - - *frame_size = frame; - - return 0; -} - -int SecCamera::getSnapshotMaxSize(int *width, int *height) -{ - switch (m_camera_id) { - case CAMERA_ID_FRONT: - m_snapshot_max_width = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH; - m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT; - break; - - default: - case CAMERA_ID_BACK: - m_snapshot_max_width = MAX_BACK_CAMERA_SNAPSHOT_WIDTH; - m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT; - break; - } - - *width = m_snapshot_max_width; - *height = m_snapshot_max_height; - - return 0; -} - -int SecCamera::setSnapshotPixelFormat(int pixel_format) -{ - int v4lpixelformat= pixel_format; - - if (m_snapshot_v4lformat != v4lpixelformat) { - m_snapshot_v4lformat = v4lpixelformat; - } - -#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 - if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420) - LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12) - LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T) - LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21) - LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P) - LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV) - LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY) - LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__); - else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) - LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__); - else - LOGD("SnapshotFormat:UnknownFormat"); -#endif - return 0; -} - -int SecCamera::getSnapshotPixelFormat(void) -{ - return m_snapshot_v4lformat; -} - -// ====================================================================== -// Settings - -int SecCamera::getCameraId(void) -{ - return m_camera_id; -} - -// ----------------------------------- - -int SecCamera::setAutofocus(void) -{ - LOGV("%s :", __func__); - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__); - return -1; - } - - return 0; -} - -int SecCamera::getAutoFocusResult(void) -{ - int af_result; - - af_result = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT); - - LOGV("%s : returning %d", __func__, af_result); - - return af_result; -} - -int SecCamera::cancelAutofocus(void) -{ - LOGV("%s :", __func__); - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__); - return -1; - } - - return 0; -} - -// ----------------------------------- - -int SecCamera::zoomIn(void) -{ - LOGV("%s :", __func__); - return 0; -} - -int SecCamera::zoomOut(void) -{ - LOGV("%s :", __func__); - return 0; -} - -// ----------------------------------- - -int SecCamera::SetRotate(int angle) -{ - LOGE("%s(angle(%d))", __func__, angle); - - if (m_angle != angle) { - switch (angle) { - case -360: - case 0: - case 360: - m_angle = 0; - break; - - case -270: - case 90: - m_angle = 90; - break; - - case -180: - case 180: - m_angle = 180; - break; - - case -90: - case 270: - m_angle = 270; - break; - - default: - LOGE("ERR(%s):Invalid angle(%d)", __func__, angle); - return -1; - } - - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_ROTATION, angle) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_ROTATION", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getRotate(void) -{ - LOGV("%s : angle(%d)", __func__, m_angle); - return m_angle; -} - -int SecCamera::setFrameRate(int frame_rate) -{ - LOGV("%s(FrameRate(%d))", __func__, frame_rate); - - if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate ) - LOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate); - - if (m_params->capture.timeperframe.denominator != (unsigned)frame_rate) { - m_params->capture.timeperframe.denominator = frame_rate; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__); - return -1; - } - } - } - - return 0; -} - -// ----------------------------------- - -int SecCamera::setVerticalMirror(void) -{ - LOGV("%s :", __func__); - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_VFLIP, 0) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __func__); - return -1; - } - - return 0; -} - -int SecCamera::setHorizontalMirror(void) -{ - LOGV("%s :", __func__); - - if (m_cam_fd <= 0) { - LOGE("ERR(%s):Camera was closed\n", __func__); - return -1; - } - - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_HFLIP, 0) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_HFLIP", __func__); - return -1; - } - - return 0; -} - -// ----------------------------------- - -int SecCamera::setWhiteBalance(int white_balance) -{ - LOGV("%s(white_balance(%d))", __func__, white_balance); - - if (white_balance <= WHITE_BALANCE_BASE || WHITE_BALANCE_MAX <= white_balance) { - LOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance); - return -1; - } - - if (m_params->white_balance != white_balance) { - m_params->white_balance = white_balance; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, white_balance) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getWhiteBalance(void) -{ - LOGV("%s : white_balance(%d)", __func__, m_params->white_balance); - return m_params->white_balance; -} - -// ----------------------------------- - -int SecCamera::setBrightness(int brightness) -{ - LOGV("%s(brightness(%d))", __func__, brightness); - - brightness += EV_DEFAULT; - - if (brightness < EV_MINUS_4 || EV_PLUS_4 < brightness) { - LOGE("ERR(%s):Invalid brightness(%d)", __func__, brightness); - return -1; - } - - if (m_params->brightness != brightness) { - m_params->brightness = brightness; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, brightness) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BRIGHTNESS", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getBrightness(void) -{ - LOGV("%s : brightness(%d)", __func__, m_params->brightness); - return m_params->brightness; -} - -// ----------------------------------- - -int SecCamera::setImageEffect(int image_effect) -{ - LOGV("%s(image_effect(%d))", __func__, image_effect); - - if (image_effect <= IMAGE_EFFECT_BASE || IMAGE_EFFECT_MAX <= image_effect) { - LOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect); - return -1; - } - - if (m_params->effects != image_effect) { - m_params->effects = image_effect; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, image_effect) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getImageEffect(void) -{ - LOGV("%s : image_effect(%d)", __func__, m_params->effects); - return m_params->effects; -} - -// ====================================================================== -int SecCamera::setAntiBanding(int anti_banding) -{ - LOGV("%s(anti_banding(%d))", __func__, anti_banding); - - if (anti_banding < ANTI_BANDING_AUTO || ANTI_BANDING_OFF < anti_banding) { - LOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding); - return -1; - } - - if (m_anti_banding != anti_banding) { - m_anti_banding = anti_banding; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_BANDING, anti_banding) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_BANDING", __func__); - return -1; - } - } - } - - return 0; -} - -//====================================================================== -int SecCamera::setSceneMode(int scene_mode) -{ - LOGV("%s(scene_mode(%d))", __func__, scene_mode); - - if (scene_mode <= SCENE_MODE_BASE || SCENE_MODE_MAX <= scene_mode) { - LOGE("ERR(%s):Invalid scene_mode (%d)", __func__, scene_mode); - return -1; - } - - if (m_params->scene_mode != scene_mode) { - m_params->scene_mode = scene_mode; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, scene_mode) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getSceneMode(void) -{ - return m_params->scene_mode; -} - -//====================================================================== - -int SecCamera::setFlashMode(int flash_mode) -{ - LOGV("%s(flash_mode(%d))", __func__, flash_mode); - - if (flash_mode <= FLASH_MODE_BASE || FLASH_MODE_MAX <= flash_mode) { - LOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode); - return -1; - } - - if (m_params->flash_mode != flash_mode) { - m_params->flash_mode = flash_mode; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FLASH_MODE, flash_mode) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FLASH_MODE", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getFlashMode(void) -{ - return m_params->flash_mode; -} - -//====================================================================== - -int SecCamera::setISO(int iso_value) -{ - LOGV("%s(iso_value(%d))", __func__, iso_value); - if (iso_value < ISO_AUTO || ISO_MAX <= iso_value) { - LOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value); - return -1; - } - - if (m_params->iso != iso_value) { - m_params->iso = iso_value; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, iso_value) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getISO(void) -{ - return m_params->iso; -} - -//====================================================================== - -int SecCamera::setContrast(int contrast_value) -{ - LOGV("%s(contrast_value(%d))", __func__, contrast_value); - - if (contrast_value < CONTRAST_MINUS_2 || CONTRAST_MAX <= contrast_value) { - LOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value); - return -1; - } - - if (m_params->contrast != contrast_value) { - m_params->contrast = contrast_value; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, contrast_value) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CONTRAST", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getContrast(void) -{ - return m_params->contrast; -} - -//====================================================================== - -int SecCamera::setSaturation(int saturation_value) -{ - LOGV("%s(saturation_value(%d))", __func__, saturation_value); - - if (saturation_value saturation != saturation_value) { - m_params->saturation = saturation_value; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, saturation_value) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getSaturation(void) -{ - return m_params->saturation; -} - -//====================================================================== - -int SecCamera::setSharpness(int sharpness_value) -{ - LOGV("%s(sharpness_value(%d))", __func__, sharpness_value); - - if (sharpness_value < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= sharpness_value) { - LOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value); - return -1; - } - - if (m_params->sharpness != sharpness_value) { - m_params->sharpness = sharpness_value; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, sharpness_value) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getSharpness(void) -{ - return m_params->sharpness; -} - -//====================================================================== - -int SecCamera::setWDR(int wdr_value) -{ - LOGV("%s(wdr_value(%d))", __func__, wdr_value); - - if (wdr_value < WDR_OFF || WDR_MAX <= wdr_value) { - LOGE("ERR(%s):Invalid wdr_value (%d)", __func__, wdr_value); - return -1; - } - - if (m_wdr != wdr_value) { - m_wdr = wdr_value; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WDR, wdr_value) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WDR", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getWDR(void) -{ - return m_wdr; -} - -//====================================================================== - -int SecCamera::setAntiShake(int anti_shake) -{ - LOGV("%s(anti_shake(%d))", __func__, anti_shake); - - if (anti_shake < ANTI_SHAKE_OFF || ANTI_SHAKE_MAX <= anti_shake) { - LOGE("ERR(%s):Invalid anti_shake (%d)", __func__, anti_shake); - return -1; - } - - if (m_anti_shake != anti_shake) { - m_anti_shake = anti_shake; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_SHAKE, anti_shake) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_SHAKE", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getAntiShake(void) -{ - return m_anti_shake; -} - -//====================================================================== - - -int SecCamera::setMetering(int metering_value) -{ - LOGV("%s(metering (%d))", __func__, metering_value); - - if (metering_value <= METERING_BASE || METERING_MAX <= metering_value) { - LOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value); - return -1; - } - - if (m_params->metering != metering_value) { - m_params->metering = metering_value; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, metering_value) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getMetering(void) -{ - return m_params->metering; -} - -//====================================================================== - -int SecCamera::setJpegQuality(int jpeg_quality) -{ - LOGV("%s(jpeg_quality (%d))", __func__, jpeg_quality); - - if (jpeg_quality < JPEG_QUALITY_ECONOMY || JPEG_QUALITY_MAX <= jpeg_quality) { - LOGE("ERR(%s):Invalid jpeg_quality (%d)", __func__, jpeg_quality); - return -1; - } - - if (m_jpeg_quality != jpeg_quality) { - m_jpeg_quality = jpeg_quality; - if (m_flag_camera_start && (m_camera_id == CAMERA_ID_BACK)) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAM_JPEG_QUALITY", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getJpegQuality(void) -{ - return m_jpeg_quality; -} - -//====================================================================== - -int SecCamera::setZoom(int zoom_level) -{ - LOGV("%s(zoom_level (%d))", __func__, zoom_level); - - if (zoom_level < ZOOM_LEVEL_0 || ZOOM_LEVEL_MAX <= zoom_level) { - LOGE("ERR(%s):Invalid zoom_level (%d)", __func__, zoom_level); - return -1; - } - - if (m_zoom_level != zoom_level) { - m_zoom_level = zoom_level; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ZOOM, zoom_level) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ZOOM", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getZoom(void) -{ - return m_zoom_level; -} - -//====================================================================== - -int SecCamera::setObjectTracking(int object_tracking) -{ - LOGV("%s(object_tracking (%d))", __func__, object_tracking); - - if (object_tracking < OBJECT_TRACKING_OFF || OBJECT_TRACKING_MAX <= object_tracking) { - LOGE("ERR(%s):Invalid object_tracking (%d)", __func__, object_tracking); - return -1; - } - - if (m_object_tracking != object_tracking) { - m_object_tracking = object_tracking; - } - - return 0; -} - -int SecCamera::getObjectTracking(void) -{ - return m_object_tracking; -} - -int SecCamera::getObjectTrackingStatus(void) -{ - int obj_status = 0; - obj_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_STATUS); - return obj_status; -} - -int SecCamera::setObjectTrackingStartStop(int start_stop) -{ - LOGV("%s(object_tracking_start_stop (%d))", __func__, start_stop); - - if (m_object_tracking_start_stop != start_stop) { - m_object_tracking_start_stop = start_stop; - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, start_stop) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP", __func__); - return -1; - } - } - - return 0; -} - -int SecCamera::setTouchAFStartStop(int start_stop) -{ - LOGV("%s(touch_af_start_stop (%d))", __func__, start_stop); - - if (m_touch_af_start_stop != start_stop) { - m_touch_af_start_stop = start_stop; - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, start_stop) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_TOUCH_AF_START_STOP", __func__); - return -1; - } - } - - return 0; -} - -//====================================================================== - -int SecCamera::setSmartAuto(int smart_auto) -{ - LOGV("%s(smart_auto (%d))", __func__, smart_auto); - - if (smart_auto < SMART_AUTO_OFF || SMART_AUTO_MAX <= smart_auto) { - LOGE("ERR(%s):Invalid smart_auto (%d)", __func__, smart_auto); - return -1; - } - - if (m_smart_auto != smart_auto) { - m_smart_auto = smart_auto; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO, smart_auto) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SMART_AUTO", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getSmartAuto(void) -{ - return m_smart_auto; -} - -int SecCamera::getAutosceneStatus(void) -{ - int autoscene_status = -1; - - if (getSmartAuto() == SMART_AUTO_ON) { - autoscene_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS); - - if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) { - LOGE("ERR(%s):Invalid getAutosceneStatus (%d)", __func__, autoscene_status); - return -1; - } - } - //LOGV("%s : autoscene_status (%d)", __func__, autoscene_status); - return autoscene_status; -} -//====================================================================== - -int SecCamera::setBeautyShot(int beauty_shot) -{ - LOGV("%s(beauty_shot (%d))", __func__, beauty_shot); - - if (beauty_shot < BEAUTY_SHOT_OFF || BEAUTY_SHOT_MAX <= beauty_shot) { - LOGE("ERR(%s):Invalid beauty_shot (%d)", __func__, beauty_shot); - return -1; - } - - if (m_beauty_shot != beauty_shot) { - m_beauty_shot = beauty_shot; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beauty_shot) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BEAUTY_SHOT", __func__); - return -1; - } - } - - setFaceDetect(FACE_DETECTION_ON_BEAUTY); - } - - return 0; -} - -int SecCamera::getBeautyShot(void) -{ - return m_beauty_shot; -} - -//====================================================================== - -int SecCamera::setVintageMode(int vintage_mode) -{ - LOGV("%s(vintage_mode(%d))", __func__, vintage_mode); - - if (vintage_mode <= VINTAGE_MODE_BASE || VINTAGE_MODE_MAX <= vintage_mode) { - LOGE("ERR(%s):Invalid vintage_mode (%d)", __func__, vintage_mode); - return -1; - } - - if (m_vintage_mode != vintage_mode) { - m_vintage_mode = vintage_mode; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VINTAGE_MODE, vintage_mode) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VINTAGE_MODE", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getVintageMode(void) -{ - return m_vintage_mode; -} - -//====================================================================== - -int SecCamera::setFocusMode(int focus_mode) -{ - LOGV("%s(focus_mode(%d))", __func__, focus_mode); - - if (FOCUS_MODE_MAX <= focus_mode) { - LOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode); - return -1; - } - - if (m_params->focus_mode != focus_mode) { - m_params->focus_mode = focus_mode; - - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getFocusMode(void) -{ - return m_params->focus_mode; -} - -//====================================================================== - -int SecCamera::setFaceDetect(int face_detect) -{ - LOGV("%s(face_detect(%d))", __func__, face_detect); - - if (m_face_detect != face_detect) { - m_face_detect = face_detect; - if (m_flag_camera_start) { - if (m_face_detect != FACE_DETECTION_OFF) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODin face detecion", __func__); - return -1; - } - } - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACE_DETECTION, face_detect) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACE_DETECTION", __func__); - return -1; - } - } - } - - return 0; -} - -int SecCamera::getFaceDetect(void) -{ - return m_face_detect; -} - -//====================================================================== - -int SecCamera::setGPSLatitude(const char *gps_latitude) -{ - double conveted_latitude = 0; - LOGV("%s(gps_latitude(%s))", __func__, gps_latitude); - if (gps_latitude == NULL) - m_gps_latitude = 0; - else { - conveted_latitude = atof(gps_latitude); - m_gps_latitude = (long)(conveted_latitude * 10000 / 1); - } - - LOGV("%s(m_gps_latitude(%ld))", __func__, m_gps_latitude); - return 0; -} - -int SecCamera::setGPSLongitude(const char *gps_longitude) -{ - double conveted_longitude = 0; - LOGV("%s(gps_longitude(%s))", __func__, gps_longitude); - if (gps_longitude == NULL) - m_gps_longitude = 0; - else { - conveted_longitude = atof(gps_longitude); - m_gps_longitude = (long)(conveted_longitude * 10000 / 1); - } - - LOGV("%s(m_gps_longitude(%ld))", __func__, m_gps_longitude); - return 0; -} - -int SecCamera::setGPSAltitude(const char *gps_altitude) -{ - double conveted_altitude = 0; - LOGV("%s(gps_altitude(%s))", __func__, gps_altitude); - if (gps_altitude == NULL) - m_gps_altitude = 0; - else { - conveted_altitude = atof(gps_altitude); - m_gps_altitude = (long)(conveted_altitude * 100 / 1); - } - - LOGV("%s(m_gps_altitude(%ld))", __func__, m_gps_altitude); - return 0; -} - -int SecCamera::setGPSTimeStamp(const char *gps_timestamp) -{ - LOGV("%s(gps_timestamp(%s))", __func__, gps_timestamp); - if (gps_timestamp == NULL) - m_gps_timestamp = 0; - else - m_gps_timestamp = atol(gps_timestamp); - - LOGV("%s(m_gps_timestamp(%ld))", __func__, m_gps_timestamp); - return 0; -} - -int SecCamera::setGPSProcessingMethod(const char *gps_processing_method) -{ - LOGV("%s(gps_processing_method(%s))", __func__, gps_processing_method); - memset(mExifInfo.gps_processing_method, 0, sizeof(mExifInfo.gps_processing_method)); - if (gps_processing_method != NULL) { - size_t len = strlen(gps_processing_method); - if (len > sizeof(mExifInfo.gps_processing_method)) { - len = sizeof(mExifInfo.gps_processing_method); - } - memcpy(mExifInfo.gps_processing_method, gps_processing_method, len); - } - return 0; -} - -int SecCamera::setFaceDetectLockUnlock(int facedetect_lockunlock) -{ - LOGV("%s(facedetect_lockunlock(%d))", __func__, facedetect_lockunlock); - - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK, facedetect_lockunlock) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK", __func__); - return -1; - } - - return 0; -} - -int SecCamera::setObjectPosition(int x, int y) -{ - LOGV("%s(setObjectPosition(x=%d, y=%d))", __func__, x, y); - - if (m_preview_width ==640) - x = x - 80; - - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_X, x) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_X", __func__); - return -1; - } - - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_Y, y) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_Y", __func__); - return -1; - } - - return 0; -} - -//====================================================================== - -int SecCamera::setGamma(int gamma) -{ - LOGV("%s(gamma(%d))", __func__, gamma); - - if (gamma < GAMMA_OFF || GAMMA_MAX <= gamma) { - LOGE("ERR(%s):Invalid gamma (%d)", __func__, gamma); - return -1; - } - - if (m_video_gamma != gamma) { - m_video_gamma = gamma; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_GAMMA", __func__); - return -1; - } - } - } - - return 0; -} - -//====================================================================== - -int SecCamera::setSlowAE(int slow_ae) -{ - LOGV("%s(slow_ae(%d))", __func__, slow_ae); - - if (slow_ae < GAMMA_OFF || GAMMA_MAX <= slow_ae) { - LOGE("ERR(%s):Invalid slow_ae (%d)", __func__, slow_ae); - return -1; - } - - if (m_slow_ae!= slow_ae) { - m_slow_ae = slow_ae; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_SLOW_AE", __func__); - return -1; - } - } - } - - return 0; -} - -//====================================================================== -int SecCamera::setRecordingSize(int width, int height) -{ - LOGV("%s(width(%d), height(%d))", __func__, width, height); - - m_recording_width = width; - m_recording_height = height; - - return 0; -} - -//====================================================================== - -int SecCamera::setExifOrientationInfo(int orientationInfo) -{ - LOGV("%s(orientationInfo(%d))", __func__, orientationInfo); - - if (orientationInfo < 0) { - LOGE("ERR(%s):Invalid orientationInfo (%d)", __func__, orientationInfo); - return -1; - } - m_exif_orientation = orientationInfo; - - return 0; -} - -//====================================================================== -int SecCamera::setBatchReflection() -{ - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BATCH_REFLECTION, 1) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BATCH_REFLECTION", __func__); - return -1; - } - } - - return 0; -} - -/*Video call*/ -int SecCamera::setVTmode(int vtmode) -{ - LOGV("%s(vtmode (%d))", __func__, vtmode); - - if (vtmode < VT_MODE_OFF || VT_MODE_MAX <= vtmode) { - LOGE("ERR(%s):Invalid vtmode (%d)", __func__, vtmode); - return -1; - } - - if (m_vtmode != vtmode) { - m_vtmode = vtmode; - } - - return 0; -} - -/* Camcorder fix fps */ -int SecCamera::setSensorMode(int sensor_mode) -{ - LOGV("%s(sensor_mode (%d))", __func__, sensor_mode); - - if (sensor_mode < SENSOR_MODE_CAMERA || SENSOR_MODE_MOVIE < sensor_mode) { - LOGE("ERR(%s):Invalid sensor mode (%d)", __func__, sensor_mode); - return -1; - } - - if (m_sensor_mode != sensor_mode) { - m_sensor_mode = sensor_mode; - } - - return 0; -} - -/* Shot mode */ -/* SINGLE = 0 -* CONTINUOUS = 1 -* PANORAMA = 2 -* SMILE = 3 -* SELF = 6 -*/ -int SecCamera::setShotMode(int shot_mode) -{ - LOGV("%s(shot_mode (%d))", __func__, shot_mode); - if (shot_mode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shot_mode) { - LOGE("ERR(%s):Invalid shot_mode (%d)", __func__, shot_mode); - return -1; - } - m_shot_mode = shot_mode; - - return 0; -} - -int SecCamera::getVTmode(void) -{ - return m_vtmode; -} - -int SecCamera::setBlur(int blur_level) -{ - LOGV("%s(level (%d))", __func__, blur_level); - - if (blur_level < BLUR_LEVEL_0 || BLUR_LEVEL_MAX <= blur_level) { - LOGE("ERR(%s):Invalid level (%d)", __func__, blur_level); - return -1; - } - - if (m_blur_level != blur_level) { - m_blur_level = blur_level; - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR, blur_level) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VGA_BLUR", __func__); - return -1; - } - } - } - return 0; -} - -int SecCamera::getBlur(void) -{ - return m_blur_level; -} - -int SecCamera::setDataLineCheck(int chk_dataline) -{ - LOGV("%s(chk_dataline (%d))", __func__, chk_dataline); - - if (chk_dataline < CHK_DATALINE_OFF || CHK_DATALINE_MAX <= chk_dataline) { - LOGE("ERR(%s):Invalid chk_dataline (%d)", __func__, chk_dataline); - return -1; - } - - if (m_chk_dataline != chk_dataline) { - m_chk_dataline = chk_dataline; - } - - return 0; -} - -int SecCamera::getDataLineCheck(void) -{ - return m_chk_dataline; -} - -int SecCamera::setDataLineCheckStop(void) -{ - LOGV("%s", __func__); - - if (m_flag_camera_start) { - if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CHECK_DATALINE_STOP, 1) < 0) { - LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CHECK_DATALINE_STOP", __func__); - return -1; - } - } - return 0; -} - -const __u8* SecCamera::getCameraSensorName(void) -{ - LOGV("%s", __func__); - - return fimc_v4l2_enuminput(m_cam_fd, getCameraId()); -} - -#ifdef ENABLE_ESD_PREVIEW_CHECK -int SecCamera::getCameraSensorESDStatus(void) -{ - LOGV("%s", __func__); - - // 0 : normal operation, 1 : abnormal operation - int status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_ESD_INT); - - return status; -} -#endif // ENABLE_ESD_PREVIEW_CHECK - -// ====================================================================== -// Jpeg - -int SecCamera::setJpegThumbnailSize(int width, int height) -{ - LOGV("%s(width(%d), height(%d))", __func__, width, height); - - m_jpeg_thumbnail_width = width; - m_jpeg_thumbnail_height = height; - - return 0; -} - -int SecCamera::getJpegThumbnailSize(int *width, int *height) -{ - if (width) - *width = m_jpeg_thumbnail_width; - if (height) - *height = m_jpeg_thumbnail_height; - - return 0; -} - -void SecCamera::setExifFixedAttribute() -{ - char property[PROPERTY_VALUE_MAX]; - - //2 0th IFD TIFF Tags - //3 Maker - property_get("ro.product.brand", property, EXIF_DEF_MAKER); - strncpy((char *)mExifInfo.maker, property, - sizeof(mExifInfo.maker) - 1); - mExifInfo.maker[sizeof(mExifInfo.maker) - 1] = '\0'; - //3 Model - property_get("ro.product.model", property, EXIF_DEF_MODEL); - strncpy((char *)mExifInfo.model, property, - sizeof(mExifInfo.model) - 1); - mExifInfo.model[sizeof(mExifInfo.model) - 1] = '\0'; - //3 Software - property_get("ro.build.id", property, EXIF_DEF_SOFTWARE); - strncpy((char *)mExifInfo.software, property, - sizeof(mExifInfo.software) - 1); - mExifInfo.software[sizeof(mExifInfo.software) - 1] = '\0'; - - //3 YCbCr Positioning - mExifInfo.ycbcr_positioning = EXIF_DEF_YCBCR_POSITIONING; - - //2 0th IFD Exif Private Tags - //3 F Number - mExifInfo.fnumber.num = EXIF_DEF_FNUMBER_NUM; - mExifInfo.fnumber.den = EXIF_DEF_FNUMBER_DEN; - //3 Exposure Program - mExifInfo.exposure_program = EXIF_DEF_EXPOSURE_PROGRAM; - //3 Exif Version - memcpy(mExifInfo.exif_version, EXIF_DEF_EXIF_VERSION, sizeof(mExifInfo.exif_version)); - //3 Aperture - uint32_t av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num/mExifInfo.fnumber.den); - mExifInfo.aperture.num = av*EXIF_DEF_APEX_DEN; - mExifInfo.aperture.den = EXIF_DEF_APEX_DEN; - //3 Maximum lens aperture - mExifInfo.max_aperture.num = mExifInfo.aperture.num; - mExifInfo.max_aperture.den = mExifInfo.aperture.den; - //3 Lens Focal Length - if (m_camera_id == CAMERA_ID_BACK) - mExifInfo.focal_length.num = BACK_CAMERA_FOCAL_LENGTH; - else - mExifInfo.focal_length.num = FRONT_CAMERA_FOCAL_LENGTH; - - mExifInfo.focal_length.den = EXIF_DEF_FOCAL_LEN_DEN; - //3 User Comments - strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS); - //3 Color Space information - mExifInfo.color_space = EXIF_DEF_COLOR_SPACE; - //3 Exposure Mode - mExifInfo.exposure_mode = EXIF_DEF_EXPOSURE_MODE; - - //2 0th IFD GPS Info Tags - unsigned char gps_version[4] = { 0x02, 0x02, 0x00, 0x00 }; - memcpy(mExifInfo.gps_version_id, gps_version, sizeof(gps_version)); - - //2 1th IFD TIFF Tags - mExifInfo.compression_scheme = EXIF_DEF_COMPRESSION; - mExifInfo.x_resolution.num = EXIF_DEF_RESOLUTION_NUM; - mExifInfo.x_resolution.den = EXIF_DEF_RESOLUTION_DEN; - mExifInfo.y_resolution.num = EXIF_DEF_RESOLUTION_NUM; - mExifInfo.y_resolution.den = EXIF_DEF_RESOLUTION_DEN; - mExifInfo.resolution_unit = EXIF_DEF_RESOLUTION_UNIT; -} - -void SecCamera::setExifChangedAttribute() -{ - //2 0th IFD TIFF Tags - //3 Width - mExifInfo.width = m_snapshot_width; - //3 Height - mExifInfo.height = m_snapshot_height; - //3 Orientation - switch (m_exif_orientation) { - case 0: - mExifInfo.orientation = EXIF_ORIENTATION_UP; - break; - case 90: - mExifInfo.orientation = EXIF_ORIENTATION_90; - break; - case 180: - mExifInfo.orientation = EXIF_ORIENTATION_180; - break; - case 270: - mExifInfo.orientation = EXIF_ORIENTATION_270; - break; - default: - mExifInfo.orientation = EXIF_ORIENTATION_UP; - break; - } - //3 Date time - time_t rawtime; - struct tm *timeinfo; - time(&rawtime); - timeinfo = localtime(&rawtime); - strftime((char *)mExifInfo.date_time, 20, "%Y:%m:%d %H:%M:%S", timeinfo); - - //2 0th IFD Exif Private Tags - //3 Exposure Time - int shutterSpeed = fimc_v4l2_g_ctrl(m_cam_fd, - V4L2_CID_CAMERA_GET_SHT_TIME); - /* TBD - front camera needs to be fixed to support this g_ctrl, - it current returns a negative err value, so avoid putting - odd value into exif for now */ - if (shutterSpeed < 0) { - LOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100", - __func__, shutterSpeed, m_camera_id); - shutterSpeed = 100; - } - mExifInfo.exposure_time.num = 1; - // x us -> 1/x s */ - mExifInfo.exposure_time.den = (uint32_t)(1000000 / shutterSpeed); - - //3 ISO Speed Rating - int iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_ISO); - /* TBD - front camera needs to be fixed to support this g_ctrl, - it current returns a negative err value, so avoid putting - odd value into exif for now */ - if (iso < 0) { - LOGE("%s: error %d getting iso, camera_id = %d, using 100", - __func__, iso, m_camera_id); - iso = ISO_100; - } - switch(iso) { - case ISO_50: - mExifInfo.iso_speed_rating = 50; - break; - case ISO_100: - mExifInfo.iso_speed_rating = 100; - break; - case ISO_200: - mExifInfo.iso_speed_rating = 200; - break; - case ISO_400: - mExifInfo.iso_speed_rating = 400; - break; - case ISO_800: - mExifInfo.iso_speed_rating = 800; - break; - case ISO_1600: - mExifInfo.iso_speed_rating = 1600; - break; - default: - mExifInfo.iso_speed_rating = 100; - break; - } - - uint32_t av, tv, bv, sv, ev; - av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num / mExifInfo.fnumber.den); - tv = APEX_EXPOSURE_TO_SHUTTER((double)mExifInfo.exposure_time.num / mExifInfo.exposure_time.den); - sv = APEX_ISO_TO_FILMSENSITIVITY(mExifInfo.iso_speed_rating); - bv = av + tv - sv; - ev = av + tv; - LOGD("Shutter speed=%d us, iso=%d\n", shutterSpeed, mExifInfo.iso_speed_rating); - LOGD("AV=%d, TV=%d, SV=%d\n", av, tv, sv); - - //3 Shutter Speed - mExifInfo.shutter_speed.num = tv*EXIF_DEF_APEX_DEN; - mExifInfo.shutter_speed.den = EXIF_DEF_APEX_DEN; - //3 Brightness - mExifInfo.brightness.num = bv*EXIF_DEF_APEX_DEN; - mExifInfo.brightness.den = EXIF_DEF_APEX_DEN; - //3 Exposure Bias - if (m_params->scene_mode == SCENE_MODE_BEACH_SNOW) { - mExifInfo.exposure_bias.num = EXIF_DEF_APEX_DEN; - mExifInfo.exposure_bias.den = EXIF_DEF_APEX_DEN; - } else { - mExifInfo.exposure_bias.num = 0; - mExifInfo.exposure_bias.den = 0; - } - //3 Metering Mode - switch (m_params->metering) { - case METERING_SPOT: - mExifInfo.metering_mode = EXIF_METERING_SPOT; - break; - case METERING_MATRIX: - mExifInfo.metering_mode = EXIF_METERING_AVERAGE; - break; - case METERING_CENTER: - mExifInfo.metering_mode = EXIF_METERING_CENTER; - break; - default : - mExifInfo.metering_mode = EXIF_METERING_AVERAGE; - break; - } - - //3 Flash - int flash = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_FLASH_ONOFF); - if (flash < 0) - mExifInfo.flash = EXIF_DEF_FLASH; - else - mExifInfo.flash = flash; - - //3 White Balance - if (m_params->white_balance == WHITE_BALANCE_AUTO) - mExifInfo.white_balance = EXIF_WB_AUTO; - else - mExifInfo.white_balance = EXIF_WB_MANUAL; - //3 Scene Capture Type - switch (m_params->scene_mode) { - case SCENE_MODE_PORTRAIT: - mExifInfo.scene_capture_type = EXIF_SCENE_PORTRAIT; - break; - case SCENE_MODE_LANDSCAPE: - mExifInfo.scene_capture_type = EXIF_SCENE_LANDSCAPE; - break; - case SCENE_MODE_NIGHTSHOT: - mExifInfo.scene_capture_type = EXIF_SCENE_NIGHT; - break; - default: - mExifInfo.scene_capture_type = EXIF_SCENE_STANDARD; - break; - } - - //2 0th IFD GPS Info Tags - if (m_gps_latitude != 0 && m_gps_longitude != 0) { - if (m_gps_latitude > 0) - strcpy((char *)mExifInfo.gps_latitude_ref, "N"); - else - strcpy((char *)mExifInfo.gps_latitude_ref, "S"); - - if (m_gps_longitude > 0) - strcpy((char *)mExifInfo.gps_longitude_ref, "E"); - else - strcpy((char *)mExifInfo.gps_longitude_ref, "W"); - - if (m_gps_altitude > 0) - mExifInfo.gps_altitude_ref = 0; - else - mExifInfo.gps_altitude_ref = 1; - - double latitude = fabs(m_gps_latitude / 10000.0); - double longitude = fabs(m_gps_longitude / 10000.0); - double altitude = fabs(m_gps_altitude / 100.0); - - mExifInfo.gps_latitude[0].num = (uint32_t)latitude; - mExifInfo.gps_latitude[0].den = 1; - mExifInfo.gps_latitude[1].num = (uint32_t)((latitude - mExifInfo.gps_latitude[0].num) * 60); - mExifInfo.gps_latitude[1].den = 1; - mExifInfo.gps_latitude[2].num = (uint32_t)((((latitude - mExifInfo.gps_latitude[0].num) * 60) - - mExifInfo.gps_latitude[1].num) * 60); - mExifInfo.gps_latitude[2].den = 1; - - mExifInfo.gps_longitude[0].num = (uint32_t)longitude; - mExifInfo.gps_longitude[0].den = 1; - mExifInfo.gps_longitude[1].num = (uint32_t)((longitude - mExifInfo.gps_longitude[0].num) * 60); - mExifInfo.gps_longitude[1].den = 1; - mExifInfo.gps_longitude[2].num = (uint32_t)((((longitude - mExifInfo.gps_longitude[0].num) * 60) - - mExifInfo.gps_longitude[1].num) * 60); - mExifInfo.gps_longitude[2].den = 1; - - mExifInfo.gps_altitude.num = (uint32_t)altitude; - mExifInfo.gps_altitude.den = 1; - - struct tm tm_data; - gmtime_r(&m_gps_timestamp, &tm_data); - mExifInfo.gps_timestamp[0].num = tm_data.tm_hour; - mExifInfo.gps_timestamp[0].den = 1; - mExifInfo.gps_timestamp[1].num = tm_data.tm_min; - mExifInfo.gps_timestamp[1].den = 1; - mExifInfo.gps_timestamp[2].num = tm_data.tm_sec; - mExifInfo.gps_timestamp[2].den = 1; - snprintf((char*)mExifInfo.gps_datestamp, sizeof(mExifInfo.gps_datestamp), - "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon, tm_data.tm_mday); - - mExifInfo.enableGps = true; - } else { - mExifInfo.enableGps = false; - } - - //2 1th IFD TIFF Tags - mExifInfo.widthThumb = m_jpeg_thumbnail_width; - mExifInfo.heightThumb = m_jpeg_thumbnail_height; -} - -// ====================================================================== -// Conversions - -inline int SecCamera::m_frameSize(int format, int width, int height) -{ - int size = 0; - - switch (format) { - case V4L2_PIX_FMT_YUV420: - case V4L2_PIX_FMT_NV12: - case V4L2_PIX_FMT_NV21: - size = (width * height * 3 / 2); - break; - - case V4L2_PIX_FMT_NV12T: - size = ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)) + - ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2)); - break; - - case V4L2_PIX_FMT_YUV422P: - case V4L2_PIX_FMT_YUYV: - case V4L2_PIX_FMT_UYVY: - size = (width * height * 2); - break; - - default : - LOGE("ERR(%s):Invalid V4L2 pixel format(%d)\n", __func__, format); - case V4L2_PIX_FMT_RGB565: - size = (width * height * BPP); - break; - } - - return size; -} - -status_t SecCamera::dump(int fd, const Vector &args) -{ - const size_t SIZE = 256; - char buffer[SIZE]; - String8 result; - snprintf(buffer, 255, "dump(%d)\n", fd); - result.append(buffer); - ::write(fd, result.string(), result.size()); - return NO_ERROR; -} - -double SecCamera::jpeg_ratio = 0.7; -int SecCamera::interleaveDataSize = 4261248; -int SecCamera::jpegLineLength = 636; - -}; // namespace android diff --git a/libcamera/SecCamera.h b/libcamera/SecCamera.h deleted file mode 100644 index b846201..0000000 --- a/libcamera/SecCamera.h +++ /dev/null @@ -1,538 +0,0 @@ -/* -** -** Copyright 2008, The Android Open Source Project -** Copyright 2010, Samsung Electronics Co. LTD -** -** 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_SEC_H -#define ANDROID_HARDWARE_CAMERA_SEC_H - -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include "JpegEncoder.h" - -#include - -namespace android { - -#define ENABLE_ESD_PREVIEW_CHECK - -#if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 -#define LOG_CAMERA LOGD -#define LOG_CAMERA_PREVIEW LOGD - -#define LOG_TIME_DEFINE(n) \ - struct timeval time_start_##n, time_stop_##n; unsigned long log_time_##n = 0; - -#define LOG_TIME_START(n) \ - gettimeofday(&time_start_##n, NULL); - -#define LOG_TIME_END(n) \ - gettimeofday(&time_stop_##n, NULL); log_time_##n = measure_time(&time_start_##n, &time_stop_##n); - -#define LOG_TIME(n) \ - log_time_##n - -#else -#define LOG_CAMERA(...) -#define LOG_CAMERA_PREVIEW(...) -#define LOG_TIME_DEFINE(n) -#define LOG_TIME_START(n) -#define LOG_TIME_END(n) -#define LOG_TIME(n) -#endif - -#define MAX_BACK_CAMERA_PREVIEW_WIDTH 720 -#define MAX_BACK_CAMERA_PREVIEW_HEIGHT 480 -#define MAX_BACK_CAMERA_SNAPSHOT_WIDTH 2560 -#define MAX_BACK_CAMERA_SNAPSHOT_HEIGHT 1920 -#define BACK_CAMERA_POSTVIEW_WIDTH 640 -#define BACK_CAMERA_POSTVIEW_WIDE_WIDTH 800 -#define BACK_CAMERA_POSTVIEW_HEIGHT 480 -#define BACK_CAMERA_POSTVIEW_BPP 16 -#define BACK_CAMERA_THUMBNAIL_WIDTH 320 -#define BACK_CAMERA_THUMBNAIL_HEIGHT 240 -#define BACK_CAMERA_THUMBNAIL_BPP 16 - -#define BACK_CAMERA_FOCAL_LENGTH 379 /* 3.79mm */ - -#define MAX_FRONT_CAMERA_PREVIEW_WIDTH 640 -#define MAX_FRONT_CAMERA_PREVIEW_HEIGHT 480 -#define MAX_FRONT_CAMERA_SNAPSHOT_WIDTH 640 -#define MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT 480 - -#define FRONT_CAMERA_THUMBNAIL_WIDTH 160 -#define FRONT_CAMERA_THUMBNAIL_HEIGHT 120 -#define FRONT_CAMERA_THUMBNAIL_BPP 16 -#define FRONT_CAMERA_FOCAL_LENGTH 130 /* 1.3mm */ - -#define DEFAULT_JPEG_THUMBNAIL_WIDTH 256 -#define DEFAULT_JPEG_THUMBNAIL_HEIGHT 192 - -#ifndef CAMERA_DEV_NAME -#define CAMERA_DEV_NAME "/dev/video0" -#endif -#ifndef CAMERA_DEV_NAME2 -#define CAMERA_DEV_NAME2 "/dev/video2" -#endif - -#define CAMERA_DEV_NAME_TEMP "/data/videotmp_000" -#define CAMERA_DEV_NAME2_TEMP "/data/videotemp_002" - - -#define BPP 2 -#define MIN(x, y) (((x) < (y)) ? (x) : (y)) -#define MAX_BUFFERS 11 - -/* - * V 4 L 2 F I M C E X T E N S I O N S - * - */ -#define V4L2_CID_ROTATION (V4L2_CID_PRIVATE_BASE + 0) -#define V4L2_CID_PADDR_Y (V4L2_CID_PRIVATE_BASE + 1) -#define V4L2_CID_PADDR_CB (V4L2_CID_PRIVATE_BASE + 2) -#define V4L2_CID_PADDR_CR (V4L2_CID_PRIVATE_BASE + 3) -#define V4L2_CID_PADDR_CBCR (V4L2_CID_PRIVATE_BASE + 4) -#define V4L2_CID_STREAM_PAUSE (V4L2_CID_PRIVATE_BASE + 53) - -#define V4L2_CID_CAM_JPEG_MAIN_SIZE (V4L2_CID_PRIVATE_BASE + 32) -#define V4L2_CID_CAM_JPEG_MAIN_OFFSET (V4L2_CID_PRIVATE_BASE + 33) -#define V4L2_CID_CAM_JPEG_THUMB_SIZE (V4L2_CID_PRIVATE_BASE + 34) -#define V4L2_CID_CAM_JPEG_THUMB_OFFSET (V4L2_CID_PRIVATE_BASE + 35) -#define V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET (V4L2_CID_PRIVATE_BASE + 36) -#define V4L2_CID_CAM_JPEG_QUALITY (V4L2_CID_PRIVATE_BASE + 37) - -#define TPATTERN_COLORBAR 1 -#define TPATTERN_HORIZONTAL 2 -#define TPATTERN_VERTICAL 3 - -#define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') - -/* FOURCC for FIMC specific */ -#define V4L2_PIX_FMT_VYUY v4l2_fourcc('V', 'Y', 'U', 'Y') -#define V4L2_PIX_FMT_NV16 v4l2_fourcc('N', 'V', '1', '6') -#define V4L2_PIX_FMT_NV61 v4l2_fourcc('N', 'V', '6', '1') -#define V4L2_PIX_FMT_NV12T v4l2_fourcc('T', 'V', '1', '2') -/* - * U S E R D E F I N E D T Y P E S - * - */ - -struct fimc_buffer { - void *start; - size_t length; -}; - -struct yuv_fmt_list { - const char *name; - const char *desc; - unsigned int fmt; - int depth; - int planes; -}; - -//s1 [Apply factory standard] -struct camsensor_date_info { - unsigned int year; - unsigned int month; - unsigned int date; -}; - - -class SecCamera { -public: - - enum CAMERA_ID { - CAMERA_ID_BACK = 0, - CAMERA_ID_FRONT = 1, - }; - - enum JPEG_QUALITY { - JPEG_QUALITY_ECONOMY = 0, - JPEG_QUALITY_NORMAL = 50, - JPEG_QUALITY_SUPERFINE = 100, - JPEG_QUALITY_MAX, - }; - - enum OBJECT_TRACKING { - OBJECT_TRACKING_OFF, - OBJECT_TRACKING_ON, - OBJECT_TRACKING_MAX, - }; - - /*VT call*/ - enum VT_MODE { - VT_MODE_OFF, - VT_MODE_ON, - VT_MODE_MAX, - }; - - /*Camera sensor mode - Camcorder fix fps*/ - enum SENSOR_MODE { - SENSOR_MODE_CAMERA, - SENSOR_MODE_MOVIE, - }; - - /*Camera Shot mode*/ - enum SHOT_MODE { - SHOT_MODE_SINGLE = 0, - SHOT_MODE_CONTINUOUS = 1, - SHOT_MODE_PANORAMA = 2, - SHOT_MODE_SMILE = 3, - SHOT_MODE_SELF = 6, - }; - - enum CHK_DATALINE { - CHK_DATALINE_OFF, - CHK_DATALINE_ON, - CHK_DATALINE_MAX, - }; - - int m_touch_af_start_stop; - - struct gps_info_latiude { - unsigned int north_south; - unsigned int dgree; - unsigned int minute; - unsigned int second; - } gpsInfoLatitude; - struct gps_info_longitude { - unsigned int east_west; - unsigned int dgree; - unsigned int minute; - unsigned int second; - } gpsInfoLongitude; - struct gps_info_altitude { - unsigned int plus_minus; - unsigned int dgree; - unsigned int minute; - unsigned int second; - } gpsInfoAltitude; - - SecCamera(); - ~SecCamera(); - - static SecCamera* createInstance(void) - { - static SecCamera singleton; - return &singleton; - } - status_t dump(int fd, const Vector& args); - - int flagCreate(void) const; - - int getCameraId(void); - - int startPreview(void); - int stopPreview(void); - - int startRecord(void); - int stopRecord(void); - int getRecordFrame(void); - int releaseRecordFrame(int index); - unsigned int getRecPhyAddrY(int); - unsigned int getRecPhyAddrC(int); - - int getPreview(void); - int setPreviewSize(int width, int height, int pixel_format); - int getPreviewSize(int *width, int *height, int *frame_size); - int getPreviewMaxSize(int *width, int *height); - int getPreviewPixelFormat(void); - int setPreviewImage(int index, unsigned char *buffer, int size); - - int setSnapshotSize(int width, int height); - int getSnapshotSize(int *width, int *height, int *frame_size); - int getSnapshotMaxSize(int *width, int *height); - int setSnapshotPixelFormat(int pixel_format); - int getSnapshotPixelFormat(void); - - unsigned char* getJpeg(unsigned char *snapshot_data, int snapshot_size, int *size); - unsigned char* yuv2Jpeg(unsigned char *raw_data, int raw_size, - int *jpeg_size, - int width, int height, int pixel_format); - - int setJpegThumbnailSize(int width, int height); - int getJpegThumbnailSize(int *width, int *height); - - int setAutofocus(void); - int zoomIn(void); - int zoomOut(void); - - int SetRotate(int angle); - int getRotate(void); - - int setVerticalMirror(void); - int setHorizontalMirror(void); - - int setWhiteBalance(int white_balance); - int getWhiteBalance(void); - - int setBrightness(int brightness); - int getBrightness(void); - - int setImageEffect(int image_effect); - int getImageEffect(void); - - int setSceneMode(int scene_mode); - int getSceneMode(void); - - int setFlashMode(int flash_mode); - int getFlashMode(void); - - int setMetering(int metering_value); - int getMetering(void); - - int setISO(int iso_value); - int getISO(void); - - int setContrast(int contrast_value); - int getContrast(void); - - int setSaturation(int saturation_value); - int getSaturation(void); - - int setSharpness(int sharpness_value); - int getSharpness(void); - - int setWDR(int wdr_value); - int getWDR(void); - - int setAntiShake(int anti_shake); - int getAntiShake(void); - - int setJpegQuality(int jpeg_qality); - int getJpegQuality(void); - - int setZoom(int zoom_level); - int getZoom(void); - - int setObjectTracking(int object_tracking); - int getObjectTracking(void); - int getObjectTrackingStatus(void); - - int setSmartAuto(int smart_auto); - int getSmartAuto(void); - int getAutosceneStatus(void); - - int setBeautyShot(int beauty_shot); - int getBeautyShot(void); - - int setVintageMode(int vintage_mode); - int getVintageMode(void); - - int setFocusMode(int focus_mode); - int getFocusMode(void); - - int setFaceDetect(int face_detect); - int getFaceDetect(void); - - int setGPSLatitude(const char *gps_latitude); - int setGPSLongitude(const char *gps_longitude); - int setGPSAltitude(const char *gps_altitude); - int setGPSTimeStamp(const char *gps_timestamp); - int setGPSProcessingMethod(const char *gps_timestamp); - int cancelAutofocus(void); - int setFaceDetectLockUnlock(int facedetect_lockunlock); - int setObjectPosition(int x, int y); - int setObjectTrackingStartStop(int start_stop); - int setTouchAFStartStop(int start_stop); - int setCAFStatus(int on_off); - int getAutoFocusResult(void); - int setAntiBanding(int anti_banding); - int getPostview(void); - int setRecordingSize(int width, int height); - int setGamma(int gamma); - int setSlowAE(int slow_ae); - int setExifOrientationInfo(int orientationInfo); - int setBatchReflection(void); - int setSnapshotCmd(void); - int endSnapshot(void); - int setCameraSensorReset(void); - int setSensorMode(int sensor_mode); /* Camcorder fix fps */ - int setShotMode(int shot_mode); /* Shot mode */ - /*VT call*/ - int setVTmode(int vtmode); - int getVTmode(void); - int setBlur(int blur_level); - int getBlur(void); - int setDataLineCheck(int chk_dataline); - int getDataLineCheck(void); - int setDataLineCheckStop(void); - int setDefultIMEI(int imei); - int getDefultIMEI(void); - const __u8* getCameraSensorName(void); - int previewPoll(bool preview); -#ifdef ENABLE_ESD_PREVIEW_CHECK - int getCameraSensorESDStatus(void); -#endif // ENABLE_ESD_PREVIEW_CHECK - - int setFrameRate(int frame_rate); - unsigned char* getJpeg(int*, unsigned int*); - int getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf, - unsigned int *output_size); - int getExif(unsigned char *pExifDst, unsigned char *pThumbSrc); - - void getPostViewConfig(int*, int*, int*); - void getThumbnailConfig(int *width, int *height, int *size); - - int getPostViewOffset(void); - int getCameraFd(void); - int getJpegFd(void); - void SetJpgAddr(unsigned char *addr); - unsigned int getPhyAddrY(int); - unsigned int getPhyAddrC(int); - void pausePreview(); - int initCamera(int index); - void DeinitCamera(); - static void setJpegRatio(double ratio) - { - if((ratio < 0) || (ratio > 1)) - return; - - jpeg_ratio = ratio; - } - - static double getJpegRatio() - { - return jpeg_ratio; - } - - static void setInterleaveDataSize(int x) - { - interleaveDataSize = x; - } - - static int getInterleaveDataSize() - { - return interleaveDataSize; - } - - static void setJpegLineLength(int x) - { - jpegLineLength = x; - } - - static int getJpegLineLength() - { - return jpegLineLength; - } - - -private: - v4l2_streamparm m_streamparm; - struct sec_cam_parm *m_params; - int m_flag_init; - - int m_camera_id; - - int m_cam_fd; - - int m_cam_fd_temp; - int m_cam_fd2_temp; - - int m_cam_fd2; - struct pollfd m_events_c2; - int m_flag_record_start; - - int m_preview_v4lformat; - int m_preview_width; - int m_preview_height; - int m_preview_max_width; - int m_preview_max_height; - - int m_snapshot_v4lformat; - int m_snapshot_width; - int m_snapshot_height; - int m_snapshot_max_width; - int m_snapshot_max_height; - - int m_angle; - int m_anti_banding; - int m_wdr; - int m_anti_shake; - int m_zoom_level; - int m_object_tracking; - int m_smart_auto; - int m_beauty_shot; - int m_vintage_mode; - int m_face_detect; - int m_object_tracking_start_stop; - int m_recording_width; - int m_recording_height; - long m_gps_latitude; - long m_gps_longitude; - long m_gps_altitude; - long m_gps_timestamp; - int m_vtmode; - int m_sensor_mode; /*Camcorder fix fps */ - int m_shot_mode; /* Shot mode */ - int m_exif_orientation; - int m_blur_level; - int m_chk_dataline; - int m_video_gamma; - int m_slow_ae; - int m_caf_on_off; - int m_default_imei; - int m_camera_af_flag; - - int m_flag_camera_start; - - int m_jpeg_fd; - int m_jpeg_thumbnail_width; - int m_jpeg_thumbnail_height; - int m_jpeg_quality; - - int m_postview_offset; - -#ifdef ENABLE_ESD_PREVIEW_CHECK - int m_esd_check_count; -#endif // ENABLE_ESD_PREVIEW_CHECK - - exif_attribute_t mExifInfo; - - struct fimc_buffer m_capture_buf; - struct pollfd m_events_c; - - inline int m_frameSize(int format, int width, int height); - - void setExifChangedAttribute(); - void setExifFixedAttribute(); - void resetCamera(); - - static double jpeg_ratio; - static int interleaveDataSize; - static int jpegLineLength; -}; - -extern unsigned long measure_time(struct timeval *start, struct timeval *stop); - -}; // namespace android - -#endif // ANDROID_HARDWARE_CAMERA_SEC_H diff --git a/libcamera/SecCameraHWInterface.cpp b/libcamera/SecCameraHWInterface.cpp deleted file mode 100644 index f019e01..0000000 --- a/libcamera/SecCameraHWInterface.cpp +++ /dev/null @@ -1,2142 +0,0 @@ -/* -** -** Copyright 2008, The Android Open Source Project -** Copyright 2010, Samsung Electronics Co. LTD -** -** 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 "CameraHardwareSec" -#include - -#include "SecCameraHWInterface.h" -#include -#include -#include - -#if defined(BOARD_USES_OVERLAY) -#include -#include -#define CACHEABLE_BUFFERS 0x1 -#define ALL_BUFFERS_FLUSHED -66 -#endif - -#define VIDEO_COMMENT_MARKER_H 0xFFBE -#define VIDEO_COMMENT_MARKER_L 0xFFBF -#define VIDEO_COMMENT_MARKER_LENGTH 4 -#define JPEG_EOI_MARKER 0xFFD9 -#define HIBYTE(x) (((x) >> 8) & 0xFF) -#define LOBYTE(x) ((x) & 0xFF) - -#define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR "0.10,1.20,Infinity" -#define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR "0.10,0.20,Infinity" -#define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR "0.10,1.20,Infinity" -#define FRONT_CAMERA_FOCUS_DISTANCES_STR "0.20,0.25,Infinity" - -namespace android { - -struct addrs { - unsigned int addr_y; - unsigned int addr_cbcr; - unsigned int buf_index; - unsigned int reserved; -}; - -struct addrs_cap { - unsigned int addr_y; - unsigned int width; - unsigned int height; -}; - -static const int INITIAL_SKIP_FRAME = 3; -static const int EFFECT_SKIP_FRAME = 1; - -CameraHardwareSec::CameraHardwareSec(int cameraId) - : - mCaptureInProgress(false), - mParameters(), - mPreviewHeap(0), - mRawHeap(0), - mRecordHeap(0), - mJpegHeap(0), - mSecCamera(NULL), - mCameraSensorName(NULL), - mSkipFrame(0), -#if defined(BOARD_USES_OVERLAY) - mUseOverlay(false), - mOverlayBufferIdx(0), -#endif - mNotifyCb(0), - mDataCb(0), - mDataCbTimestamp(0), - mCallbackCookie(0), - mMsgEnabled(0), - mRecordRunning(false), - mPostViewWidth(0), - mPostViewHeight(0), - mPostViewSize(0) -{ - LOGV("%s :", __func__); - int ret = 0; - - mSecCamera = SecCamera::createInstance(); - - if (mSecCamera == NULL) { - LOGE("ERR(%s):Fail on mSecCamera object creation", __func__); - } - - ret = mSecCamera->initCamera(cameraId); - if (ret < 0) { - LOGE("ERR(%s):Fail on mSecCamera init", __func__); - } - - if (mSecCamera->flagCreate() == 0) { - LOGE("ERR(%s):Fail on mSecCamera->flagCreate()", __func__); - } - - int recordHeapSize = sizeof(struct addrs) * kBufferCount; - LOGV("mRecordHeap : MemoryHeapBase(recordHeapSize(%d))", recordHeapSize); - mRecordHeap = new MemoryHeapBase(recordHeapSize); - if (mRecordHeap->getHeapID() < 0) { - LOGE("ERR(%s): Record heap creation fail", __func__); - mRecordHeap.clear(); - } - - mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); - LOGV("mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d", - mPostViewWidth,mPostViewHeight,mPostViewSize); - - int rawHeapSize = mPostViewSize; - LOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize); - mRawHeap = new MemoryHeapBase(rawHeapSize); - if (mRawHeap->getHeapID() < 0) { - LOGE("ERR(%s): Raw heap creation fail", __func__); - mRawHeap.clear(); - } - - initDefaultParameters(cameraId); - - mExitAutoFocusThread = false; - mExitPreviewThread = false; - /* whether the PreviewThread is active in preview or stopped. we - * create the thread but it is initially in stopped state. - */ - mPreviewRunning = false; - mPreviewThread = new PreviewThread(this); - mAutoFocusThread = new AutoFocusThread(this); - mPictureThread = new PictureThread(this); -} - -void CameraHardwareSec::initDefaultParameters(int cameraId) -{ - if (mSecCamera == NULL) { - LOGE("ERR(%s):mSecCamera object is NULL", __func__); - return; - } - - CameraParameters p; - CameraParameters ip; - - mCameraSensorName = mSecCamera->getCameraSensorName(); - LOGV("CameraSensorName: %s", mCameraSensorName); - - int preview_max_width = 0; - int preview_max_height = 0; - int snapshot_max_width = 0; - int snapshot_max_height = 0; - - if (cameraId == SecCamera::CAMERA_ID_BACK) { - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, - "720x480,640x480,320x240,176x144"); - p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, - "2560x1920,2048x1536,1600x1200,1600x960,640x480"); - } else { - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, - "640x480,320x240,176x144"); - p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, - "640x480"); - } - - // If these fail, then we are using an invalid cameraId and we'll leave the - // sizes at zero to catch the error. - if (mSecCamera->getPreviewMaxSize(&preview_max_width, - &preview_max_height) < 0) - LOGE("getPreviewMaxSize fail (%d / %d) \n", - preview_max_width, preview_max_height); - if (mSecCamera->getSnapshotMaxSize(&snapshot_max_width, - &snapshot_max_height) < 0) - LOGE("getSnapshotMaxSize fail (%d / %d) \n", - snapshot_max_width, snapshot_max_height); - - p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP); - p.setPreviewSize(preview_max_width, preview_max_height); - - p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); - p.setPictureSize(snapshot_max_width, snapshot_max_height); - p.set(CameraParameters::KEY_JPEG_QUALITY, "100"); // maximum quality - - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, - CameraParameters::PIXEL_FORMAT_YUV420SP); - p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, - CameraParameters::PIXEL_FORMAT_JPEG); - p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, - CameraParameters::PIXEL_FORMAT_YUV420SP); - - String8 parameterString; - - if (cameraId == SecCamera::CAMERA_ID_BACK) { - parameterString = CameraParameters::FOCUS_MODE_AUTO; - parameterString.append(","); - parameterString.append(CameraParameters::FOCUS_MODE_INFINITY); - parameterString.append(","); - parameterString.append(CameraParameters::FOCUS_MODE_MACRO); - p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, - parameterString.string()); - p.set(CameraParameters::KEY_FOCUS_MODE, - CameraParameters::FOCUS_MODE_AUTO); - p.set(CameraParameters::KEY_FOCUS_DISTANCES, - BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR); - p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, - "320x240,0x0"); - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "320"); - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "240"); - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "30"); - p.setPreviewFrameRate(30); - } else { - parameterString = CameraParameters::FOCUS_MODE_FIXED; - p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, - parameterString.string()); - p.set(CameraParameters::KEY_FOCUS_MODE, - CameraParameters::FOCUS_MODE_FIXED); - p.set(CameraParameters::KEY_FOCUS_DISTANCES, - FRONT_CAMERA_FOCUS_DISTANCES_STR); - p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, - "160x120,0x0"); - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160"); - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120"); - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "15"); - p.setPreviewFrameRate(15); - } - - parameterString = CameraParameters::EFFECT_NONE; - parameterString.append(","); - parameterString.append(CameraParameters::EFFECT_MONO); - parameterString.append(","); - parameterString.append(CameraParameters::EFFECT_NEGATIVE); - parameterString.append(","); - parameterString.append(CameraParameters::EFFECT_SEPIA); - p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, parameterString.string()); - - if (cameraId == SecCamera::CAMERA_ID_BACK) { - parameterString = CameraParameters::FLASH_MODE_ON; - parameterString.append(","); - parameterString.append(CameraParameters::FLASH_MODE_OFF); - parameterString.append(","); - parameterString.append(CameraParameters::FLASH_MODE_AUTO); - parameterString.append(","); - parameterString.append(CameraParameters::FLASH_MODE_TORCH); - p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, - parameterString.string()); - p.set(CameraParameters::KEY_FLASH_MODE, - CameraParameters::FLASH_MODE_OFF); - - parameterString = CameraParameters::SCENE_MODE_AUTO; - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_PORTRAIT); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_LANDSCAPE); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_NIGHT); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_BEACH); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_SNOW); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_SUNSET); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_FIREWORKS); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_SPORTS); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_PARTY); - parameterString.append(","); - parameterString.append(CameraParameters::SCENE_MODE_CANDLELIGHT); - p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, - parameterString.string()); - p.set(CameraParameters::KEY_SCENE_MODE, - CameraParameters::SCENE_MODE_AUTO); - - /* we have two ranges, 4-30fps for night mode and - * 15-30fps for all others - */ - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)"); - p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000"); - - p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.43"); - } else { - p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(7500,30000)"); - p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000"); - - p.set(CameraParameters::KEY_FOCAL_LENGTH, "0.9"); - } - - parameterString = CameraParameters::WHITE_BALANCE_AUTO; - parameterString.append(","); - parameterString.append(CameraParameters::WHITE_BALANCE_INCANDESCENT); - parameterString.append(","); - parameterString.append(CameraParameters::WHITE_BALANCE_FLUORESCENT); - parameterString.append(","); - parameterString.append(CameraParameters::WHITE_BALANCE_DAYLIGHT); - parameterString.append(","); - parameterString.append(CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT); - p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, - parameterString.string()); - - ip.set("sharpness-min", 0); - ip.set("sharpness-max", 4); - ip.set("saturation-min", 0); - ip.set("saturation-max", 4); - ip.set("contrast-min", 0); - ip.set("contrast-max", 4); - - p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100"); - - p.set(CameraParameters::KEY_ROTATION, 0); - p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO); - - p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE); - - ip.set("sharpness", SHARPNESS_DEFAULT); - ip.set("contrast", CONTRAST_DEFAULT); - ip.set("saturation", SATURATION_DEFAULT); - ip.set("iso", "auto"); - ip.set("metering", "center"); - - ip.set("wdr", 0); - ip.set("chk_dataline", 0); - if (cameraId == SecCamera::CAMERA_ID_FRONT) { - ip.set("vtmode", 0); - ip.set("blur", 0); - } - - p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2"); - p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4"); - - p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0"); - p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "4"); - p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-4"); - p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5"); - - mParameters = p; - mInternalParameters = ip; - - /* make sure mSecCamera has all the settings we do. applications - * aren't required to call setParameters themselves (only if they - * want to change something. - */ - setParameters(p); - mSecCamera->setISO(ISO_AUTO); - mSecCamera->setMetering(METERING_CENTER); - mSecCamera->setContrast(CONTRAST_DEFAULT); - mSecCamera->setSharpness(SHARPNESS_DEFAULT); - mSecCamera->setSaturation(SATURATION_DEFAULT); - if (cameraId == SecCamera::CAMERA_ID_BACK) - mSecCamera->setFrameRate(30); - else - mSecCamera->setFrameRate(15); -} - -CameraHardwareSec::~CameraHardwareSec() -{ - LOGV("%s :", __func__); - - singleton.clear(); -} - -sp CameraHardwareSec::getPreviewHeap() const -{ - return mPreviewHeap; -} - -sp CameraHardwareSec::getRawHeap() const -{ - return mRawHeap; -} - -void CameraHardwareSec::setCallbacks(notify_callback notify_cb, - data_callback data_cb, - data_callback_timestamp data_cb_timestamp, - void *user) -{ - mNotifyCb = notify_cb; - mDataCb = data_cb; - mDataCbTimestamp = data_cb_timestamp; - mCallbackCookie = user; -} - -void CameraHardwareSec::enableMsgType(int32_t msgType) -{ - LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x", - __func__, msgType, mMsgEnabled); - mMsgEnabled |= msgType; - LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); -} - -void CameraHardwareSec::disableMsgType(int32_t msgType) -{ - LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x", - __func__, msgType, mMsgEnabled); - mMsgEnabled &= ~msgType; - LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); -} - -bool CameraHardwareSec::msgTypeEnabled(int32_t msgType) -{ - return (mMsgEnabled & msgType); -} - -// --------------------------------------------------------------------------- -void CameraHardwareSec::setSkipFrame(int frame) -{ - Mutex::Autolock lock(mSkipFrameLock); - if (frame < mSkipFrame) - return; - - mSkipFrame = frame; -} - -int CameraHardwareSec::previewThreadWrapper() -{ - LOGI("%s: starting", __func__); - while (1) { - mPreviewLock.lock(); - while (!mPreviewRunning) { - LOGI("%s: calling mSecCamera->stopPreview() and waiting", __func__); - mSecCamera->stopPreview(); - /* signal that we're stopping */ - mPreviewStoppedCondition.signal(); - mPreviewCondition.wait(mPreviewLock); - LOGI("%s: return from wait", __func__); - } - mPreviewLock.unlock(); - - if (mExitPreviewThread) { - LOGI("%s: exiting", __func__); - mSecCamera->stopPreview(); - return 0; - } - previewThread(); - } -} - -int CameraHardwareSec::previewThread() -{ - int index; - nsecs_t timestamp; - unsigned int phyYAddr; - unsigned int phyCAddr; - struct addrs *addrs; - - index = mSecCamera->getPreview(); - if (index < 0) { - LOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__); - return UNKNOWN_ERROR; - } - mSkipFrameLock.lock(); - if (mSkipFrame > 0) { - mSkipFrame--; - mSkipFrameLock.unlock(); - return NO_ERROR; - } - mSkipFrameLock.unlock(); - - timestamp = systemTime(SYSTEM_TIME_MONOTONIC); - - phyYAddr = mSecCamera->getPhyAddrY(index); - phyCAddr = mSecCamera->getPhyAddrC(index); - - if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) { - LOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr); - return UNKNOWN_ERROR; - } - - int width, height, frame_size, offset; - - mSecCamera->getPreviewSize(&width, &height, &frame_size); - - offset = (frame_size + 16) * index; - sp buffer = new MemoryBase(mPreviewHeap, offset, frame_size); - - memcpy(static_cast(mPreviewHeap->base()) + (offset + frame_size ), &phyYAddr, 4); - memcpy(static_cast(mPreviewHeap->base()) + (offset + frame_size + 4), &phyCAddr, 4); - -#if defined(BOARD_USES_OVERLAY) - if (mUseOverlay) { - int ret; - overlay_buffer_t overlay_buffer; - - mOverlayBufferIdx ^= 1; - memcpy(static_cast(mPreviewHeap->base()) + offset + frame_size + sizeof(phyYAddr) + sizeof(phyCAddr), - &mOverlayBufferIdx, sizeof(mOverlayBufferIdx)); - - ret = mOverlay->queueBuffer((void*)(static_cast(mPreviewHeap->base()) + (offset + frame_size))); - - if (ret == -1 ) { - LOGE("ERR(%s):overlay queueBuffer fail", __func__); - } else if (ret != ALL_BUFFERS_FLUSHED) { - ret = mOverlay->dequeueBuffer(&overlay_buffer); - if (ret == -1) { - LOGE("ERR(%s):overlay dequeueBuffer fail", __func__); - } - } - } -#endif - - // Notify the client of a new frame. - if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) { - mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie); - } - - Mutex::Autolock lock(mRecordLock); - if (mRecordRunning == true) { - index = mSecCamera->getRecordFrame(); - if (index < 0) { - LOGE("ERR(%s):Fail on SecCamera->getRecord()", __func__); - return UNKNOWN_ERROR; - } - - phyYAddr = mSecCamera->getRecPhyAddrY(index); - phyCAddr = mSecCamera->getRecPhyAddrC(index); - - if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) { - LOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr); - return UNKNOWN_ERROR; - } - - addrs = (struct addrs *)mRecordHeap->base(); - - sp buffer = new MemoryBase(mRecordHeap, index * sizeof(struct addrs), sizeof(struct addrs)); - addrs[index].addr_y = phyYAddr; - addrs[index].addr_cbcr = phyCAddr; - addrs[index].buf_index = index; - - // Notify the client of a new frame. - if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) { - mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, buffer, mCallbackCookie); - } else { - mSecCamera->releaseRecordFrame(index); - } - } - - return NO_ERROR; -} - -status_t CameraHardwareSec::startPreview() -{ - int ret = 0; //s1 [Apply factory standard] - - LOGV("%s :", __func__); - - Mutex::Autolock lock(mStateLock); - if (mCaptureInProgress) { - LOGE("%s : capture in progress, not allowed", __func__); - return INVALID_OPERATION; - } - - mPreviewLock.lock(); - if (mPreviewRunning) { - // already running - LOGE("%s : preview thread already running", __func__); - mPreviewLock.unlock(); - return INVALID_OPERATION; - } - - setSkipFrame(INITIAL_SKIP_FRAME); - - ret = mSecCamera->startPreview(); - LOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret); - - if (ret < 0) { - LOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__); - return -1; //UNKNOWN_ERROR; - } - - if (mPreviewHeap != NULL) - mPreviewHeap.clear(); - - int width, height, frame_size; - - mSecCamera->getPreviewSize(&width, &height, &frame_size); - - int previewHeapSize = (frame_size + 16) * kBufferCount; - - LOGD("MemoryHeapBase(fd(%d), size(%d), width(%d), height(%d))", (int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), width, height); - mPreviewHeap = new MemoryHeapBase((int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), (uint32_t)0); - - mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); - LOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",mPostViewWidth,mPostViewHeight,mPostViewSize); - - mPreviewRunning = true; - mPreviewCondition.signal(); - mPreviewLock.unlock(); - - return NO_ERROR; -} - -#if defined(BOARD_USES_OVERLAY) -bool CameraHardwareSec::useOverlay() -{ - LOGV("%s: returning true", __func__); - return true; -} - -status_t CameraHardwareSec::setOverlay(const sp &overlay) -{ - LOGV("%s :", __func__); - - int overlayWidth = 0; - int overlayHeight = 0; - int overlayFrameSize = 0; - - if (overlay == NULL) { - LOGV("%s : overlay == NULL", __func__); - goto setOverlayFail; - } - LOGV("%s : overlay = %p", __func__, overlay->getHandleRef()); - - if (overlay->getHandleRef()== NULL && mUseOverlay == true) { - if (mOverlay != 0) - mOverlay->destroy(); - - mOverlay = NULL; - mUseOverlay = false; - - return NO_ERROR; - } - - if (overlay->getStatus() != NO_ERROR) { - LOGE("ERR(%s):overlay->getStatus() fail", __func__); - goto setOverlayFail; - } - - mSecCamera->getPreviewSize(&overlayWidth, &overlayHeight, &overlayFrameSize); - - if (overlay->setCrop(0, 0, overlayWidth, overlayHeight) != NO_ERROR) { - LOGE("ERR(%s)::(mOverlay->setCrop(0, 0, %d, %d) fail", __func__, overlayWidth, overlayHeight); - goto setOverlayFail; - } - - mOverlay = overlay; - mUseOverlay = true; - - return NO_ERROR; - -setOverlayFail : - if (mOverlay != 0) - mOverlay->destroy(); - mOverlay = 0; - - mUseOverlay = false; - - return UNKNOWN_ERROR; -} -#endif - -void CameraHardwareSec::stopPreview() -{ - LOGV("%s :", __func__); - - /* request that the preview thread stop. */ - mPreviewLock.lock(); - if (mPreviewRunning) { - mPreviewRunning = false; - mPreviewCondition.signal(); - /* wait until preview thread is stopped */ - mPreviewStoppedCondition.wait(mPreviewLock); - } else { - LOGI("%s : preview not running, doing nothing", __func__); - } - mPreviewLock.unlock(); -} - -bool CameraHardwareSec::previewEnabled() -{ - Mutex::Autolock lock(mPreviewLock); - LOGV("%s : %d", __func__, mPreviewRunning); - return mPreviewRunning; -} - -// --------------------------------------------------------------------------- - -status_t CameraHardwareSec::startRecording() -{ - LOGV("%s :", __func__); - - Mutex::Autolock lock(mRecordLock); - - if (mRecordRunning == false) { - if (mSecCamera->startRecord() < 0) { - LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__); - return UNKNOWN_ERROR; - } - mRecordRunning = true; - } - return NO_ERROR; -} - -void CameraHardwareSec::stopRecording() -{ - LOGV("%s :", __func__); - - Mutex::Autolock lock(mRecordLock); - - if (mRecordRunning == true) { - if (mSecCamera->stopRecord() < 0) { - LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__); - return; - } - mRecordRunning = false; - } -} - -bool CameraHardwareSec::recordingEnabled() -{ - LOGV("%s :", __func__); - - return mRecordRunning; -} - -void CameraHardwareSec::releaseRecordingFrame(const sp& mem) -{ - ssize_t offset; - sp heap = mem->getMemory(&offset, NULL); - struct addrs *addrs = (struct addrs *)((uint8_t *)heap->base() + offset); - - mSecCamera->releaseRecordFrame(addrs->buf_index); -} - -// --------------------------------------------------------------------------- - -int CameraHardwareSec::autoFocusThread() -{ - int count =0; - int af_status =0 ; - - LOGV("%s : starting", __func__); - - /* block until we're told to start. we don't want to use - * a restartable thread and requestExitAndWait() in cancelAutoFocus() - * because it would cause deadlock between our callbacks and the - * caller of cancelAutoFocus() which both want to grab the same lock - * in CameraServices layer. - */ - mFocusLock.lock(); - /* check early exit request */ - if (mExitAutoFocusThread) { - mFocusLock.unlock(); - LOGV("%s : exiting on request0", __func__); - return NO_ERROR; - } - mFocusCondition.wait(mFocusLock); - /* check early exit request */ - if (mExitAutoFocusThread) { - mFocusLock.unlock(); - LOGV("%s : exiting on request1", __func__); - return NO_ERROR; - } - mFocusLock.unlock(); - - LOGV("%s : calling setAutoFocus", __func__); - if (mSecCamera->setAutofocus() < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__); - return UNKNOWN_ERROR; - } - - af_status = mSecCamera->getAutoFocusResult(); - - int i; - - i = 0; - - af_status = mSecCamera->getAutoFocusResult(); - - while(af_status == 0x05 && i < 100) - { - LOGV("%s : AF Result == 0X05 sleeping!!", __func__); - usleep(50000); - af_status = mSecCamera->getAutoFocusResult(); - i++; - } - - LOGV("%s : AF Result == %d", __func__, af_status); - - if (af_status == 0x02) { - LOGV("%s : AF Success!!", __func__); - if (mMsgEnabled & CAMERA_MSG_FOCUS) - mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); - } -//FIXME: determine that the user cancled the AF -#if 0 - else if (af_status == 0x02) { - LOGV("%s : AF Cancelled !!", __func__); - if (mMsgEnabled & CAMERA_MSG_FOCUS) { - /* CAMERA_MSG_FOCUS only takes a bool. true for - * finished and false for failure. cancel is still - * considered a true result. - */ - mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); - } - } -#endif - else { - LOGV("%s : AF Fail !!", __func__); - LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); - if (mMsgEnabled & CAMERA_MSG_FOCUS) - mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie); - } - - LOGV("%s : exiting with no error", __func__); - return NO_ERROR; -} - -status_t CameraHardwareSec::autoFocus() -{ - LOGV("%s :", __func__); - /* signal autoFocusThread to run once */ - mFocusCondition.signal(); - return NO_ERROR; -} - -/* 2009.10.14 by icarus for added interface */ -status_t CameraHardwareSec::cancelAutoFocus() -{ - LOGV("%s :", __func__); - - if (mSecCamera->cancelAutofocus() < 0) { - LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__); - return UNKNOWN_ERROR; - } - - return NO_ERROR; -} - -int CameraHardwareSec::save_jpeg( unsigned char *real_jpeg, int jpeg_size) -{ - FILE *yuv_fp = NULL; - char filename[100], *buffer = NULL; - - /* file create/open, note to "wb" */ - yuv_fp = fopen("/data/camera_dump.jpeg", "wb"); - if (yuv_fp == NULL) { - LOGE("Save jpeg file open error"); - return -1; - } - - LOGV("[BestIQ] real_jpeg size ========> %d\n", jpeg_size); - buffer = (char *) malloc(jpeg_size); - if (buffer == NULL) { - LOGE("Save YUV] buffer alloc failed"); - if (yuv_fp) - fclose(yuv_fp); - - return -1; - } - - memcpy(buffer, real_jpeg, jpeg_size); - - fflush(stdout); - - fwrite(buffer, 1, jpeg_size, yuv_fp); - - fflush(yuv_fp); - - if (yuv_fp) - fclose(yuv_fp); - if (buffer) - free(buffer); - - return 0; -} - -void CameraHardwareSec::save_postview(const char *fname, uint8_t *buf, uint32_t size) -{ - int nw; - int cnt = 0; - uint32_t written = 0; - - LOGD("opening file [%s]\n", fname); - int fd = open(fname, O_RDWR | O_CREAT); - if (fd < 0) { - LOGE("failed to create file [%s]: %s", fname, strerror(errno)); - return; - } - - LOGD("writing %d bytes to file [%s]\n", size, fname); - while (written < size) { - nw = ::write(fd, buf + written, size - written); - if (nw < 0) { - LOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno)); - break; - } - written += nw; - cnt++; - } - LOGD("done writing %d bytes to file [%s] in %d passes\n",size, fname, cnt); - ::close(fd); -} - -bool CameraHardwareSec::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHeight, - char *dstBuf, uint32_t dstWidth, uint32_t dstHeight) -{ - int32_t step_x, step_y; - int32_t iXsrc, iXdst; - int32_t x, y, src_y_start_pos, dst_pos, src_pos; - - if (dstWidth % 2 != 0 || dstHeight % 2 != 0){ - LOGE("scale_down_yuv422: invalid width, height for scaling"); - return false; - } - - step_x = srcWidth / dstWidth; - step_y = srcHeight / dstHeight; - - dst_pos = 0; - for (uint32_t y = 0; y < dstHeight; y++) { - src_y_start_pos = (y * step_y * (srcWidth * 2)); - - for (uint32_t x = 0; x < dstWidth; x += 2) { - src_pos = src_y_start_pos + (x * (step_x * 2)); - - dstBuf[dst_pos++] = srcBuf[src_pos ]; - dstBuf[dst_pos++] = srcBuf[src_pos + 1]; - dstBuf[dst_pos++] = srcBuf[src_pos + 2]; - dstBuf[dst_pos++] = srcBuf[src_pos + 3]; - } - } - - return true; -} - -bool CameraHardwareSec::YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight) -{ - int32_t x, y, src_y_start_pos, dst_cbcr_pos, dst_pos, src_pos; - unsigned char *srcBufPointer = (unsigned char *)srcBuf; - unsigned char *dstBufPointer = (unsigned char *)dstBuf; - - dst_pos = 0; - dst_cbcr_pos = srcWidth*srcHeight; - for (uint32_t y = 0; y < srcHeight; y++) { - src_y_start_pos = (y * (srcWidth * 2)); - - for (uint32_t x = 0; x < (srcWidth * 2); x += 2) { - src_pos = src_y_start_pos + x; - - dstBufPointer[dst_pos++] = srcBufPointer[src_pos]; - } - } - for (uint32_t y = 0; y < srcHeight; y += 2) { - src_y_start_pos = (y * (srcWidth * 2)); - - for (uint32_t x = 0; x < (srcWidth * 2); x += 4) { - src_pos = src_y_start_pos + x; - - dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 3]; - dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 1]; - } - } - - return true; -} - -int CameraHardwareSec::pictureThread() -{ - LOGV("%s :", __func__); - - int jpeg_size = 0; - int ret = NO_ERROR; - unsigned char *jpeg_data = NULL; - int postview_offset = 0; - unsigned char *postview_data = NULL; - - unsigned char *addr = NULL; - int mPostViewWidth, mPostViewHeight, mPostViewSize; - int mThumbWidth, mThumbHeight, mThumbSize; - int cap_width, cap_height, cap_frame_size; - - unsigned int output_size = 0; - - mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); - mSecCamera->getThumbnailConfig(&mThumbWidth, &mThumbHeight, &mThumbSize); - int postviewHeapSize = mPostViewSize; - mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size); - int mJpegHeapSize; - if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) - mJpegHeapSize = cap_frame_size * SecCamera::getJpegRatio(); - else - mJpegHeapSize = cap_frame_size; - - LOG_TIME_DEFINE(0) - LOG_TIME_START(0) - - sp buffer = new MemoryBase(mRawHeap, 0, mPostViewSize + 8); - - struct addrs_cap *addrs = (struct addrs_cap *)mRawHeap->base(); - - addrs[0].width = mPostViewWidth; - addrs[0].height = mPostViewHeight; - LOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight); - - sp JpegHeap = new MemoryHeapBase(mJpegHeapSize); - sp PostviewHeap = new MemoryHeapBase(mPostViewSize); - sp ThumbnailHeap = new MemoryHeapBase(mThumbSize); - - if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { - LOG_TIME_DEFINE(1) - LOG_TIME_START(1) - - int picture_size, picture_width, picture_height; - mSecCamera->getSnapshotSize(&picture_width, &picture_height, &picture_size); - int picture_format = mSecCamera->getSnapshotPixelFormat(); - - unsigned int phyAddr; - - // Modified the shutter sound timing for Jpeg capture - if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) - mSecCamera->setSnapshotCmd(); - if (mMsgEnabled & CAMERA_MSG_SHUTTER) { - mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie); - } - - if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){ - jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr); - if (jpeg_data == NULL) { - LOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __func__); - ret = UNKNOWN_ERROR; - } - } else { - if (mSecCamera->getSnapshotAndJpeg((unsigned char*)PostviewHeap->base(), - (unsigned char*)JpegHeap->base(), &output_size) < 0) { - mStateLock.lock(); - mCaptureInProgress = false; - mStateLock.unlock(); - return UNKNOWN_ERROR; - } - LOGI("snapshotandjpeg done\n"); - } - - addrs[0].addr_y = phyAddr; - - LOG_TIME_END(1) - LOG_CAMERA("getSnapshotAndJpeg interval: %lu us", LOG_TIME(1)); - } - - /* the capture is done at this point so we can allow sensor commands - * again, we still need to do jpeg and thumbnail processing, but the - * sensor is available for something else - */ - mStateLock.lock(); - mCaptureInProgress = false; - mStateLock.unlock(); - - if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { - mDataCb(CAMERA_MSG_RAW_IMAGE, buffer, mCallbackCookie); - } - - if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { - - memcpy(JpegHeap->base (), jpeg_data, jpeg_size + 2); - - int JpegExifSize; - sp ExifHeap = new MemoryHeapBase(EXIF_FILE_SIZE + JPG_STREAM_BUF_SIZE); - JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->base(), - (unsigned char *)ThumbnailHeap->base()); - - LOGV("JpegExifSize=%d", JpegExifSize); - - if (JpegExifSize < 0) { - ret = UNKNOWN_ERROR; - goto out; - } - - unsigned char *ExifStart = (unsigned char *)JpegHeap->base() + 2; - unsigned char *ImageStart = ExifStart + JpegExifSize; - memmove(ImageStart, ExifStart, jpeg_size - 2); - memcpy(ExifStart, ExifHeap->base(), JpegExifSize); - - sp mem = new MemoryBase(JpegHeap, 0, jpeg_size + JpegExifSize); - - mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie); - } - - LOG_TIME_END(0) - LOG_CAMERA("pictureThread interval: %lu us", LOG_TIME(0)); -out: - LOGV("%s : pictureThread end", __func__); - return ret; -} - -status_t CameraHardwareSec::takePicture() -{ - LOGV("%s :", __func__); - - stopPreview(); - - Mutex::Autolock lock(mStateLock); - if (mCaptureInProgress) { - LOGE("%s : capture already in progress", __func__); - return INVALID_OPERATION; - } - - if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) { - LOGE("%s : couldn't run picture thread", __func__); - return INVALID_OPERATION; - } - mCaptureInProgress = true; - - return NO_ERROR; -} - -status_t CameraHardwareSec::cancelPicture() -{ - mPictureThread->requestExitAndWait(); - - return NO_ERROR; -} - -bool CameraHardwareSec::CheckVideoStartMarker(unsigned char *pBuf) -{ - if (!pBuf) { - LOGE("CheckVideoStartMarker() => pBuf is NULL\n"); - return false; - } - - if (HIBYTE(VIDEO_COMMENT_MARKER_H) == * pBuf && LOBYTE(VIDEO_COMMENT_MARKER_H) == *(pBuf + 1) && - HIBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 2) && LOBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 3)) - return true; - - return false; -} - -bool CameraHardwareSec::CheckEOIMarker(unsigned char *pBuf) -{ - if (!pBuf) { - LOGE("CheckEOIMarker() => pBuf is NULL\n"); - return false; - } - - // EOI marker [FF D9] - if (HIBYTE(JPEG_EOI_MARKER) == *pBuf && LOBYTE(JPEG_EOI_MARKER) == *(pBuf + 1)) - return true; - - return false; -} - -bool CameraHardwareSec::FindEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize) -{ - if (NULL == pBuf || 0 >= dwBufSize) { - LOGE("FindEOIMarkerInJPEG() => There is no contents."); - return false; - } - - unsigned char *pBufEnd = pBuf + dwBufSize; - - while (pBuf < pBufEnd) { - if (CheckEOIMarker(pBuf++)) - return true; - - (*pnJPEGsize)++; - } - - return false; -} - -bool CameraHardwareSec::SplitFrame(unsigned char *pFrame, int dwSize, - int dwJPEGLineLength, int dwVideoLineLength, int dwVideoHeight, - void *pJPEG, int *pdwJPEGSize, - void *pVideo, int *pdwVideoSize) -{ - LOGV("===========SplitFrame Start=============="); - - if (NULL == pFrame || 0 >= dwSize) { - LOGE("There is no contents.\r\n"); - return false; - } - - if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) { - LOGE("There in no input information for decoding interleaved jpeg"); - return false; - } - - unsigned char *pSrc = pFrame; - unsigned char *pSrcEnd = pFrame + dwSize; - - unsigned char *pJ = (unsigned char *)pJPEG; - int dwJSize = 0; - unsigned char *pV = (unsigned char *)pVideo; - int dwVSize = 0; - - bool bRet = false; - bool isFinishJpeg = false; - - while (pSrc < pSrcEnd) { - // Check video start marker - if (CheckVideoStartMarker(pSrc)) { - int copyLength; - - if (pSrc + dwVideoLineLength <= pSrcEnd) - copyLength = dwVideoLineLength; - else - copyLength = pSrcEnd - pSrc - VIDEO_COMMENT_MARKER_LENGTH; - - // Copy video data - if (pV) { - memcpy(pV, pSrc + VIDEO_COMMENT_MARKER_LENGTH, copyLength); - pV += copyLength; - dwVSize += copyLength; - } - - pSrc += copyLength + VIDEO_COMMENT_MARKER_LENGTH; - } else { - // Copy pure JPEG data - int size = 0; - int dwCopyBufLen = dwJPEGLineLength <= pSrcEnd-pSrc ? dwJPEGLineLength : pSrcEnd - pSrc; - - if (FindEOIMarkerInJPEG((unsigned char *)pSrc, dwCopyBufLen, &size)) { - isFinishJpeg = true; - size += 2; // to count EOF marker size - } else { - if ((dwCopyBufLen == 1) && (pJPEG < pJ)) { - unsigned char checkBuf[2] = { *(pJ - 1), *pSrc }; - - if (CheckEOIMarker(checkBuf)) - isFinishJpeg = true; - } - size = dwCopyBufLen; - } - - memcpy(pJ, pSrc, size); - - dwJSize += size; - - pJ += dwCopyBufLen; - pSrc += dwCopyBufLen; - } - if (isFinishJpeg) - break; - } - - if (isFinishJpeg) { - bRet = true; - if(pdwJPEGSize) - *pdwJPEGSize = dwJSize; - if(pdwVideoSize) - *pdwVideoSize = dwVSize; - } else { - LOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI"); - bRet = false; - if(pdwJPEGSize) - *pdwJPEGSize = 0; - if(pdwVideoSize) - *pdwVideoSize = 0; - } - LOGV("===========SplitFrame end=============="); - - return bRet; -} - -int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData, - int interleaveDataSize, - int yuvWidth, - int yuvHeight, - int *pJpegSize, - void *pJpegData, - void *pYuvData) -{ - if (pInterleaveData == NULL) - return false; - - bool ret = true; - unsigned int *interleave_ptr = (unsigned int *)pInterleaveData; - unsigned char *jpeg_ptr = (unsigned char *)pJpegData; - unsigned char *yuv_ptr = (unsigned char *)pYuvData; - unsigned char *p; - int jpeg_size = 0; - int yuv_size = 0; - - int i = 0; - - LOGV("decodeInterleaveData Start~~~"); - while (i < interleaveDataSize) { - if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) || - (*interleave_ptr == 0xFF02FFFF)) { - // Padding Data -// LOGE("%d(%x) padding data\n", i, *interleave_ptr); - interleave_ptr++; - i += 4; - } - else if ((*interleave_ptr & 0xFFFF) == 0x05FF) { - // Start-code of YUV Data -// LOGE("%d(%x) yuv data\n", i, *interleave_ptr); - p = (unsigned char *)interleave_ptr; - p += 2; - i += 2; - - // Extract YUV Data - if (pYuvData != NULL) { - memcpy(yuv_ptr, p, yuvWidth * 2); - yuv_ptr += yuvWidth * 2; - yuv_size += yuvWidth * 2; - } - p += yuvWidth * 2; - i += yuvWidth * 2; - - // Check End-code of YUV Data - if ((*p == 0xFF) && (*(p + 1) == 0x06)) { - interleave_ptr = (unsigned int *)(p + 2); - i += 2; - } else { - ret = false; - break; - } - } else { - // Extract JPEG Data -// LOGE("%d(%x) jpg data, jpeg_size = %d bytes\n", i, *interleave_ptr, jpeg_size); - if (pJpegData != NULL) { - memcpy(jpeg_ptr, interleave_ptr, 4); - jpeg_ptr += 4; - jpeg_size += 4; - } - interleave_ptr++; - i += 4; - } - } - if (ret) { - if (pJpegData != NULL) { - // Remove Padding after EOI - for (i = 0; i < 3; i++) { - if (*(--jpeg_ptr) != 0xFF) { - break; - } - jpeg_size--; - } - *pJpegSize = jpeg_size; - - } - // Check YUV Data Size - if (pYuvData != NULL) { - if (yuv_size != (yuvWidth * yuvHeight * 2)) { - ret = false; - } - } - } - LOGV("decodeInterleaveData End~~~"); - return ret; -} - -status_t CameraHardwareSec::dump(int fd, const Vector& args) const -{ - const size_t SIZE = 256; - char buffer[SIZE]; - String8 result; - - if (mSecCamera != 0) { - mSecCamera->dump(fd, args); - mParameters.dump(fd, args); - mInternalParameters.dump(fd, args); - snprintf(buffer, 255, " preview running(%s)\n", 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 CameraHardwareSec::setParameters(const CameraParameters& params) -{ - LOGV("%s :", __func__); - - status_t ret = NO_ERROR; - - /* if someone calls us while picture thread is running, it could screw - * up the sensor quite a bit so return error. we can't wait because - * that would cause deadlock with the callbacks - */ - mStateLock.lock(); - if (mCaptureInProgress) { - mStateLock.unlock(); - LOGE("%s : capture in progress, not allowed", __func__); - return UNKNOWN_ERROR; - } - mStateLock.unlock(); - - // preview size - int new_preview_width = 0; - int new_preview_height = 0; - params.getPreviewSize(&new_preview_width, &new_preview_height); - const char *new_str_preview_format = params.getPreviewFormat(); - LOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s", - __func__, new_preview_width, new_preview_height, new_str_preview_format); - - if (0 < new_preview_width && 0 < new_preview_height && new_str_preview_format != NULL) { - int new_preview_format = 0; - - if (!strcmp(new_str_preview_format, - CameraParameters::PIXEL_FORMAT_RGB565)) - new_preview_format = V4L2_PIX_FMT_RGB565; - else if (!strcmp(new_str_preview_format, - CameraParameters::PIXEL_FORMAT_YUV420SP)) - new_preview_format = V4L2_PIX_FMT_NV21; - else if (!strcmp(new_str_preview_format, "yuv420sp_custom")) - new_preview_format = V4L2_PIX_FMT_NV12T; - else if (!strcmp(new_str_preview_format, "yuv420p")) - new_preview_format = V4L2_PIX_FMT_YUV420; - else if (!strcmp(new_str_preview_format, "yuv422i")) - new_preview_format = V4L2_PIX_FMT_YUYV; - else if (!strcmp(new_str_preview_format, "yuv422p")) - new_preview_format = V4L2_PIX_FMT_YUV422P; - else - new_preview_format = V4L2_PIX_FMT_NV21; //for 3rd party - - if (mSecCamera->setPreviewSize(new_preview_width, new_preview_height, new_preview_format) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))", - __func__, new_preview_width, new_preview_height, new_preview_format); - ret = UNKNOWN_ERROR; - } else { - mParameters.setPreviewSize(new_preview_width, new_preview_height); - mParameters.setPreviewFormat(new_str_preview_format); - } -#if defined(BOARD_USES_OVERLAY) - if (mUseOverlay == true && mOverlay != 0) { - if (mOverlay->setCrop(0, 0, new_preview_width, new_preview_height) != NO_ERROR) { - LOGE("ERR(%s)::(mOverlay->setCrop(0, 0, %d, %d) fail", - __func__, new_preview_width, new_preview_height); - } - } -#endif - } - - int new_picture_width = 0; - int new_picture_height = 0; - - params.getPictureSize(&new_picture_width, &new_picture_height); - LOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height); - if (0 < new_picture_width && 0 < new_picture_height) { - if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))", - __func__, new_picture_width, new_picture_height); - ret = UNKNOWN_ERROR; - } else { - mParameters.setPictureSize(new_picture_width, new_picture_height); - } - } - - // picture format - const char *new_str_picture_format = params.getPictureFormat(); - LOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format); - if (new_str_picture_format != NULL) { - int new_picture_format = 0; - - if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGB565)) - new_picture_format = V4L2_PIX_FMT_RGB565; - else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_YUV420SP)) - new_picture_format = V4L2_PIX_FMT_NV21; - else if (!strcmp(new_str_picture_format, "yuv420sp_custom")) - new_picture_format = V4L2_PIX_FMT_NV12T; - else if (!strcmp(new_str_picture_format, "yuv420p")) - new_picture_format = V4L2_PIX_FMT_YUV420; - else if (!strcmp(new_str_picture_format, "yuv422i")) - new_picture_format = V4L2_PIX_FMT_YUYV; - else if (!strcmp(new_str_picture_format, "uyv422i_custom")) //Zero copy UYVY format - new_picture_format = V4L2_PIX_FMT_UYVY; - else if (!strcmp(new_str_picture_format, "uyv422i")) //Non-zero copy UYVY format - new_picture_format = V4L2_PIX_FMT_UYVY; - else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_JPEG)) - new_picture_format = V4L2_PIX_FMT_YUYV; - else if (!strcmp(new_str_picture_format, "yuv422p")) - new_picture_format = V4L2_PIX_FMT_YUV422P; - else - new_picture_format = V4L2_PIX_FMT_NV21; //for 3rd party - - if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format); - ret = UNKNOWN_ERROR; - } else { - mParameters.setPictureFormat(new_str_picture_format); - } - } - - //JPEG image quality - int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY); - LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality); - /* we ignore bad values */ - if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) { - if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality); - } - } - - // JPEG thumbnail size - int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); - int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); - if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) { - if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width); - mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, new_jpeg_thumbnail_height); - } - } - - // frame rate - int new_frame_rate = params.getPreviewFrameRate(); - /* ignore any fps request, we're determine fps automatically based - * on scene mode. don't return an error because it causes CTS failure. - */ - if (new_frame_rate != mParameters.getPreviewFrameRate()) { - LOGW("WARN(%s): request for preview frame %d not allowed, != %d\n", - __func__, new_frame_rate, mParameters.getPreviewFrameRate()); - } - - // rotation - int new_rotation = params.getInt(CameraParameters::KEY_ROTATION); - LOGV("%s : new_rotation %d", __func__, new_rotation); - if (0 <= new_rotation) { - LOGV("%s : set orientation:%d\n", __func__, new_rotation); - if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_ROTATION, new_rotation); - } - } - - // brightness - int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); - int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION); - int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION); - LOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation); - if ((min_exposure_compensation <= new_exposure_compensation) && - (max_exposure_compensation >= new_exposure_compensation)) { - if (mSecCamera->setBrightness(new_exposure_compensation) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_exposure_compensation); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation); - } - } - - // whitebalance - const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE); - LOGV("%s : new_white_str %s", __func__, new_white_str); - if (new_white_str != NULL) { - int new_white = -1; - - if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO)) - new_white = WHITE_BALANCE_AUTO; - else if (!strcmp(new_white_str, - CameraParameters::WHITE_BALANCE_DAYLIGHT)) - new_white = WHITE_BALANCE_SUNNY; - else if (!strcmp(new_white_str, - CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT)) - new_white = WHITE_BALANCE_CLOUDY; - else if (!strcmp(new_white_str, - CameraParameters::WHITE_BALANCE_FLUORESCENT)) - new_white = WHITE_BALANCE_FLUORESCENT; - else if (!strcmp(new_white_str, - CameraParameters::WHITE_BALANCE_INCANDESCENT)) - new_white = WHITE_BALANCE_TUNGSTEN; - else { - LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent - ret = UNKNOWN_ERROR; - } - - if (0 <= new_white) { - if (mSecCamera->setWhiteBalance(new_white) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str); - } - } - } - - // scene mode - const char *new_scene_mode_str = params.get(CameraParameters::KEY_SCENE_MODE); - const char *current_scene_mode_str = mParameters.get(CameraParameters::KEY_SCENE_MODE); - - // fps range - int new_min_fps = 0; - int new_max_fps = 0; - int current_min_fps, current_max_fps; - params.getPreviewFpsRange(&new_min_fps, &new_max_fps); - mParameters.getPreviewFpsRange(¤t_min_fps, ¤t_max_fps); - /* our fps range is determined by the sensor, reject any request - * that isn't exactly what we're already at. - * but the check is performed when requesting only changing fps range - */ - if (new_scene_mode_str && current_scene_mode_str) { - if (!strcmp(new_scene_mode_str, current_scene_mode_str)) { - if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) { - LOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed", - __func__, new_min_fps, new_max_fps); - LOGE("%s : current_min_fps = %d, current_max_fps = %d", - __func__, current_min_fps, current_max_fps); - ret = UNKNOWN_ERROR; - } - } - } else { - /* Check basic validation if scene mode is different */ - if ((new_min_fps > new_max_fps) || - (new_min_fps < 0) || (new_max_fps < 0)) - ret = UNKNOWN_ERROR; - } - - if (new_scene_mode_str != NULL) { - int new_scene_mode = -1; - - const char *new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE); - const char *new_focus_mode_str; - - new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE); - // fps range is (15000,30000) by default. - mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)"); - mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, - "15000,30000"); - - if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) { - new_scene_mode = SCENE_MODE_NONE; - } else { - // defaults for non-auto scene modes - if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) { - new_focus_mode_str = CameraParameters::FOCUS_MODE_AUTO; - } - new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; - - if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_PORTRAIT)) { - new_scene_mode = SCENE_MODE_PORTRAIT; - new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO; - } else if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_LANDSCAPE)) { - new_scene_mode = SCENE_MODE_LANDSCAPE; - } else if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_SPORTS)) { - new_scene_mode = SCENE_MODE_SPORTS; - } else if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_PARTY)) { - new_scene_mode = SCENE_MODE_PARTY_INDOOR; - new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO; - } else if ((!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_BEACH)) || - (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_SNOW))) { - new_scene_mode = SCENE_MODE_BEACH_SNOW; - } else if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_SUNSET)) { - new_scene_mode = SCENE_MODE_SUNSET; - } else if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_NIGHT)) { - new_scene_mode = SCENE_MODE_NIGHTSHOT; - mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)"); - mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, - "4000,30000"); - } else if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_FIREWORKS)) { - new_scene_mode = SCENE_MODE_FIREWORKS; - } else if (!strcmp(new_scene_mode_str, - CameraParameters::SCENE_MODE_CANDLELIGHT)) { - new_scene_mode = SCENE_MODE_CANDLE_LIGHT; - } else { - LOGE("%s::unmatched scene_mode(%s)", - __func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto - ret = UNKNOWN_ERROR; - } - } - - // focus mode - if (new_focus_mode_str != NULL) { - int new_focus_mode = -1; - - if (!strcmp(new_focus_mode_str, - CameraParameters::FOCUS_MODE_AUTO)) { - new_focus_mode = FOCUS_MODE_AUTO; - mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, - BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR); - } - else if (!strcmp(new_focus_mode_str, - CameraParameters::FOCUS_MODE_MACRO)) { - new_focus_mode = FOCUS_MODE_MACRO; - mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, - BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR); - } - else if (!strcmp(new_focus_mode_str, - CameraParameters::FOCUS_MODE_INFINITY)) { - new_focus_mode = FOCUS_MODE_INFINITY; - mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, - BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR); - } - else { - LOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str); - ret = UNKNOWN_ERROR; - } - - if (0 <= new_focus_mode) { - if (mSecCamera->setFocusMode(new_focus_mode) < 0) { - LOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str); - } - } - } - - // flash.. - if (new_flash_mode_str != NULL) { - int new_flash_mode = -1; - - if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_OFF)) - new_flash_mode = FLASH_MODE_OFF; - else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_AUTO)) - new_flash_mode = FLASH_MODE_AUTO; - else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_ON)) - new_flash_mode = FLASH_MODE_ON; - else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_TORCH)) - new_flash_mode = FLASH_MODE_TORCH; - else { - LOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye - ret = UNKNOWN_ERROR; - } - if (0 <= new_flash_mode) { - if (mSecCamera->setFlashMode(new_flash_mode) < 0) { - LOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str); - } - } - } - - // scene.. - if (0 <= new_scene_mode) { - if (mSecCamera->setSceneMode(new_scene_mode) < 0) { - LOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode); - ret = UNKNOWN_ERROR; - } else { - mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str); - } - } - } - - // --------------------------------------------------------------------------- - - // image effect - const char *new_image_effect_str = params.get(CameraParameters::KEY_EFFECT); - if (new_image_effect_str != NULL) { - - int new_image_effect = -1; - - if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NONE)) - new_image_effect = IMAGE_EFFECT_NONE; - else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_MONO)) - new_image_effect = IMAGE_EFFECT_BNW; - else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_SEPIA)) - new_image_effect = IMAGE_EFFECT_SEPIA; - else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_AQUA)) - new_image_effect = IMAGE_EFFECT_AQUA; - else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NEGATIVE)) - new_image_effect = IMAGE_EFFECT_NEGATIVE; - else { - //posterize, whiteboard, blackboard, solarize - LOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str); - ret = UNKNOWN_ERROR; - } - - if (new_image_effect >= 0) { - if (mSecCamera->setImageEffect(new_image_effect) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect); - ret = UNKNOWN_ERROR; - } else { - const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT); - - if (old_image_effect_str) { - if (strcmp(old_image_effect_str, new_image_effect_str)) { - setSkipFrame(EFFECT_SKIP_FRAME); - } - } - - mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str); - } - } - } - - //vt mode - int new_vtmode = mInternalParameters.getInt("vtmode"); - if (0 <= new_vtmode) { - if (mSecCamera->setVTmode(new_vtmode) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __func__, new_vtmode); - ret = UNKNOWN_ERROR; - } - } - - //contrast - int new_contrast = mInternalParameters.getInt("contrast"); - - if (0 <= new_contrast) { - if (mSecCamera->setContrast(new_contrast) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setContrast(%d)", __func__, new_contrast); - ret = UNKNOWN_ERROR; - } - } - - //WDR - int new_wdr = mInternalParameters.getInt("wdr"); - - if (0 <= new_wdr) { - if (mSecCamera->setWDR(new_wdr) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr); - ret = UNKNOWN_ERROR; - } - } - - //anti shake - int new_anti_shake = mInternalParameters.getInt("anti-shake"); - - if (0 <= new_anti_shake) { - if (mSecCamera->setAntiShake(new_anti_shake) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake); - ret = UNKNOWN_ERROR; - } - } - - // gps latitude - const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE); - if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) { - LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str); - ret = UNKNOWN_ERROR; - } else { - if (new_gps_latitude_str) { - mParameters.set(CameraParameters::KEY_GPS_LATITUDE, new_gps_latitude_str); - } else { - mParameters.remove(CameraParameters::KEY_GPS_LATITUDE); - } - } - - // gps longitude - const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE); - - if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) { - LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str); - ret = UNKNOWN_ERROR; - } else { - if (new_gps_longitude_str) { - mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, new_gps_longitude_str); - } else { - mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE); - } - } - - // gps altitude - const char *new_gps_altitude_str = params.get(CameraParameters::KEY_GPS_ALTITUDE); - - if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) { - LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str); - ret = UNKNOWN_ERROR; - } else { - if (new_gps_altitude_str) { - mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, new_gps_altitude_str); - } else { - mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE); - } - } - - // gps timestamp - const char *new_gps_timestamp_str = params.get(CameraParameters::KEY_GPS_TIMESTAMP); - - if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) { - LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str); - ret = UNKNOWN_ERROR; - } else { - if (new_gps_timestamp_str) { - mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, new_gps_timestamp_str); - } else { - mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP); - } - } - - // gps processing method - const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); - - if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) { - LOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str); - ret = UNKNOWN_ERROR; - } else { - if (new_gps_processing_method_str) { - mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, new_gps_processing_method_str); - } else { - mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD); - } - } - - // Recording size - int new_recording_width = mInternalParameters.getInt("recording-size-width"); - int new_recording_height= mInternalParameters.getInt("recording-size-height"); - - if (0 < new_recording_width && 0 < new_recording_height) { - if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_recording_width, new_recording_height); - ret = UNKNOWN_ERROR; - } - } else { - if (mSecCamera->setRecordingSize(new_preview_width, new_preview_height) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_preview_width, new_preview_height); - ret = UNKNOWN_ERROR; - } - } - - //gamma - const char *new_gamma_str = mInternalParameters.get("video_recording_gamma"); - - if (new_gamma_str != NULL) { - int new_gamma = -1; - if (!strcmp(new_gamma_str, "off")) - new_gamma = GAMMA_OFF; - else if (!strcmp(new_gamma_str, "on")) - new_gamma = GAMMA_ON; - else { - LOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str); - ret = UNKNOWN_ERROR; - } - - if (0 <= new_gamma) { - if (mSecCamera->setGamma(new_gamma) < 0) { - LOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma); - ret = UNKNOWN_ERROR; - } - } - } - - //slow ae - const char *new_slow_ae_str = mInternalParameters.get("slow_ae"); - - if (new_slow_ae_str != NULL) { - int new_slow_ae = -1; - - if (!strcmp(new_slow_ae_str, "off")) - new_slow_ae = SLOW_AE_OFF; - else if (!strcmp(new_slow_ae_str, "on")) - new_slow_ae = SLOW_AE_ON; - else { - LOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str); - ret = UNKNOWN_ERROR; - } - - if (0 <= new_slow_ae) { - if (mSecCamera->setSlowAE(new_slow_ae) < 0) { - LOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae); - ret = UNKNOWN_ERROR; - } - } - } - - /*Camcorder fix fps*/ - int new_sensor_mode = mInternalParameters.getInt("cam_mode"); - - if (0 <= new_sensor_mode) { - if (mSecCamera->setSensorMode(new_sensor_mode) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode); - ret = UNKNOWN_ERROR; - } - } else { - new_sensor_mode=0; - } - - /*Shot mode*/ - int new_shot_mode = mInternalParameters.getInt("shot_mode"); - - if (0 <= new_shot_mode) { - if (mSecCamera->setShotMode(new_shot_mode) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode); - ret = UNKNOWN_ERROR; - } - } else { - new_shot_mode=0; - } - - //blur for Video call - int new_blur_level = mInternalParameters.getInt("blur"); - - if (0 <= new_blur_level) { - if (mSecCamera->setBlur(new_blur_level) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setBlur(%d)", __func__, new_blur_level); - ret = UNKNOWN_ERROR; - } - } - - - // chk_dataline - int new_dataline = mInternalParameters.getInt("chk_dataline"); - - if (0 <= new_dataline) { - if (mSecCamera->setDataLineCheck(new_dataline) < 0) { - LOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline); - ret = UNKNOWN_ERROR; - } - } - LOGV("%s return ret = %d", __func__, ret); - - if (mSecCamera->stopPreview() < 0) { - LOGE("ERR(%s):Fail on mSecCamera->stopPreview", __func__); - ret = UNKNOWN_ERROR; - } - - //sleep a bit to give the cam a chance to get ready - usleep(100000); - if (mSecCamera->startPreview() < 0) { - LOGE("ERR(%s):Fail on mSecCamera->startPreview", __func__); - ret = UNKNOWN_ERROR; - } - - return ret; -} - -CameraParameters CameraHardwareSec::getParameters() const -{ - LOGV("%s :", __func__); - return mParameters; -} - -status_t CameraHardwareSec::sendCommand(int32_t command, int32_t arg1, int32_t arg2) -{ - return BAD_VALUE; -} - -void CameraHardwareSec::release() -{ - LOGV("%s :", __func__); - - /* shut down any threads we have that might be running. do it here - * instead of the destructor. we're guaranteed to be on another thread - * than the ones below. if we used the destructor, since the threads - * have a reference to this object, we could wind up trying to wait - * for ourself to exit, which is a deadlock. - */ - if (mPreviewThread != NULL) { - /* this thread is normally already in it's threadLoop but blocked - * on the condition variable or running. signal it so it wakes - * up and can exit. - */ - mPreviewThread->requestExit(); - mExitPreviewThread = true; - mPreviewRunning = true; /* let it run so it can exit */ - mPreviewCondition.signal(); - mPreviewThread->requestExitAndWait(); - mPreviewThread.clear(); - } - if (mAutoFocusThread != NULL) { - /* this thread is normally already in it's threadLoop but blocked - * on the condition variable. signal it so it wakes up and can exit. - */ - mFocusLock.lock(); - mAutoFocusThread->requestExit(); - mExitAutoFocusThread = true; - mFocusCondition.signal(); - mFocusLock.unlock(); - mAutoFocusThread->requestExitAndWait(); - mAutoFocusThread.clear(); - } - if (mPictureThread != NULL) { - mPictureThread->requestExitAndWait(); - mPictureThread.clear(); - } - if (mRawHeap != NULL) - mRawHeap.clear(); - - if (mJpegHeap != NULL) - mJpegHeap.clear(); - - if (mPreviewHeap != NULL) { - LOGI("%s: calling mPreviewHeap.dispose()", __func__); - mPreviewHeap->dispose(); - mPreviewHeap.clear(); - } - - if (mRecordHeap != NULL) - mRecordHeap.clear(); - -#if defined(BOARD_USES_OVERLAY) - if (mUseOverlay) { - mOverlay->destroy(); - mUseOverlay = false; - mOverlay = NULL; - } -#endif - - /* close after all the heaps are cleared since those - * could have dup'd our file descriptor. - */ - mSecCamera->DeinitCamera(); - mSecCamera = NULL; - -} - -wp CameraHardwareSec::singleton; - -sp CameraHardwareSec::createInstance(int cameraId) -{ - LOGV("%s :", __func__); - if (singleton != 0) { - sp hardware = singleton.promote(); - if (hardware != 0) { - return hardware; - } - } - sp hardware(new CameraHardwareSec(cameraId)); - singleton = hardware; - return hardware; -} - -static CameraInfo sCameraInfo[] = { - { - CAMERA_FACING_BACK, - 90, /* orientation */ - }, -#ifdef FFC_PRESENT - { - CAMERA_FACING_FRONT, - 0, /* orientation */ - } -#endif -}; - -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 HAL_openCameraHardware(int cameraId) -{ - return CameraHardwareSec::createInstance(cameraId); -} - -}; // namespace android diff --git a/libcamera/SecCameraHWInterface.h b/libcamera/SecCameraHWInterface.h deleted file mode 100644 index 75526c6..0000000 --- a/libcamera/SecCameraHWInterface.h +++ /dev/null @@ -1,212 +0,0 @@ -/* -** -** Copyright 2008, The Android Open Source Project -** Copyright 2010, Samsung Electronics Co. LTD -** -** 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_SEC_H -#define ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H - -#include "SecCamera.h" -#include -#include -#include -#include -#include - -namespace android { -class CameraHardwareSec : public CameraHardwareInterface { -public: - virtual sp getPreviewHeap() const; - virtual sp 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(); -#if defined(BOARD_USES_OVERLAY) - virtual bool useOverlay(); - virtual status_t setOverlay(const sp &overlay); -#endif - virtual void stopPreview(); - virtual bool previewEnabled(); - - virtual status_t startRecording(); - virtual void stopRecording(); - virtual bool recordingEnabled(); - virtual void releaseRecordingFrame(const sp &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 &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 createInstance(int cameraId); - -private: - CameraHardwareSec(int cameraId); - virtual ~CameraHardwareSec(); - - static wp singleton; - - static const int kBufferCount = MAX_BUFFERS; - static const int kBufferCountForRecord = MAX_BUFFERS; - - class PreviewThread : public Thread { - CameraHardwareSec *mHardware; - public: - PreviewThread(CameraHardwareSec *hw): - Thread(false), - mHardware(hw) { } - virtual void onFirstRef() { - run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY); - } - virtual bool threadLoop() { - mHardware->previewThreadWrapper(); - return false; - } - }; - - class PictureThread : public Thread { - CameraHardwareSec *mHardware; - public: - PictureThread(CameraHardwareSec *hw): - Thread(false), - mHardware(hw) { } - virtual bool threadLoop() { - mHardware->pictureThread(); - mHardware->mSecCamera->endSnapshot(); - return false; - } - }; - - class AutoFocusThread : public Thread { - CameraHardwareSec *mHardware; - public: - AutoFocusThread(CameraHardwareSec *hw): Thread(false), mHardware(hw) { } - virtual void onFirstRef() { - run("CameraAutoFocusThread", PRIORITY_DEFAULT); - } - virtual bool threadLoop() { - mHardware->autoFocusThread(); - return true; - } - }; - - void initDefaultParameters(int cameraId); - void initHeapLocked(); - - sp mPreviewThread; - int previewThread(); - int previewThreadWrapper(); - - sp mAutoFocusThread; - int autoFocusThread(); - - sp mPictureThread; - int pictureThread(); - bool mCaptureInProgress; - - int save_jpeg(unsigned char *real_jpeg, int jpeg_size); - void save_postview(const char *fname, uint8_t *buf, - uint32_t size); - int decodeInterleaveData(unsigned char *pInterleaveData, - int interleaveDataSize, - int yuvWidth, - int yuvHeight, - int *pJpegSize, - void *pJpegData, - void *pYuvData); - bool YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight); - bool scaleDownYuv422(char *srcBuf, uint32_t srcWidth, - uint32_t srcHight, char *dstBuf, - uint32_t dstWidth, uint32_t dstHight); - - bool CheckVideoStartMarker(unsigned char *pBuf); - bool CheckEOIMarker(unsigned char *pBuf); - bool FindEOIMarkerInJPEG(unsigned char *pBuf, - int dwBufSize, int *pnJPEGsize); - bool SplitFrame(unsigned char *pFrame, int dwSize, - int dwJPEGLineLength, int dwVideoLineLength, - int dwVideoHeight, void *pJPEG, - int *pdwJPEGSize, void *pVideo, - int *pdwVideoSize); - void setSkipFrame(int frame); - /* used by auto focus thread to block until it's told to run */ - mutable Mutex mFocusLock; - mutable Condition mFocusCondition; - bool mExitAutoFocusThread; - - /* used by preview thread to block until it's told to run */ - mutable Mutex mPreviewLock; - mutable Condition mPreviewCondition; - mutable Condition mPreviewStoppedCondition; - bool mPreviewRunning; - bool mExitPreviewThread; - - /* used to guard threading state */ - mutable Mutex mStateLock; - - CameraParameters mParameters; - CameraParameters mInternalParameters; - - sp mPreviewHeap; - sp mRawHeap; - sp mRecordHeap; - sp mJpegHeap; - sp mBuffers[kBufferCount]; - sp mRecordBuffers[kBufferCountForRecord]; - - SecCamera *mSecCamera; - const __u8 *mCameraSensorName; - - mutable Mutex mSkipFrameLock; - int mSkipFrame; - -#if defined(BOARD_USES_OVERLAY) - sp mOverlay; - bool mUseOverlay; - int mOverlayBufferIdx; -#endif - - notify_callback mNotifyCb; - data_callback mDataCb; - data_callback_timestamp mDataCbTimestamp; - void *mCallbackCookie; - - int32_t mMsgEnabled; - - bool mRecordRunning; - mutable Mutex mRecordLock; - int mPostViewWidth; - int mPostViewHeight; - int mPostViewSize; -}; - -}; // namespace android - -#endif -- cgit v1.1