diff options
Diffstat (limited to 'libcamera')
| -rw-r--r-- | libcamera/Android.mk | 45 | ||||
| -rw-r--r-- | libcamera/SecCamera.cpp | 3932 | ||||
| -rw-r--r-- | libcamera/SecCamera.h | 886 | ||||
| -rw-r--r-- | libcamera/SecCameraHWInterface.cpp | 2370 | ||||
| -rw-r--r-- | libcamera/SecCameraHWInterface.h | 257 |
5 files changed, 7490 insertions, 0 deletions
diff --git a/libcamera/Android.mk b/libcamera/Android.mk new file mode 100644 index 0000000..192af24 --- /dev/null +++ b/libcamera/Android.mk @@ -0,0 +1,45 @@ +# When zero we link against libqcamera; when 1, we dlopen libqcamera. +ifeq ($(BOARD_CAMERA_LIBRARIES),libcamera) + +DLOPEN_LIBSECCAMERA:=1 + +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_CFLAGS:=-fno-short-enums +LOCAL_CFLAGS+=-DDLOPEN_LIBSECCAMERA=$(DLOPEN_LIBSECCAMERA) +LOCAL_CFLAGS += -DSWP1_CAMERA_ADD_ADVANCED_FUNCTION + + +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 +LOCAL_SHARED_LIBRARIES+= libcamera_client + +#Enable the below code to show the video output (without GUI) on TV +#ifeq ($(BOARD_USES_HDMI), true) +#LOCAL_CFLAGS+=-DENABLE_HDMI_DISPLAY \ +# -DBOARD_HDMI_STD=$(BOARD_HDMI_STD) +# +#LOCAL_C_INCLUDES += $(LOCAL_PATH)/../include +#LOCAL_SHARED_LIBRARIES+= libhdmi +#endif + +ifeq ($(DLOPEN_LIBSECCAMERA),1) +LOCAL_SHARED_LIBRARIES+= libdl +endif + +LOCAL_MODULE:= libcamera + +include $(BUILD_SHARED_LIBRARY) + +endif + diff --git a/libcamera/SecCamera.cpp b/libcamera/SecCamera.cpp new file mode 100644 index 0000000..186421e --- /dev/null +++ b/libcamera/SecCamera.cpp @@ -0,0 +1,3932 @@ +/* + * Copyright@ 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" +#define ADD_THUMB_IMG 1 + +#include <utils/Log.h> + +#include <string.h> +#include <stdlib.h> +#include <sys/poll.h> +#include "SecCamera.h" +#include "cutils/properties.h" + +#ifdef BOARD_USES_SDTV +#include "TvOut.h" +#endif + +using namespace android; + +#ifdef BOARD_USES_SDTV +#include "utils/Timers.h" +//#define MEASURE_DURATION_TVOUT +sp<TvOut> mtvoutcamera; +static bool suspendTvInit = false ; +#define TVOUT_RESUME_TIME 4 +#endif + +//#define PERFORMANCE //Uncomment to measure performance +//#define DUMP_YUV //Uncomment to take a dump of YUV frame during capture + +#define CHECK(return_value) \ + if(return_value < 0) \ + { \ + LOGE("%s::%d fail. errno: %s\n", __func__,__LINE__, strerror(errno)); \ + return -1; \ + } \ + +#define CHECK_PTR(return_value) \ + if(return_value < 0) \ + { \ + LOGE("%s::%d fail\n", __func__,__LINE__); \ + 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; +static int cam_id = 0; + +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 inline unsigned long check_performance() +{ + unsigned long time = 0; + static unsigned long max=0, min=0xffffffff; + + if(time_start.tv_sec == 0 && time_start.tv_usec == 0) { + gettimeofday(&time_start, NULL); + } else { + gettimeofday(&time_stop, NULL); + time = measure_time(&time_start, &time_stop); + if(max < time) max = time; + if(min > time) min = time; + LOGV("Interval: %lu us (%2.2lf fps), min:%2.2lf fps, max:%2.2lf fps\n", time, 1000000.0/time, 1000000.0/max, 1000000.0/min); + gettimeofday(&time_start, NULL); + } + + return time; +} + +static int close_buffers(struct fimc_buffer *buffers) +{ + int i; + + for (i = 0; i < MAX_BUFFERS; i++) { + if (buffers[i].start) + { + munmap(buffers[i].start, buffers[i].length); + //LOGV("munmap():virt. addr[%d]: 0x%x size = %d\n", i, (unsigned int) buffers[i].start, buffers[i].length); + buffers[i].start = NULL; + } + } + + return 0; +} + +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_yuv_buffers(struct fimc_buffer *buffers, int width, int height, unsigned int fmt) +{ + int i, len; + + len = (width * height * get_pixel_depth(fmt)) / 8; + + + for (i = 0; i < MAX_BUFFERS; i++) + { + if(fmt==V4L2_PIX_FMT_NV12T) + { + buffers[i].start = NULL; + buffers[i].length = ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height))+ ALIGN_BUF(ALIGN_W(width) * ALIGN_H(height/2)); + } + else + { + buffers[i].start = NULL; + buffers[i].length = len; + } + } + + return 0; +} + +static int fimc_poll(struct pollfd *events) +{ + int ret; + + ret = poll(events, 1, 5000); + if (ret < 0) { + LOGE("ERR(%s):poll error\n", __FUNCTION__); + return ret; + } + + if (ret == 0) { + LOGE("ERR(%s):No data in 5 secs..\n", __FUNCTION__); + return ret; + } + + return ret; +} + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +static int fimc_esd_poll(struct pollfd *events) +{ + int ret; + + ret = poll(events, 1, 1000); + + if (ret < 0) { + LOGE("ERR(%s):poll error\n", __FUNCTION__); + return ret; + } + + if (ret == 0) { + LOGE("ERR(%s):No data in 1 secs.. Camera Device Reset \n", __FUNCTION__); + return ret; + } + + return ret; +} +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + +#ifdef DUMP_YUV +static int save_yuv(struct fimc_buffer *m_buffers_c, int width, int height, int depth, int index, int frame_count) +{ + FILE *yuv_fp = NULL; + char filename[100], *buffer = NULL; + + /* file create/open, note to "wb" */ + yuv_fp = fopen("/sdcard/camera_dump.yuv", "wb"); + if (yuv_fp==NULL) + { + LOGE("Save YUV] file open error"); + return -1; + } + + buffer = (char *) malloc(m_buffers_c[index].length); + if(buffer == NULL) + { + LOGE("Save YUV] buffer alloc failed"); + if(yuv_fp) fclose(yuv_fp); + return -1; + } + + memcpy(buffer, m_buffers_c[index].start, m_buffers_c[index].length); + + fflush(stdout); + + fwrite(buffer, 1, m_buffers_c[index].length, yuv_fp); + + fflush(yuv_fp); + + if(yuv_fp) + fclose(yuv_fp); + if(buffer) + free(buffer); + + return 0; +} +#endif //DUMP_YUV + +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", __FUNCTION__); + return -1; + } + + if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { + LOGE("ERR(%s):no capture devices\n", __FUNCTION__); + return -1; + } + + return ret; +} + +static int fimc_v4l2_enuminput(int fp) +{ + struct v4l2_input input; + + input.index = cam_id; + if(ioctl(fp, VIDIOC_ENUMINPUT, &input) != 0) + { + LOGE("ERR(%s):No matching index found\n", __FUNCTION__); + return -1; + } + LOGI("Name of input channel[%d] is %s\n", input.index, input.name); + + return input.index; +} + + +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", __FUNCTION__); + 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", __FUNCTION__); + 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; + + //LOGE("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", __FUNCTION__); + 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) { + LOGD("passed fmt = %d 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", __FUNCTION__); + return -1; + } + + return req.count; +} + +static int fimc_v4l2_querybuf(int fp, struct fimc_buffer *buffers, enum v4l2_buf_type type, int nr_frames) +{ + struct v4l2_buffer v4l2_buf; + int i, ret; + + for(i = 0; i < nr_frames; i++) + { + v4l2_buf.type = type; + v4l2_buf.memory = V4L2_MEMORY_MMAP; + v4l2_buf.index = i; + + ret = ioctl(fp , VIDIOC_QUERYBUF, &v4l2_buf); + if(ret < 0) + { + LOGE("ERR(%s):VIDIOC_QUERYBUF failed\n", __FUNCTION__); + return -1; + } + + if(nr_frames == 1) + { + buffers[i].length = v4l2_buf.length; + if ((buffers[i].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",__FUNCTION__, __LINE__); + return -1; + } + + //LOGV("buffers[%d].start = %p v4l2_buf.length = %d", i, buffers[i].start, v4l2_buf.length); + } + else + { + +#if defined DUMP_YUV || defined (SEND_YUV_RECORD_DATA) + buffers[i].length = v4l2_buf.length; + if ((buffers[i].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",__FUNCTION__, __LINE__); + return -1; + } + + //LOGV("buffers[%d].start = %p v4l2_buf.length = %d", i, buffers[i].start, v4l2_buf.length); +#endif + } + + } + + 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", __FUNCTION__); + return ret; + } + + return ret; +} + +static int fimc_v4l2_streamoff(int fp) +{ + enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + int ret; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGE("%s()", __FUNCTION__); +#endif + ret = ioctl(fp, VIDIOC_STREAMOFF, &type); + if (ret < 0) { + LOGE("ERR(%s):VIDIOC_STREAMOFF failed\n", __FUNCTION__); + 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", __FUNCTION__); + 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\n", __FUNCTION__); + 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 failed\n", __FUNCTION__); + 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 failed, ret: %d\n", __FUNCTION__, ret); + return ret; + } + + return ctrl.value; +} + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +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", __FUNCTION__); + + return ret; +} +#endif +static int fimc_v4l2_g_parm(int fp) +{ + struct v4l2_streamparm stream; + int ret; + + stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + + ret = ioctl(fp, VIDIOC_G_PARM, &stream); + if (ret < 0) { + LOGE("ERR(%s):VIDIOC_G_PARM failed\n", __FUNCTION__); + return -1; + } + +// LOGV("timeperframe: numerator %d, denominator %d\n", \ + stream.parm.capture.timeperframe.numerator, \ + stream.parm.capture.timeperframe.denominator); + + return 0; +} + +static int fimc_v4l2_s_parm(int fp, int fps_numerator, int fps_denominator) +{ + struct v4l2_streamparm stream; + int ret; + + stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + stream.parm.capture.capturemode = 0; + stream.parm.capture.timeperframe.numerator = fps_numerator; + stream.parm.capture.timeperframe.denominator = fps_denominator; + + ret = ioctl(fp, VIDIOC_S_PARM, &stream); + if (ret < 0) { + LOGE("ERR(%s):VIDIOC_S_PARM failed\n", __FUNCTION__); + return ret; + } + + return 0; +} + +#if 0 +static int fimc_v4l2_s_parm_ex(int fp, int mode, int no_dma_op) //Kamat: not present in new code +{ + struct v4l2_streamparm stream; + int ret; + + stream.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + stream.parm.capture.capturemode = mode; + if(no_dma_op) + stream.parm.capture.reserved[0] = 100; + + ret = ioctl(fp, VIDIOC_S_PARM, &stream); + if (ret < 0) { + LOGE("ERR(%s):VIDIOC_S_PARM_EX failed\n", __FUNCTION__); + return ret; + } + + return 0; +} +#endif + +// ====================================================================== +// Constructor & Destructor + +SecCamera::SecCamera() : + m_focus_mode(1), + m_iso(0), + m_camera_id(CAMERA_ID_BACK), + m_preview_v4lformat(-1), + 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(0), + m_fps(30), + m_autofocus(AUTO_FOCUS_ON), + m_white_balance(WHITE_BALANCE_AUTO), + m_brightness(BRIGHTNESS_NORMAL), + m_image_effect(IMAGE_EFFECT_NONE), + #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + m_anti_banding(0), + m_flash_mode(1), + m_metering(2), + m_contrast(2), + m_saturation(2), + m_sharpness(2), + m_wdr(0), + m_anti_shake(0), + m_zoom_level(0), + m_object_tracking(0), + m_smart_auto(0), + m_beauty_shot(0), + m_vintage_mode(1), + m_face_detect(0), + m_gps_latitude(0), + m_gps_longitude(0), + m_gps_altitude(0), + m_gps_timestamp(0), + m_vtmode(0), + m_sensor_mode(0), + m_exif_orientation(1), + m_blur_level(0), + m_chk_dataline(0), + m_video_gamma(0), + m_slow_ae(0), + #else + m_image_effect(IMAGE_EFFECT_ORIGINAL), + #endif + m_flag_camera_start(0), + m_jpeg_thumbnail_width (0), + m_jpeg_thumbnail_height(0), + m_jpeg_quality(100), + m_camera_af_flag(-1), + m_shot_mode(0) +{ + LOGV("%s()", __FUNCTION__); +#ifdef BOARD_USES_SDTV + nsecs_t before1, after1; + +#ifdef MEASURE_DURATION_TVOUT + before1 = systemTime(SYSTEM_TIME_MONOTONIC); +#endif + //suspend + if(mtvoutcamera == 0) { + mtvoutcamera = TvOut::connect(); + } + if(mtvoutcamera != 0 ) + { + if (mtvoutcamera->isEnabled() ) + { + mtvoutcamera->DisableTvOut() ; // //TvOutSuspend("Tvout is not available! so what can i do, close camera or any other app which uses fimc"); + suspendTvInit = true; + } + } + +#ifdef MEASURE_DURATION_TVOUT + after1 = systemTime(SYSTEM_TIME_MONOTONIC); + LOGD("%s: MEASURE_DURATION_TVOUT duration=%lld", __func__, ns2us(after1-before1)); +#endif + +#endif + initCamera(); +} + +int SecCamera::flagCreate(void) const +{ + LOGV("%s() : %d", __FUNCTION__, m_flag_init); + return m_flag_init; +} + +SecCamera::~SecCamera() +{ + LOGV("%s()", __FUNCTION__); + + DeinitCamera(); +#ifdef BOARD_USES_SDTV + nsecs_t before1, after1; + +#ifdef MEASURE_DURATION_TVOUT + before1 = systemTime(SYSTEM_TIME_MONOTONIC); +#endif + + //resume + if(mtvoutcamera != 0 ) + { + if (!mtvoutcamera->isEnabled() && (mtvoutcamera->isSuspended() )) + { + mtvoutcamera->TvOutResume(TVOUT_RESUME_TIME); + } + } + suspendTvInit = false; +#ifdef MEASURE_DURATION_TVOUT + after1 = systemTime(SYSTEM_TIME_MONOTONIC); + LOGD("%s: MEASURE_DURATION_TVOUT duration=%lld", __func__, ns2us(after1-before1)); +#endif +#endif +} + +int SecCamera::initCamera() +{ + LOGV("%s()", __FUNCTION__); + int ret = 0, index = 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; + +#ifdef BOARD_USES_SDTV + nsecs_t before1, after1; + +#ifdef MEASURE_DURATION_TVOUT + before1 = systemTime(SYSTEM_TIME_MONOTONIC); +#endif + + //suspend + if(mtvoutcamera == 0) { + mtvoutcamera = TvOut::connect(); + } + + + + if(mtvoutcamera != 0 ) + { + + if ( mtvoutcamera->isEnabled() ) + { + + mtvoutcamera->DisableTvOut() ; + suspendTvInit = true; + } + } + +#ifdef MEASURE_DURATION_TVOUT + after1 = systemTime(SYSTEM_TIME_MONOTONIC); + LOGD("%s: MEASURE_DURATION_TVOUT duration=%lld", __func__, ns2us(after1-before1)); +#endif + + +#endif +#ifndef JPEG_FROM_SENSOR + m_jpeg_fd = SsbSipJPEGEncodeInit(); + LOGD("(%s):JPEG device open ID = %d\n", __FUNCTION__,m_jpeg_fd); + if(m_jpeg_fd < 0) + { + m_jpeg_fd = 0; + LOGE("ERR(%s):Cannot open a jpeg device file\n", __FUNCTION__); + return -1; + } +#endif + + 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", __FUNCTION__, CAMERA_DEV_NAME, strerror(errno)); +#ifndef JPEG_FROM_SENSOR + SsbSipJPEGEncodeDeInit(m_jpeg_fd); +#endif + return -1; + } + + if(m_cam_fd < 3) { // for 0, 1, 2 + LOGE("ERR(%s):m_cam_fd is %d\n", __FUNCTION__, 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", __FUNCTION__, 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", __FUNCTION__, 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); + index = fimc_v4l2_enuminput(m_cam_fd); + CHECK(index); + ret = fimc_v4l2_s_input(m_cam_fd, index); + CHECK(ret); + +#ifdef DUAL_PORT_RECORDING + m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR); + if (m_cam_fd2 < 0) + { + LOGE("ERR(%s):Cannot open %s (error : %s)\n", __FUNCTION__, 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", __FUNCTION__, 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", __FUNCTION__, 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", __FUNCTION__, 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); + index = fimc_v4l2_enuminput(m_cam_fd2); + CHECK(index); + ret = fimc_v4l2_s_input(m_cam_fd2, index); + CHECK(ret); +#endif + setExifFixedAttribute(); + + m_flag_init = 1; + } + return 0; +} + +void SecCamera::resetCamera() +{ + LOGV("%s()", __FUNCTION__); + DeinitCamera(); + initCamera(); +} + +void SecCamera::DeinitCamera() +{ + LOGV("%s()", __FUNCTION__); + + if(m_flag_init) + { +#ifndef JPEG_FROM_SENSOR + if(m_jpeg_fd > 0) + { + if(SsbSipJPEGEncodeDeInit(m_jpeg_fd) != JPEG_OK) + { + LOGE("ERR(%s):Fail on SsbSipJPEGEncodeDeInit\n", __FUNCTION__); + } + m_jpeg_fd = 0; + } +#endif + LOGE("DeinitCamera: m_cam_fd(%d)", m_cam_fd); + if(m_cam_fd > -1) + { + close(m_cam_fd); + m_cam_fd = -1; + } +#ifdef DUAL_PORT_RECORDING + LOGE("DeinitCamera: m_cam_fd2(%d)", m_cam_fd2); + if(m_cam_fd2 > -1) + { + close(m_cam_fd2); + m_cam_fd2 = -1; + } +#endif + 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; + } + +#ifdef BOARD_USES_SDTV + nsecs_t before1, after1; + +#ifdef MEASURE_DURATION_TVOUT + before1 = systemTime(SYSTEM_TIME_MONOTONIC); +#endif + + if(mtvoutcamera == 0) { + mtvoutcamera = TvOut::connect(); + + } + + //resume + if(mtvoutcamera != 0 ) + { + + if(mtvoutcamera->isSuspended()) + { + mtvoutcamera->TvOutResume(TVOUT_RESUME_TIME); + } + } +#ifdef MEASURE_DURATION_TVOUT + after1 = systemTime(SYSTEM_TIME_MONOTONIC); + LOGD("%s: MEASURE_DURATION_TVOUT duration=%lld", __func__, ns2us(after1-before1)); +#endif +#endif + m_flag_init = 0; + usleep(100000); //100 ms delay to allow proper closure of fimc device. + } +} + + +int SecCamera::getCameraFd(void) +{ + return m_cam_fd; +} + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +int SecCamera::setCameraSensorReset(void) +{ + int ret = 0; + + LOGV("%s", __FUNCTION__); + + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_RESET, 0); + CHECK(ret); + + return ret; +} + +int SecCamera::setDefultIMEI(int imei) +{ + LOGV("%s(m_default_imei (%d))", __FUNCTION__, imei); + + if(m_default_imei != imei) + { + m_default_imei = imei; + } + return 0; +} + +int SecCamera::getDefultIMEI(void) +{ + return m_default_imei; +} + + +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + + +// ====================================================================== +// Preview + +int SecCamera::flagPreviewStart(void) +{ + LOGV("%s:started(%d)", __func__, m_flag_camera_start); + + return m_flag_camera_start > 0; +} + +int SecCamera::startPreview(void) +{ +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGV("%s()", __FUNCTION__); +#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + LOGE("%s()", __FUNCTION__); +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + + // aleady started + if(m_flag_camera_start > 0) + { + LOGE("ERR(%s):Preview was already started\n", __FUNCTION__); + return 0; + } + + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + 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); + + init_yuv_buffers(m_buffers_c, m_preview_width, m_preview_height, m_preview_v4lformat); + ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); + CHECK(ret); + ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); + CHECK(ret); + + /* g_parm, s_parm sample */ + ret = fimc_v4l2_g_parm(m_cam_fd); + CHECK(ret); + ret = fimc_v4l2_s_parm(m_cam_fd, 1, m_fps); + CHECK(ret); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGE("%s()m_preview_width: %d m_preview_height: %d m_angle: %d\n", __FUNCTION__, m_preview_width,m_preview_height,m_angle); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_ROTATION, m_angle); + CHECK(ret); + + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CHECK_DATALINE, m_chk_dataline); + CHECK(ret); + + if(m_camera_id == CAMERA_ID_BACK) + { + /*Should be set before starting preview*/ + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_BANDING, m_anti_banding); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, m_iso); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, m_brightness); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, m_fps); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, m_metering); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_GAMMA, m_video_gamma); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_SLOW_AE, m_slow_ae); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, m_image_effect); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, m_white_balance); + CHECK(ret); + } + else + { + /* VT mode setting */ + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VT_MODE, m_vtmode); + CHECK(ret); + } + +#endif + /* 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); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + m_flag_camera_start = 1; //Kamat check + + if(m_camera_id == CAMERA_ID_BACK) { + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, m_image_effect); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, m_white_balance); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, m_iso); + CHECK(ret); + if(m_focus_mode ==FOCUS_MODE_FACEDETECT) + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO); + else{ + if(m_shot_mode == 2){ //Panorama shot + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, m_focus_mode); + CHECK(ret); + m_camera_af_flag = -1; + } + else if(m_shot_mode == 3){ //Smile shot + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, m_focus_mode); + CHECK(ret); + m_camera_af_flag = -1; + } + else if (m_camera_af_flag < 0) { //After captur, Focus is fixed. + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, m_focus_mode); + CHECK(ret); + m_camera_af_flag = 0; + } + } + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, m_fps); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, m_metering); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, m_saturation); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, m_contrast); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ZOOM, m_zoom_level); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SENSOR_MODE, m_sensor_mode); + CHECK(ret); + // Apply the scene mode only in camera not in camcorder + if (!m_sensor_mode) + { + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, m_scene_mode); + CHECK(ret); + } + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, m_brightness); + CHECK(ret); + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, m_sharpness); + CHECK(ret); + } + else // In case VGA camera + { + /* Brightness setting */ + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, m_brightness); + CHECK(ret); + } +#endif + + // 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); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGE("%s: get the first frame of the preview\n", __FUNCTION__); +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + +#ifndef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + m_flag_camera_start = 1; //Kamat check +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + +#ifdef ENABLE_HDMI_DISPLAY + hdmi_initialize(m_preview_width,m_preview_height); + hdmi_gl_initialize(0); + hdmi_gl_streamoff(0); +#endif +#ifdef BOARD_USES_SDTV + + if(suspendTvInit ==true ) + { + if(!mtvoutcamera->isSuspended()) + { + mtvoutcamera->TvOutSuspend("") ; + } + } + +#endif + + return 0; +} + +int SecCamera::stopPreview(void) +{ +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGE("%s()", __FUNCTION__); + + close_buffers(m_buffers_c); + + if(m_flag_camera_start == 0) { + LOGE("%s: m_flag_camera_start is zero", __FUNCTION__); + return 0; + } +#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + LOGV("%s()", __FUNCTION__); + + close_buffers(m_buffers_c); + + if(m_flag_camera_start == 0) + return 0; +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ +#ifdef ENABLE_HDMI_DISPLAY + hdmi_deinitialize(); + hdmi_gl_streamon(0); +#endif + + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + return -1; + } + + int ret = fimc_v4l2_streamoff(m_cam_fd); + + m_flag_camera_start = 0; //Kamat check + CHECK(ret); + + return ret; +} + +//Recording +#ifdef DUAL_PORT_RECORDING +int SecCamera::startRecord(void) +{ + LOGV("%s()", __FUNCTION__); + + // aleady started + if(m_flag_record_start > 0) + { + LOGE("ERR(%s):Preview was already started\n", __FUNCTION__); + return 0; + } + + if(m_cam_fd2 <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + return -1; + } + + memset(&m_events_c2, 0, sizeof(m_events_c2)); + m_events_c2.fd = m_cam_fd2; + m_events_c2.events = POLLIN | POLLERR; + + int m_record_v4lformat = V4L2_PIX_FMT_NV12T; //Kamat: set suitably + /* enum_fmt, s_fmt sample */ + int ret = fimc_v4l2_enum_fmt(m_cam_fd2,m_record_v4lformat); + CHECK(ret); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGE("%s: m_recording_width = %d, m_recording_height = %d\n", __FUNCTION__, m_recording_width, m_recording_height); + + ret = fimc_v4l2_s_fmt(m_cam_fd2, m_recording_width, m_recording_height,m_record_v4lformat, 0); + + CHECK(ret); + + init_yuv_buffers(m_buffers_c2, m_recording_width, m_recording_height, m_record_v4lformat); +#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + ret = fimc_v4l2_s_fmt(m_cam_fd2, m_preview_width,m_preview_height,m_record_v4lformat, 0); + CHECK(ret); + + init_yuv_buffers(m_buffers_c2, m_preview_width, m_preview_height, m_record_v4lformat); +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + + ret = fimc_v4l2_reqbufs(m_cam_fd2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); + CHECK(ret); + ret = fimc_v4l2_querybuf(m_cam_fd2, m_buffers_c2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); + CHECK(ret); + + /* g_parm, s_parm sample */ + ret = fimc_v4l2_g_parm(m_cam_fd2); + CHECK(ret); + ret = fimc_v4l2_s_parm(m_cam_fd2, 1, m_fps); + CHECK(ret); + + /* start with all buffers in queue */ + for (int 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); + + // It is a delay for a new frame, not to show the previous bigger ugly picture frame. + ret = fimc_poll(&m_events_c2); + CHECK(ret); + + m_flag_record_start = 1; //Kamat check + + return 0; +} + +int SecCamera::stopRecord(void) +{ + if(m_flag_record_start == 0) + return 0; + + LOGV("%s()", __FUNCTION__); + + close_buffers(m_buffers_c2); + + if(m_cam_fd2 <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + return -1; + } + + int ret = fimc_v4l2_streamoff(m_cam_fd2); + + m_flag_record_start = 0; //Kamat check + 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; +} +#endif //DUAL_PORT_RECORDING + +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; +} + +#ifdef SEND_YUV_RECORD_DATA +#define PAGE_ALIGN(x) ((x+0xFFF)&(~0xFFF)) // Set as multiple of 4K +void SecCamera::getYUVBuffers(unsigned char** virYAddr, unsigned char** virCAddr, int index) +{ + *virYAddr = (unsigned char*)m_buffers_c[index].start; + //*virCAddr = (unsigned char*)m_buffers_c[index].start + PAGE_ALIGN(m_preview_width * m_preview_height); + *virCAddr = (unsigned char*)m_buffers_c[index].start + ALIGN_TO_8KB(ALIGN_TO_128B(m_preview_width) * ALIGN_TO_32B(m_preview_height)); +} +#endif + +void SecCamera::pausePreview() +{ + fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0); +} + +int SecCamera::getPreview() +{ + int index; +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + int ret; +#endif + +#ifdef PERFORMANCE + + LOG_TIME_DEFINE(0) + LOG_TIME_DEFINE(1) + + LOG_TIME_START(0) + fimc_poll(&m_events_c); + LOG_TIME_END(0) + LOG_CAMERA("fimc_poll interval: %lu us", LOG_TIME(0)); + + LOG_TIME_START(1) + index = fimc_v4l2_dqbuf(m_cam_fd); + LOG_TIME_END(1) + LOG_CAMERA("fimc_dqbuf interval: %lu us", LOG_TIME(1)); + +#else +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if(m_flag_camera_start == 0 || fimc_esd_poll(&m_events_c) == 0) + { + LOGE("ERR(%s):Start Camera Device Reset \n", __FUNCTION__); + /* 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); + index = fimc_v4l2_enuminput(m_cam_fd); + CHECK(index); + ret = fimc_v4l2_s_input(m_cam_fd, 1000); + CHECK(ret); + //setCameraSensorReset(); + ret = startPreview(); + + if(ret < 0) { + LOGE("ERR(%s): startPreview() return %d\n", __FUNCTION__, ret); + + return 0; + } + } +#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + fimc_poll(&m_events_c); +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + index = fimc_v4l2_dqbuf(m_cam_fd); +#endif + if(!(0 <= index && index < MAX_BUFFERS)) + { + LOGE("ERR(%s):wrong index = %d\n", __FUNCTION__, index); + return -1; + } + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + ret = fimc_v4l2_qbuf(m_cam_fd, index); //Kamat: is it overhead? +#else /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + int ret = fimc_v4l2_qbuf(m_cam_fd, index); //Kamat: is it overhead? +#endif /* SWP1_CAMERA_ADD_ADVANCED_FUNCTION */ + + CHECK(ret); + +#ifdef ENABLE_HDMI_DISPLAY + hdmi_set_v_param(getPhyAddrY(index), getPhyAddrC (index),m_preview_width,m_preview_height); +#endif + return index; + +} + +#ifdef DUAL_PORT_RECORDING +int SecCamera::getRecord() +{ + int index; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if(m_flag_record_start == 0) { + LOGE("%s: m_flag_record_start is 0", __FUNCTION__); + startRecord(); + } +#endif + +#ifdef PERFORMANCE + + LOG_TIME_DEFINE(0) + LOG_TIME_DEFINE(1) + + LOG_TIME_START(0) + fimc_poll(&m_events_c2); + LOG_TIME_END(0) + LOG_CAMERA("fimc_poll interval: %lu us", LOG_TIME(0)); + + LOG_TIME_START(1) + index = fimc_v4l2_dqbuf(m_cam_fd2); + LOG_TIME_END(1) + LOG_CAMERA("fimc_dqbuf interval: %lu us", LOG_TIME(1)); + +#else + fimc_poll(&m_events_c2); + index = fimc_v4l2_dqbuf(m_cam_fd2); +#endif + if(!(0 <= index && index < MAX_BUFFERS)) + { + LOGE("ERR(%s):wrong index = %d\n", __FUNCTION__, index); + return -1; + } + + int ret = fimc_v4l2_qbuf(m_cam_fd2, index); //Kamat: is it overhead? + CHECK(ret); + + return index; +} +#endif //DUAL_PORT_RECORDING + +int SecCamera::setPreviewSize(int width, int height, int pixel_format) +{ + LOGV("%s(width(%d), height(%d), format(%d))", __FUNCTION__, 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 +#ifdef JPEG_FROM_SENSOR +/* + * 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()", __FUNCTION__); + + int ret = 0; + + LOG_TIME_DEFINE(0) + LOG_TIME_DEFINE(1) + + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + return 0; + } + + if(m_flag_camera_start > 0) + { + LOG_TIME_START(0) + 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_PTR(ret); + ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG); + CHECK_PTR(ret); + init_yuv_buffers(m_buffers_c, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat); + + ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); + CHECK_PTR(ret); + ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); + CHECK_PTR(ret); + + ret = fimc_v4l2_g_parm(m_cam_fd); + CHECK_PTR(ret); + ret = fimc_v4l2_s_parm(m_cam_fd, 1, m_fps); + CHECK_PTR(ret); + + ret = fimc_v4l2_qbuf(m_cam_fd, 0); + CHECK_PTR(ret); + + ret = fimc_v4l2_streamon(m_cam_fd); + CHECK_PTR(ret); + LOG_TIME_END(1) + + 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()", __FUNCTION__); + + int index, ret = 0; + unsigned char* addr; + + LOG_TIME_DEFINE(2) +/* kidggang (10.7.5) - Problem - After jpegquality is capture, operation setting is normal. + + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_QUALITY, m_jpeg_quality); + CHECK_PTR(ret); +*/ + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + //exif orient info +// ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_ORIENTATION, m_exif_orientation); //kidggang +// CHECK_PTR(ret); +#if 0//def SWP1_CAMERA_ADD_ADVANCED_FUNCTION + //set gps information + ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_LATITUDE, &m_gps_latitude); + CHECK_PTR(ret); + ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_LONGITUDE, &m_gps_longitude); + CHECK_PTR(ret); + ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_ALTITUDE, &m_gps_altitude); + CHECK_PTR(ret); + ret = fimc_v4l2_s_ext_ctrl(m_cam_fd, V4L2_CID_CAMERA_GPS_TIMESTAMP, &m_gps_timestamp); + CHECK_PTR(ret); +#endif + +/* kidggang + ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CAPTURE, 0); + CHECK_PTR(ret);*/ + + // capture + ret = fimc_poll(&m_events_c); + CHECK_PTR(ret); + index = fimc_v4l2_dqbuf(m_cam_fd); + if(!(0 <= index && index < MAX_BUFFERS)) + { + LOGE("ERR(%s):wrong index = %d\n", __FUNCTION__, index); + return NULL; + } +#endif + + *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\n\n",index, m_snapshot_width, m_snapshot_height); + + addr = (unsigned char*)(m_buffers_c[index].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) + +#if 0 //temporary blocked for build + 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)); +#endif + return addr; +} + +int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc) +{ + JpegEncoder jpgEnc; +#if ADD_THUMB_IMG + 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; + getPostViewConfig(&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); + + mExifInfo.enableThumb = true; +#else + mExifInfo.enableThumb = false; +#endif + + unsigned int exifSize; + setExifChangedAttribute(); + 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); +} + +#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA +int SecCamera::getPostViewOffset(void) +{ + return m_postview_offset; +} +#endif + +#else //#ifdef JPEG_FROM_SENSOR +int SecCamera::getJpegFd(void) +{ + return m_jpeg_fd; +} + +void SecCamera::SetJpgAddr(unsigned char *addr) +{ + SetMapAddr(addr); +} + +#if 0 +int SecCamera::getSnapshot(unsigned char * buffer, unsigned int buffer_size) +{ + LOGV("%s(buffer(%p), size(%d))", __FUNCTION__, buffer, buffer_size); + + if(getSnapshotAndJpeg(buffer, buffer_size, NULL, NULL) == 0) + return -1; + + return 0; +} +#endif + +#endif + +unsigned char* SecCamera::getSnapshotAndJpeg() +{ + LOGV("%s()", __FUNCTION__); + + 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", __FUNCTION__); + return 0; + } + + if(m_flag_camera_start > 0) + { + LOG_TIME_START(0) + 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; + + LOGE("[zzangdol] w %d, h %d\n", m_snapshot_width, m_snapshot_height); + + ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat); + CHECK_PTR(ret); + ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat); + CHECK_PTR(ret); + init_yuv_buffers(m_buffers_c, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat); + + ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); + CHECK_PTR(ret); + ret = fimc_v4l2_querybuf(m_cam_fd, m_buffers_c, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); + CHECK_PTR(ret); + + /* g_parm, s_parm sample */ + ret = fimc_v4l2_g_parm(m_cam_fd); + CHECK_PTR(ret); + ret = fimc_v4l2_s_parm(m_cam_fd, 1, m_fps); + CHECK_PTR(ret); + + ret = fimc_v4l2_qbuf(m_cam_fd, 0); + CHECK_PTR(ret); + + ret = fimc_v4l2_streamon(m_cam_fd);//zzangdolp + CHECK_PTR(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 dqueued buffer = %d snapshot_width = %d snapshot_height = %d\n\n",index, m_snapshot_width, m_snapshot_height); + +#ifdef DUMP_YUV + save_yuv(m_buffers_c, m_snapshot_width, m_snapshot_height, 16, index, 0); +#endif + LOG_TIME_END(2) + + //addr = getPhyAddrY(index); + addr = (unsigned char*)m_buffers_c[index].start; + if(addr == 0) + { + LOGE("%s] Physical address 0"); + } + LOG_TIME_START(5) // post + fimc_v4l2_streamoff(m_cam_fd); +#ifdef DUMP_YUV + close_buffers(m_buffers_c); +#endif + 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)); + + return addr; +} + + +int SecCamera::setSnapshotSize(int width, int height) +{ + LOGV("%s(width(%d), height(%d))", __FUNCTION__, 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", __FUNCTION__); } + else if(m_snapshot_v4lformat == V4L2_PIX_FMT_NV12) { LOGE("%s():SnapshotFormat:V4L2_PIX_FMT_NV12", __FUNCTION__); } + else if(m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T) { LOGE("%s():SnapshotFormat:V4L2_PIX_FMT_NV12T", __FUNCTION__); } + else if(m_snapshot_v4lformat == V4L2_PIX_FMT_NV21) { LOGE("%s():SnapshotFormat:V4L2_PIX_FMT_NV21", __FUNCTION__); } + else if(m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P) { LOGE("%s():SnapshotFormat:V4L2_PIX_FMT_YUV422P", __FUNCTION__); } + else if(m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV) { LOGE("%s():SnapshotFormat:V4L2_PIX_FMT_YUYV", __FUNCTION__); } + else if(m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY) { LOGE("%s():SnapshotFormat:V4L2_PIX_FMT_UYVY", __FUNCTION__); } + else if(m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) { LOGE("%s():SnapshotFormat:V4L2_PIX_FMT_RGB565", __FUNCTION__); } + else { LOGE("SnapshotFormat:UnknownFormat"); } +#endif + + return 0; +} + +int SecCamera::getSnapshotPixelFormat(void) +{ + return m_snapshot_v4lformat; +} + + +// ====================================================================== +// Settings + +int SecCamera::setCameraId(int camera_id) +{ + if( camera_id != CAMERA_ID_FRONT + && camera_id != CAMERA_ID_BACK) + { + LOGE("ERR(%s)::Invalid camera id(%d)\n", __func__, camera_id); + return -1; + } + if(m_camera_id == camera_id) + return 0; + + LOGV("%s(camera_id(%d))", __FUNCTION__, camera_id); + + switch(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; + cam_id = 1; + 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; + cam_id = 0; + break; + } + + m_camera_id = camera_id; + + resetCamera(); + + return 0; +} + +int SecCamera::getCameraId(void) +{ + return m_camera_id; +} + +// ----------------------------------- + +int SecCamera::setAutofocus(void) +{ + LOGV("%s()", __FUNCTION__); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + 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", __FUNCTION__); + return -1; + } +#else + // kcoolsw : turn on setAutofocus initially.. + if(m_autofocus != AUTO_FOCUS_ON) + { + m_autofocus = AUTO_FOCUS_ON; + } +#endif + + return 0; +} + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +int SecCamera::getAutoFocusResult(void) +{ + int af_result = 0; + af_result = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT); + return af_result; +} +int SecCamera::cancelAutofocus(void) +{ + LOGV("%s()", __FUNCTION__); + + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + 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", __FUNCTION__); + return -1; + } + + usleep(1000); + + if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_STATUS) < 0) + { + LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __FUNCTION__); + return -1; + } + return 0; +} +#endif +// ----------------------------------- + +int SecCamera::zoomIn(void) +{ + LOGV("%s()", __FUNCTION__); + return 0; +} + +int SecCamera::zoomOut(void) +{ + LOGV("%s()", __FUNCTION__); + return 0; +} + +// ----------------------------------- + +int SecCamera::SetRotate(int angle) +{ + LOGE("%s(angle(%d))", __FUNCTION__, angle); +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + 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)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } +#endif + return 0; +} + +int SecCamera::getRotate(void) +{ + LOGV("%s():angle(%d)", __FUNCTION__, m_angle); + return m_angle; +} + +void SecCamera::setFrameRate(int frame_rate) +{ +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGV("%s(FrameRate(%d))", __FUNCTION__, frame_rate); + + if(frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate ) + LOGE("ERR(%s):Invalid frame_rate(%d)", __FUNCTION__, frame_rate); + + if(m_fps != frame_rate) + { + m_fps = 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", __FUNCTION__); + } + } +#else + m_fps = frame_rate; +#endif + +} + +/* kidggang (10.7.5) - Problem - After jpegquality is capture, operation setting is normal. +void SecCamera::setJpegQuality(int quality) +{ + m_jpeg_quality = quality; +} +*/ +// ----------------------------------- + +int SecCamera::setVerticalMirror(void) +{ + LOGV("%s()", __FUNCTION__); + + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + return -1; + } + + if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_VFLIP, 0) < 0) + { + LOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __FUNCTION__); + return -1; + } + + return 0; +} + +int SecCamera::setHorizontalMirror(void) +{ + LOGV("%s()", __FUNCTION__); + + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + return -1; + } + + if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_HFLIP, 0) < 0) + { + LOGE("ERR(%s):Fail on V4L2_CID_HFLIP", __FUNCTION__); + return -1; + } + + return 0; +} + +// ----------------------------------- + +int SecCamera::setWhiteBalance(int white_balance) +{ + LOGV("%s(white_balance(%d))", __FUNCTION__, white_balance); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if(white_balance <= WHITE_BALANCE_BASE || WHITE_BALANCE_MAX <= white_balance) +#else + if(white_balance < WHITE_BALANCE_AUTO || WHITE_BALANCE_SUNNY < white_balance) +#endif + { + LOGE("ERR(%s):Invalid white_balance(%d)", __FUNCTION__, white_balance); + return -1; + } + + if(m_white_balance != white_balance) + { + m_white_balance = white_balance; +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + 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", __FUNCTION__); + return -1; + } + } +#endif + } + + return 0; +} + +int SecCamera::getWhiteBalance(void) +{ + LOGV("%s():white_balance(%d)", __FUNCTION__, m_white_balance); + return m_white_balance; +} + +// ----------------------------------- + +int SecCamera::setBrightness(int brightness) +{ + LOGV("%s(brightness(%d))", __FUNCTION__, brightness); + + if(brightness < BRIGHTNESS_MINUS_4|| BRIGHTNESS_PLUS_4< brightness ) + { + LOGE("ERR(%s):Invalid brightness(%d)", __FUNCTION__, brightness); + return -1; + } + + if(m_brightness != brightness) + { + m_brightness = brightness; +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + 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", __FUNCTION__); + return -1; + } + } +#endif + } + + return 0; +} + +int SecCamera::getBrightness(void) +{ + LOGV("%s():brightness(%d)", __FUNCTION__, m_brightness); + return m_brightness; +} + +// ----------------------------------- + +int SecCamera::setImageEffect(int image_effect) +{ + LOGV("%s(image_effect(%d))", __FUNCTION__, image_effect); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if(image_effect <= IMAGE_EFFECT_BASE || IMAGE_EFFECT_MAX <= image_effect) +#else + if(image_effect < IMAGE_EFFECT_ORIGINAL || IMAGE_EFFECT_SILHOUETTE < image_effect) +#endif + { + LOGE("ERR(%s):Invalid image_effect(%d)", __FUNCTION__, image_effect); + return -1; + } + + if(m_image_effect != image_effect) + { + m_image_effect = image_effect; +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + 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", __FUNCTION__); + return -1; + } + } +#endif + } + + return 0; +} + +int SecCamera::getImageEffect(void) +{ + LOGV("%s():image_effect(%d)", __FUNCTION__, m_image_effect); + return m_image_effect; +} + +// ====================================================================== +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +int SecCamera::setAntiBanding(int anti_banding) +{ + LOGV("%s(anti_banding(%d))", __FUNCTION__, anti_banding); + + if(anti_banding < ANTI_BANDING_AUTO|| ANTI_BANDING_OFF < anti_banding) + { + LOGE("ERR(%s):Invalid anti_banding (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +//====================================================================== +int SecCamera::setSceneMode(int scene_mode) +{ + LOGV("%s(scene_mode(%d))", __FUNCTION__, scene_mode); + + if(scene_mode <= SCENE_MODE_BASE || SCENE_MODE_MAX <= scene_mode) + { + LOGE("ERR(%s):Invalid scene_mode (%d)", __FUNCTION__, scene_mode); + return -1; + } + + if(m_scene_mode != scene_mode) + { + m_scene_mode = scene_mode; + if(m_flag_camera_start) + { + if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, m_scene_mode) < 0) + { + LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getSceneMode(void) +{ + return m_scene_mode; +} + +//====================================================================== + +int SecCamera::setFlashMode(int flash_mode) +{ + LOGV("%s(flash_mode(%d))", __FUNCTION__, flash_mode); + + if(flash_mode <= FLASH_MODE_BASE || FLASH_MODE_MAX <= flash_mode) + { + LOGE("ERR(%s):Invalid flash_mode (%d)", __FUNCTION__, flash_mode); + return -1; + } + + if(m_flash_mode != flash_mode) + { + m_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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getFlashMode(void) +{ + return m_flash_mode; +} + +//====================================================================== + +int SecCamera::setISO(int iso_value) +{ + LOGV("%s(iso_value(%d))", __FUNCTION__, iso_value); + if(iso_value <ISO_AUTO || ISO_MAX <= iso_value) + { + LOGE("ERR(%s):Invalid iso_value (%d)", __FUNCTION__, iso_value); + return -1; + } + + if(m_iso != iso_value) + { + m_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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getISO(void) +{ + return m_iso; +} + +//====================================================================== + +int SecCamera::setContrast(int contrast_value) +{ + LOGV("%s(contrast_value(%d))", __FUNCTION__, contrast_value); + + if(contrast_value <CONTRAST_MINUS_2|| CONTRAST_MAX<= contrast_value) + { + LOGE("ERR(%s):Invalid contrast_value (%d)", __FUNCTION__, contrast_value); + return -1; + } + + if(m_contrast != contrast_value) + { + m_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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getContrast(void) +{ + return m_contrast; +} + +//====================================================================== + +int SecCamera::setSaturation(int saturation_value) +{ + LOGV("%s(saturation_value(%d))", __FUNCTION__, saturation_value); + + if(saturation_value <SATURATION_MINUS_2|| SATURATION_MAX<= saturation_value) + { + LOGE("ERR(%s):Invalid saturation_value (%d)", __FUNCTION__, saturation_value); + return -1; + } + + if(m_saturation!= saturation_value) + { + m_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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getSaturation(void) +{ + return m_saturation; +} + +//====================================================================== + +int SecCamera::setSharpness(int sharpness_value) +{ + LOGV("%s(sharpness_value(%d))", __FUNCTION__, sharpness_value); + + if(sharpness_value <SHARPNESS_MINUS_2|| SHARPNESS_MAX<= sharpness_value) + { + LOGE("ERR(%s):Invalid sharpness_value (%d)", __FUNCTION__, sharpness_value); + return -1; + } + + if(m_sharpness!= sharpness_value) + { + m_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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getSharpness(void) +{ + return m_sharpness; +} + +//====================================================================== + +int SecCamera::setWDR(int wdr_value) +{ + LOGV("%s(wdr_value(%d))", __FUNCTION__, wdr_value); + + if(wdr_value<WDR_OFF || WDR_MAX<= wdr_value) + { + LOGE("ERR(%s):Invalid wdr_value (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getWDR(void) +{ + return m_wdr; +} + +//====================================================================== + +int SecCamera::setAntiShake(int anti_shake) +{ + LOGV("%s(anti_shake(%d))", __FUNCTION__, anti_shake); + + if(anti_shake<ANTI_SHAKE_OFF || ANTI_SHAKE_MAX<= anti_shake) + { + LOGE("ERR(%s):Invalid anti_shake (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getAntiShake(void) +{ + return m_anti_shake; +} + +//====================================================================== + + +int SecCamera::setMetering(int metering_value) +{ + LOGV("%s(metering (%d))", __FUNCTION__, metering_value); + + if(metering_value <= METERING_BASE || METERING_MAX <= metering_value) + { + LOGE("ERR(%s):Invalid metering_value (%d)", __FUNCTION__, metering_value); + return -1; + } + + if(m_metering != metering_value) + { + m_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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getMetering(void) +{ + return m_metering; +} + +//====================================================================== + +int SecCamera::setJpegQuality(int jpeg_quality) +{ + LOGV("%s(jpeg_quality (%d))", __FUNCTION__, jpeg_quality); + + if(jpeg_quality < JPEG_QUALITY_ECONOMY|| JPEG_QUALITY_MAX<= jpeg_quality) + { + LOGE("ERR(%s):Invalid jpeg_quality (%d)", __FUNCTION__, jpeg_quality); + return -1; + } + + if(m_jpeg_quality != jpeg_quality) + { + m_jpeg_quality = jpeg_quality; + 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", __FUNCTION__); + return -1; + } + } + + return 0; +} + +int SecCamera::getJpegQuality(void) +{ + return m_jpeg_quality; +} + +//====================================================================== + +int SecCamera::setZoom(int zoom_level) +{ + LOGV("%s(zoom_level (%d))", __FUNCTION__, zoom_level); + + if(zoom_level < ZOOM_LEVEL_0|| ZOOM_LEVEL_MAX<= zoom_level) + { + LOGE("ERR(%s):Invalid zoom_level (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getZoom(void) +{ + return m_zoom_level; +} + +//====================================================================== + +int SecCamera::setObjectTracking(int object_tracking) +{ + LOGV("%s(object_tracking (%d))", __FUNCTION__, object_tracking); + + if(object_tracking < OBJECT_TRACKING_OFF|| OBJECT_TRACKING_MAX<= object_tracking) + { + LOGE("ERR(%s):Invalid object_tracking (%d)", __FUNCTION__, 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))", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + + return 0; +} + +int SecCamera::setTouchAFStartStop(int start_stop) +{ + LOGV("%s(touch_af_start_stop (%d))", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + + return 0; +} + +//====================================================================== + +int SecCamera::setSmartAuto(int smart_auto) +{ + LOGV("%s(smart_auto (%d))", __FUNCTION__, smart_auto); + + if(smart_auto < SMART_AUTO_OFF|| SMART_AUTO_MAX <= smart_auto) + { + LOGE("ERR(%s):Invalid smart_auto (%d)", __FUNCTION__, 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", __FUNCTION__); + 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)", __FUNCTION__, autoscene_status); + return -1; + } + } + //LOGV("%s() autoscene_status (%d)", __FUNCTION__, autoscene_status); + return autoscene_status; +} +//====================================================================== + +int SecCamera::setBeautyShot(int beauty_shot) +{ + LOGV("%s(beauty_shot (%d))", __FUNCTION__, beauty_shot); + + if(beauty_shot < BEAUTY_SHOT_OFF|| BEAUTY_SHOT_MAX <= beauty_shot) + { + LOGE("ERR(%s):Invalid beauty_shot (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + + setFaceDetect(FACE_DETECT_BEAUTY_ON); + } + } + + return 0; +} + +int SecCamera::getBeautyShot(void) +{ + return m_beauty_shot; +} + +//====================================================================== + +int SecCamera::setVintageMode(int vintage_mode) +{ + LOGV("%s(vintage_mode(%d))", __FUNCTION__, vintage_mode); + + if(vintage_mode <= VINTAGE_MODE_BASE || VINTAGE_MODE_MAX <= vintage_mode) + { + LOGE("ERR(%s):Invalid vintage_mode (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + + return 0; +} + +int SecCamera::getVintageMode(void) +{ + return m_vintage_mode; +} + +//====================================================================== + +int SecCamera::setFocusMode(int focus_mode) +{ + LOGV("%s(focus_mode(%d))", __FUNCTION__, focus_mode); + + if(FOCUS_MODE_MAX <= focus_mode) + { + LOGE("ERR(%s):Invalid focus_mode (%d)", __FUNCTION__, focus_mode); + return -1; + } + + if(m_focus_mode != focus_mode) + { + m_focus_mode = focus_mode; + + if (m_focus_mode != FOCUS_MODE_FACEDETECT) + { + m_face_detect = FACE_DETECT_OFF; + if(m_flag_camera_start) + { +// setFaceDetect(m_face_detect); + + 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", __FUNCTION__); + return -1; + } + } + } + else + { + m_face_detect = FACE_DETECT_NORMAL_ON; + if(m_flag_camera_start) + { + 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_MODE", __FUNCTION__); + return -1; + } + +// setFaceDetect(m_face_detect); + } + } + } + + return 0; +} + +int SecCamera::getFocusMode(void) +{ + return m_focus_mode; +} + +//====================================================================== + + int SecCamera::setFaceDetect(int face_detect) + { + LOGV("%s(face_detect(%d))", __FUNCTION__, face_detect); + +// if(m_face_detect != face_detect) + { + m_face_detect = face_detect; + if(m_flag_camera_start) + { + if(m_face_detect != FACE_DETECT_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", __FUNCTION__); + 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", __FUNCTION__); + 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))", __FUNCTION__, 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))", __FUNCTION__, m_gps_latitude); + return 0; + } + int SecCamera::setGPSLongitude(const char * gps_longitude) + { + double conveted_longitude = 0; + LOGV("%s(gps_longitude(%s))", __FUNCTION__, 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))", __FUNCTION__, m_gps_longitude); + return 0; + } + int SecCamera::setGPSAltitude(const char * gps_altitude) + { + double conveted_altitude = 0; + LOGV("%s(gps_altitude(%s))", __FUNCTION__, 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))", __FUNCTION__, m_gps_altitude); + return 0; + } + int SecCamera::setGPSTimeStamp(const char * gps_timestamp) + { + LOGV("%s(gps_timestamp(%s))", __FUNCTION__, gps_timestamp); + if(gps_timestamp == NULL) + m_gps_timestamp = 0; + else + m_gps_timestamp = atol(gps_timestamp); + + LOGV("%s(m_gps_timestamp(%ld))", __FUNCTION__, m_gps_timestamp); + return 0; + } + + //====================================================================== + int SecCamera::setAEAWBLockUnlock(int ae_lockunlock, int awb_lockunlock) + { + LOGV("%s(ae_lockunlock(%d) , (awb_lockunlock(%d))", __FUNCTION__, ae_lockunlock, awb_lockunlock); + int ae_awb_status = 1; +#if 0 + if(ae_lockunlock == 0 && awb_lockunlock ==0) + ae_awb_status = AE_UNLOCK_AWB_UNLOCK; + else if (ae_lockunlock == 1 && awb_lockunlock ==0) + ae_awb_status = AE_LOCK_AWB_UNLOCK; + else if (ae_lockunlock == 1 && awb_lockunlock ==0) + ae_awb_status = AE_UNLOCK_AWB_LOCK; + else + ae_awb_status = AE_LOCK_AWB_LOCK; +#endif + if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, ae_awb_status) < 0) + { + LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_AE_AWB_LOCKUNLOCK", __FUNCTION__); + return -1; + } + + return 0; + } + + int SecCamera::setFaceDetectLockUnlock(int facedetect_lockunlock) + { + LOGV("%s(facedetect_lockunlock(%d))", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + + return 0; + } + + int SecCamera::setObjectPosition(int x, int y) + { + LOGV("%s(setObjectPosition(x=%d, y=%d))", __FUNCTION__, 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", __FUNCTION__); + 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", __FUNCTION__); + return -1; + } + + return 0; + } + + //====================================================================== + + int SecCamera::setGamma(int gamma) + { + LOGV("%s(gamma(%d))", __FUNCTION__, gamma); + + if(gamma<GAMMA_OFF|| GAMMA_MAX<= gamma) + { + LOGE("ERR(%s):Invalid gamma (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + + return 0; + } + + //====================================================================== + + int SecCamera::setSlowAE(int slow_ae) + { + LOGV("%s(slow_ae(%d))", __FUNCTION__, slow_ae); + + if(slow_ae<GAMMA_OFF|| GAMMA_MAX<= slow_ae) + { + LOGE("ERR(%s):Invalid slow_ae (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + + return 0; + } + + //====================================================================== + + int SecCamera::setRecordingSize(int width, int height) + { + LOGE("%s(width(%d), height(%d))", __FUNCTION__, width, height); + + m_recording_width = width; + m_recording_height = height; + + return 0; + } + + //====================================================================== + +int SecCamera::setExifOrientationInfo(int orientationInfo) +{ + LOGV("%s(orientationInfo(%d))", __FUNCTION__, orientationInfo); + + if(orientationInfo < 0) + { + LOGE("ERR(%s):Invalid orientationInfo (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + + return 0; +} + +/*Video call*/ +int SecCamera::setVTmode(int vtmode) +{ + LOGV("%s(vtmode (%d))", __FUNCTION__, vtmode); + + if(vtmode < VT_MODE_OFF || VT_MODE_MAX <= vtmode) + { + LOGE("ERR(%s):Invalid vtmode (%d)", __FUNCTION__, 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))", __FUNCTION__, sensor_mode); + + if(sensor_mode < SENSOR_MODE_CAMERA || SENSOR_MODE_MOVIE < sensor_mode) + { + LOGE("ERR(%s):Invalid sensor mode (%d)", __FUNCTION__, 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))", __FUNCTION__, shot_mode); + if(shot_mode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shot_mode) + { + LOGE("ERR(%s):Invalid shot_mode (%d)", __FUNCTION__, 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))", __FUNCTION__, blur_level); + + if(blur_level < BLUR_LEVEL_0|| BLUR_LEVEL_MAX <= blur_level) + { + LOGE("ERR(%s):Invalid level (%d)", __FUNCTION__, 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", __FUNCTION__); + return -1; + } + } + } + return 0; +} + +int SecCamera::getBlur(void) +{ + return m_blur_level; +} + + +int SecCamera::setDataLineCheck(int chk_dataline) +{ + LOGV("%s(chk_dataline (%d))", __FUNCTION__, chk_dataline); + + if(chk_dataline < CHK_DATALINE_OFF || CHK_DATALINE_MAX<= chk_dataline) + { + LOGE("ERR(%s):Invalid chk_dataline (%d)", __FUNCTION__, 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", __FUNCTION__); + + 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", __FUNCTION__); + return -1; + } + } + return 0; +} + +#endif + +// ====================================================================== +// Jpeg + +#ifndef JPEG_FROM_SENSOR +unsigned char * SecCamera::getJpeg(unsigned char *snapshot_data, int snapshot_size, int * size) +{ + LOGV("%s()", __FUNCTION__); + + if(m_cam_fd <= 0) + { + LOGE("ERR(%s):Camera was closed\n", __FUNCTION__); + return NULL; + } + + unsigned char * jpeg_data = NULL; + int jpeg_size = 0; + + jpeg_data = yuv2Jpeg(snapshot_data, snapshot_size, &jpeg_size, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat); + + *size = jpeg_size; + return jpeg_data; +} +#endif + +#ifndef JPEG_FROM_SENSOR +unsigned char * SecCamera::yuv2Jpeg(unsigned char * raw_data, int raw_size,int * jpeg_size,int width, int height, int pixel_format) +{ + LOGV("%s:raw_data(%p), raw_size(%d), jpeg_size(%d), width(%d), height(%d), format(%d)", + __FUNCTION__, raw_data, raw_size, *jpeg_size, width, height, pixel_format); + + if(m_jpeg_fd <= 0) + { + LOGE("ERR(%s):JPEG device was closed\n", __FUNCTION__); + return NULL; + } + if(pixel_format == V4L2_PIX_FMT_RGB565) + { + LOGE("ERR(%s):It doesn't support V4L2_PIX_FMT_RGB565\n", __FUNCTION__); + return NULL; + } + + unsigned char * InBuf = NULL; + unsigned char * OutBuf = NULL; + unsigned char * jpeg_data = NULL; + long frameSize; + exif_file_info_t ExifInfo; + + int input_file_format = JPG_MODESEL_YCBCR; + + int out_file_format = JPG_422; + switch(pixel_format) + { + case V4L2_PIX_FMT_NV12: + case V4L2_PIX_FMT_NV21: + case V4L2_PIX_FMT_NV12T: + case V4L2_PIX_FMT_YUV420: + out_file_format = JPG_420; + break; + case V4L2_PIX_FMT_YUYV: + case V4L2_PIX_FMT_UYVY: + case V4L2_PIX_FMT_YUV422P: + out_file_format = JPG_422; + break; + } + + ////////////////////////////////////////////////////////////// + // 2. set encode config. // + ////////////////////////////////////////////////////////////// + LOGV("Step 1 : JPEG_SET_ENCODE_IN_FORMAT(JPG_MODESEL_YCBCR)"); + if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_IN_FORMAT, input_file_format) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_IN_FORMAT\n", __FUNCTION__); + goto YUV2JPEG_END; + } + + LOGV("Step 2 : JPEG_SET_SAMPING_MODE(JPG_422)"); + if (SsbSipJPEGSetEncConfig(JPEG_SET_SAMPING_MODE, out_file_format) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_SAMPING_MODE\n", __FUNCTION__); + goto YUV2JPEG_END; + } + + LOGV("Step 3 : JPEG_SET_ENCODE_WIDTH(%d)", width); + if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_WIDTH, width) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_WIDTH \n", __FUNCTION__); + goto YUV2JPEG_END; + } + + LOGV("Step 4 : JPEG_SET_ENCODE_HEIGHT(%d)", height); + if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_HEIGHT, height) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_HEIGHT \n", __FUNCTION__); + goto YUV2JPEG_END; + } + + LOGV("Step 5 : JPEG_SET_ENCODE_QUALITY(JPG_QUALITY_LEVEL_2)"); + if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_QUALITY \n", __FUNCTION__); + goto YUV2JPEG_END; + } + +#if (INCLUDE_JPEG_THUMBNAIL == 1) + + LOGV("Step 6a : JPEG_SET_ENCODE_THUMBNAIL(TRUE)"); + if (SsbSipJPEGSetEncConfig(JPEG_SET_ENCODE_THUMBNAIL, TRUE) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_ENCODE_THUMBNAIL \n", __FUNCTION__); + goto YUV2JPEG_END; + } + + LOGV("Step 6b : JPEG_SET_THUMBNAIL_WIDTH(%d)", m_jpeg_thumbnail_width); + if (SsbSipJPEGSetEncConfig(JPEG_SET_THUMBNAIL_WIDTH, m_jpeg_thumbnail_width) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_THUMBNAIL_WIDTH(%d) \n", __FUNCTION__, m_jpeg_thumbnail_height); + goto YUV2JPEG_END; + } + + LOGV("Step 6c : JPEG_SET_THUMBNAIL_HEIGHT(%d)", m_jpeg_thumbnail_height); + if (SsbSipJPEGSetEncConfig(JPEG_SET_THUMBNAIL_HEIGHT, m_jpeg_thumbnail_height) != JPEG_OK) { + LOGE("ERR(%s):Fail on JPEG_SET_THUMBNAIL_HEIGHT(%d) \n", __FUNCTION__, m_jpeg_thumbnail_height); + goto YUV2JPEG_END; + } + +#endif + + if(raw_size == 0) //Kamat: This is our code path + { + unsigned int addr_y; + int width, height,frame_size; + getSnapshotSize(&width, &height, &frame_size); + if(raw_data == NULL) + { + LOGE("%s %d] Raw data is NULL \n",__func__,__LINE__); + goto YUV2JPEG_END; + } + else //Kamat: our path + { + addr_y = (unsigned int)raw_data; + } + + SsbSipJPEGSetEncodeInBuf(m_jpeg_fd, addr_y, frame_size); + } + else + { + ////////////////////////////////////////////////////////////// + // 4. get Input buffer address // + ////////////////////////////////////////////////////////////// + LOGV("Step 7 : Input buffer size(0x%X", raw_size); + InBuf = (unsigned char *)SsbSipJPEGGetEncodeInBuf(m_jpeg_fd, raw_size); + if(InBuf == NULL) + { + LOGE("ERR(%s):Fail on SsbSipJPEGGetEncodeInBuf \n", __FUNCTION__); + goto YUV2JPEG_END; + } + ////////////////////////////////////////////////////////////// + // 5. put YUV stream to Input buffer + ////////////////////////////////////////////////////////////// + LOGV("Step 8: memcpy(InBuf(%p), raw_data(%p), raw_size(%d)", InBuf, raw_data, raw_size); + memcpy(InBuf, raw_data, raw_size); + } + + ////////////////////////////////////////////////////////////// + // 6. Make Exif info parameters + ////////////////////////////////////////////////////////////// + LOGV("Step 9: m_makeExifParam()"); + memset(&ExifInfo, 0x00, sizeof(exif_file_info_t)); + m_makeExifParam(&ExifInfo); + + ////////////////////////////////////////////////////////////// + // 7. Encode YUV stream + ////////////////////////////////////////////////////////////// + LOGV("Step a: SsbSipJPEGEncodeExe()"); + if(SsbSipJPEGEncodeExe(m_jpeg_fd, &ExifInfo, JPEG_USE_SW_SCALER) != JPEG_OK) //with Exif + { + LOGE("ERR(%s):Fail on SsbSipJPEGEncodeExe \n", __FUNCTION__); + goto YUV2JPEG_END; + } + ////////////////////////////////////////////////////////////// + // 8. get output buffer address + ////////////////////////////////////////////////////////////// + LOGV("Step b: SsbSipJPEGGetEncodeOutBuf()"); + OutBuf = (unsigned char *)SsbSipJPEGGetEncodeOutBuf(m_jpeg_fd, &frameSize); + if(OutBuf == NULL) + { + LOGE("ERR(%s):Fail on SsbSipJPEGGetEncodeOutBuf \n", __FUNCTION__); + goto YUV2JPEG_END; + } + ////////////////////////////////////////////////////////////// + // 9. write JPEG result file + ////////////////////////////////////////////////////////////// + LOGV("Done"); + jpeg_data = OutBuf; + *jpeg_size = (int)frameSize; + +YUV2JPEG_END : + + return jpeg_data; +} +#endif + +int SecCamera::setJpegThumbnailSize(int width, int height) +{ + LOGV("%s(width(%d), height(%d))", __FUNCTION__, 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() +{ + //2 0th IFD TIFF Tags + //3 Maker + strcpy((char *)mExifInfo.maker, EXIF_DEF_MAKER); + //3 Model + strcpy((char *)mExifInfo.model, EXIF_DEF_MODEL); + //3 Software + property_get("ro.build.PDA", (char *)mExifInfo.software, EXIF_DEF_SOFTWARE); + //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 Flash + mExifInfo.flash = EXIF_DEF_FLASH; + //3 Lens Focal Length + mExifInfo.focal_length.num = EXIF_DEF_FOCAL_LEN_NUM; + 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_s_ctrl(m_cam_fd, + V4L2_CID_CAMERA_GET_SHT_TIME, + 0); + mExifInfo.exposure_time.num = 1; + mExifInfo.exposure_time.den = 1000000.0/shutterSpeed; /* us -> sec */ + + //3 ISO Speed Rating + int iso = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_ISO, 0); + if (m_iso == ISO_AUTO) { + mExifInfo.iso_speed_rating = iso; + } + else { + switch(m_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 = iso; + 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(iso); + bv = av + tv - sv; + ev = av + tv; + LOGD("Shutter speed=%d us, iso=%d\n", shutterSpeed, iso); + 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_scene_mode == SCENE_MODE_BEACH_SNOW) { + mExifInfo.exposure_bias.num = 1*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_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 White Balance + if(m_white_balance == WHITE_BALANCE_AUTO) + mExifInfo.white_balance = EXIF_WB_AUTO; + else + mExifInfo.white_balance = EXIF_WB_MANUAL; + //3 Scene Capture Type + switch(m_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; + + mExifInfo.enableGps = true; + } + else { + mExifInfo.enableGps = false; + } + + //2 1th IFD TIFF Tags + int thumbWidth, thumbHeight, thumbSrcSize; + getPostViewConfig(&thumbWidth, &thumbHeight, &thumbSrcSize); + mExifInfo.widthThumb = thumbWidth; + mExifInfo.heightThumb = thumbHeight; +} + +// ====================================================================== +// 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", __FUNCTION__, format); + case V4L2_PIX_FMT_RGB565 : + size = (width * height * BPP); + break; + } + + return size; +} + +status_t SecCamera::dump(int fd, const Vector<String16>& 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; +} + +}; // namespace android diff --git a/libcamera/SecCamera.h b/libcamera/SecCamera.h new file mode 100644 index 0000000..e504ca6 --- /dev/null +++ b/libcamera/SecCamera.h @@ -0,0 +1,886 @@ +/* +** +** Copyright 2008, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#ifndef ANDROID_HARDWARE_CAMERA_SEC_H +#define ANDROID_HARDWARE_CAMERA_SEC_H + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> + +#include <fcntl.h> +#include <unistd.h> +#include <errno.h> +#include <signal.h> +#include <sys/mman.h> +#include <sys/time.h> +#include <sys/ioctl.h> +#include <sys/poll.h> +#include <sys/stat.h> + +#include <linux/videodev2.h> +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +#include <videodev2_samsung.h> +#endif + +#include "JpegEncoder.h" + +#ifdef ENABLE_HDMI_DISPLAY +#include "hdmi_lib.h" +#endif + +#include <camera/CameraHardwareInterface.h> + +namespace android { + +#define PREVIEW_USING_MMAP //Define this if the preview data is to be shared using memory mapped technique instead of passing physical address. + +#define JPEG_FROM_SENSOR //Define this if the JPEG images are obtained directly from camera sensor. Else on chip JPEG encoder will be used. + +//#define DUAL_PORT_RECORDING //Define this if 2 fimc ports are needed for recording. + +//#define SEND_YUV_RECORD_DATA //Define this to copy YUV data to encoder instead of sharing the physical address. + +#define INCLUDE_JPEG_THUMBNAIL 1 //Valid only for on chip JPEG encoder + +#if defined PREVIEW_USING_MMAP +#define DUAL_PORT_RECORDING +#endif + +#if defined JPEG_FROM_SENSOR +#define DIRECT_DELIVERY_OF_POSTVIEW_DATA //Define this if postview data is needed in buffer instead of zero copy. +#endif + +#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 LCD_WIDTH 480 +#define LCD_HEIGHT 800 + +#define JOIN(x, y) JOIN_AGAIN(x, y) +#define JOIN_AGAIN(x, y) x ## y + +#define FRONT_CAM VGA +#define BACK_CAM CE147 + +#if !defined (FRONT_CAM) || !defined(BACK_CAM) +#error "Please define the Camera module" +#endif + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +#define CE147_PREVIEW_WIDTH 640 +#define CE147_PREVIEW_HEIGHT 480 +#define CE147_SNAPSHOT_WIDTH 2560 +#define CE147_SNAPSHOT_HEIGHT 1920 +#else +#define CE147_PREVIEW_WIDTH 1280 +#define CE147_PREVIEW_HEIGHT 720 +#define CE147_SNAPSHOT_WIDTH 2592 +#define CE147_SNAPSHOT_HEIGHT 1936 +#endif + +#define CE147_POSTVIEW_WIDTH 640 +#define CE147_POSTVIEW_WIDE_WIDTH 800 +#define CE147_POSTVIEW_HEIGHT 480 +#define CE147_POSTVIEW_BPP 16 + +#define VGA_PREVIEW_WIDTH 640 +#define VGA_PREVIEW_HEIGHT 480 +#define VGA_SNAPSHOT_WIDTH 640 +#define VGA_SNAPSHOT_HEIGHT 480 + +#define MAX_BACK_CAMERA_PREVIEW_WIDTH JOIN(BACK_CAM,_PREVIEW_WIDTH) +#define MAX_BACK_CAMERA_PREVIEW_HEIGHT JOIN(BACK_CAM,_PREVIEW_HEIGHT) +#define MAX_BACK_CAMERA_SNAPSHOT_WIDTH JOIN(BACK_CAM,_SNAPSHOT_WIDTH) +#define MAX_BACK_CAMERA_SNAPSHOT_HEIGHT JOIN(BACK_CAM,_SNAPSHOT_HEIGHT) +#define BACK_CAMERA_POSTVIEW_WIDTH JOIN(BACK_CAM,_POSTVIEW_WIDTH) +#define BACK_CAMERA_POSTVIEW_WIDE_WIDTH JOIN(BACK_CAM,_POSTVIEW_WIDE_WIDTH) +#define BACK_CAMERA_POSTVIEW_HEIGHT JOIN(BACK_CAM,_POSTVIEW_HEIGHT) +#define BACK_CAMERA_POSTVIEW_BPP JOIN(BACK_CAM,_POSTVIEW_BPP) + +#define MAX_FRONT_CAMERA_PREVIEW_WIDTH JOIN(FRONT_CAM,_PREVIEW_WIDTH) +#define MAX_FRONT_CAMERA_PREVIEW_HEIGHT JOIN(FRONT_CAM,_PREVIEW_HEIGHT) +#define MAX_FRONT_CAMERA_SNAPSHOT_WIDTH JOIN(FRONT_CAM,_SNAPSHOT_WIDTH) +#define MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT JOIN(FRONT_CAM,_SNAPSHOT_HEIGHT) + +#define DEFAULT_JPEG_THUMBNAIL_WIDTH 256 +#define DEFAULT_JPEG_THUMBNAIL_HEIGHT 192 + +#define CAMERA_DEV_NAME "/dev/video0" + +#ifdef DUAL_PORT_RECORDING +#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 8 + +/* + * 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 = 1, + CAMERA_ID_FRONT = 2, + }; + + enum AUTO_FOCUS + { + AUTO_FOCUS_OFF, + AUTO_FOCUS_ON, + AUTO_FOCUS_STATUS, + }; + + enum WHILTE_BALANCE + { + #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + WHITE_BALANCE_BASE, + WHITE_BALANCE_AUTO, + WHITE_BALANCE_DAYLIGHT, + WHITE_BALANCE_CLOUDY, + WHITE_BALANCE_INCANDESCENT, + WHITE_BALANCE_FLUORESCENT, + WHITE_BALANCE_MAX, + #else + WHITE_BALANCE_AUTO, + WHITE_BALANCE_INDOOR3100, + WHITE_BALANCE_OUTDOOR5100, + WHITE_BALANCE_INDOOR2000, + WHITE_BALANCE_HALT, + WHITE_BALANCE_CLOUDY, + WHITE_BALANCE_SUNNY, + #endif + }; + + enum BRIGHTNESS + { + BRIGHTNESS_MINUS_4= 0, + BRIGHTNESS_MINUS_3, + BRIGHTNESS_MINUS_2, + BRIGHTNESS_MINUS_1, + BRIGHTNESS_NORMAL, + BRIGHTNESS_PLUS_1, + BRIGHTNESS_PLUS_2, + BRIGHTNESS_PLUS_3, + BRIGHTNESS_PLUS_4, + }; + + enum IMAGE_EFFECT + { + #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + IMAGE_EFFECT_BASE, + IMAGE_EFFECT_NONE, + IMAGE_EFFECT_BNW, + IMAGE_EFFECT_SEPIA, + IMAGE_EFFECT_AQUA, + IMAGE_EFFECT_ANTIQUE, + IMAGE_EFFECT_NEGATIVE, + IMAGE_EFFECT_SHARPEN, + IMAGE_EFFECT_MAX, + #else + IMAGE_EFFECT_ORIGINAL, + IMAGE_EFFECT_ARBITRARY, + IMAGE_EFFECT_NEGATIVE, + IMAGE_EFFECT_FREEZE, + IMAGE_EFFECT_EMBOSSING, + IMAGE_EFFECT_SILHOUETTE, + #endif + }; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + enum SCENE_MODE + { + SCENE_MODE_BASE, + SCENE_MODE_NONE, + SCENE_MODE_PORTRAIT, + SCENE_MODE_NIGHTSHOT, + SCENE_MODE_BACK_LIGHT, + SCENE_MODE_LANDSCAPE, + SCENE_MODE_SPORTS, + SCENE_MODE_PARTY_INDOOR, + SCENE_MODE_BEACH_SNOW, + SCENE_MODE_SUNSET, + SCENE_MODE_DUSK_DAWN, + SCENE_MODE_FALL_COLOR, + SCENE_MODE_FIREWORKS, + SCENE_MODE_TEXT, + SCENE_MODE_CANDLE_LIGHT, + SCENE_MODE_MAX, + }; + + enum FLASH_MODE + { + FLASH_MODE_BASE, + FLASH_MODE_OFF, + FLASH_MODE_AUTO, + FLASH_MODE_ON, + FLASH_MODE_TORCH, + FLASH_MODE_MAX, + }; + + enum ISO + { + ISO_AUTO, + ISO_50, + ISO_100, + ISO_200, + ISO_400, + ISO_800, + ISO_1600, + ISO_SPORTS, + ISO_NIGHT, + ISO_MOVIE, + ISO_MAX, + }; + + enum METERING + { + METERING_BASE = 0, + METERING_MATRIX, + METERING_CENTER, + METERING_SPOT, + METERING_MAX, + }; + + enum CONTRAST + { + CONTRAST_MINUS_2 = 0, + CONTRAST_MINUS_1, + CONTRAST_NORMAL, + CONTRAST_PLUS_1, + CONTRAST_PLUS_2, + CONTRAST_MAX, + }; + + enum SATURATION + { + SATURATION_MINUS_2= 0, + SATURATION_MINUS_1, + SATURATION_NORMAL, + SATURATION_PLUS_1, + SATURATION_PLUS_2, + SATURATION_MAX, + }; + + enum SHARPNESS + { + SHARPNESS_MINUS_2 = 0, + SHARPNESS_MINUS_1, + SHARPNESS_NORMAL, + SHARPNESS_PLUS_1, + SHARPNESS_PLUS_2, + SHARPNESS_MAX, + }; + + enum WDR + { + WDR_OFF, + WDR_ON, + WDR_MAX, + }; + + enum ANTI_SHAKE + { + ANTI_SHAKE_OFF, + ANTI_SHAKE_ON, + ANTI_SHAKE_MAX, + }; + + enum JPEG_QUALITY + { + JPEG_QUALITY_ECONOMY = 0, + JPEG_QUALITY_NORMAL = 50, + JPEG_QUALITY_SUPERFINE = 100, + JPEG_QUALITY_MAX, + }; + + enum ZOOM_LEVEL + { + ZOOM_LEVEL_0 = 0, + ZOOM_LEVEL_1, + ZOOM_LEVEL_2, + ZOOM_LEVEL_3, + ZOOM_LEVEL_4, + ZOOM_LEVEL_5, + ZOOM_LEVEL_6, + ZOOM_LEVEL_7, + ZOOM_LEVEL_8, + ZOOM_LEVEL_9, + ZOOM_LEVEL_10, + ZOOM_LEVEL_11, + ZOOM_LEVEL_12, + ZOOM_LEVEL_MAX, + }; + + enum OBJECT_TRACKING + { + OBJECT_TRACKING_OFF, + OBJECT_TRACKING_ON, + OBJECT_TRACKING_MAX, + }; + + enum OBJECT_TRACKING_STAUS + { + OBJECT_TRACKING_STATUS_BASE, + OBJECT_TRACKING_STATUS_PROGRESSING, + OBJECT_TRACKING_STATUS_SUCCESS, + OBJECT_TRACKING_STATUS_FAIL, + OBJECT_TRACKING_STATUS_MISSING, + OBJECT_TRACKING_STATUS_MAX, + }; + + enum SMART_AUTO + { + SMART_AUTO_OFF, + SMART_AUTO_ON, + SMART_AUTO_MAX, + }; + + enum BEAUTY_SHOT + { + BEAUTY_SHOT_OFF, + BEAUTY_SHOT_ON, + BEAUTY_SHOT_MAX, + }; + + enum VINTAGE_MODE + { + VINTAGE_MODE_BASE, + VINTAGE_MODE_OFF, + VINTAGE_MODE_NORMAL, + VINTAGE_MODE_WARM, + VINTAGE_MODE_COOL, + VINTAGE_MODE_BNW, + VINTAGE_MODE_MAX, + }; + + enum FOCUS_MODE + { + FOCUS_MODE_AUTO, + FOCUS_MODE_MACRO, + FOCUS_MODE_FACEDETECT, + FOCUS_MODE_AUTO_DEFAULT, + FOCUS_MODE_MACRO_DEFAULT, + FOCUS_MODE_FACEDETECT_DEFAULT, + FOCUS_MODE_MAX, + }; + + enum FACE_DETECT + { + FACE_DETECT_OFF, + FACE_DETECT_NORMAL_ON, + FACE_DETECT_BEAUTY_ON, + FACE_DETECT_NO_LINE, + FACE_DETECT_MAX, + }; + + enum AE_AWB_LOCK_UNLOCK + { + AE_UNLOCK_AWB_UNLOCK = 0, + AE_LOCK_AWB_UNLOCK, + AE_UNLOCK_AWB_LOCK, + AE_LOCK_AWB_LOCK, + AE_AWB_MAX + }; + + enum FRAME_RATE + { + FRAME_RATE_AUTO = 0, + FRAME_RATE_15 = 15, + FRAME_RATE_30 = 30, + FRAME_RATE_60 = 60, + FRAME_RATE_120 = 120, + FRAME_RATE_MAX + }; + enum ANTI_BANDING + { + ANTI_BANDING_AUTO = 0, + ANTI_BANDING_50HZ = 1, + ANTI_BANDING_60HZ = 2, + ANTI_BANDING_OFF = 3, + }; + + enum SMART_AUTO_SCENE + { + SMART_AUTO_STATUS_AUTO = 0, + SMART_AUTO_STATUS_LANDSCAPE, + SMART_AUTO_STATUS_PORTRAIT, + SMART_AUTO_STATUS_MACRO, + SMART_AUTO_STATUS_NIGHT, + SMART_AUTO_STATUS_PORTRAIT_NIGHT, + SMART_AUTO_STATUS_BACKLIT, + SMART_AUTO_STATUS_PORTRAIT_BACKLIT, + SMART_AUTO_STATUS_ANTISHAKE, + SMART_AUTO_STATUS_PORTRAIT_ANTISHAKE, + SMART_AUTO_STATUS_MAX, + }; + + enum GAMMA + { + GAMMA_OFF, + GAMMA_ON, + GAMMA_MAX, + }; + + enum SLOW_AE + { + SLOW_AE_OFF, + SLOW_AE_ON, + SLOW_AE_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 BLUR_LEVEL + { + BLUR_LEVEL_0 = 0, + BLUR_LEVEL_1, + BLUR_LEVEL_2, + BLUR_LEVEL_3, + BLUR_LEVEL_MAX, + }; + + enum CHK_DATALINE + { + CHK_DATALINE_OFF, + CHK_DATALINE_ON, + CHK_DATALINE_MAX, + }; + + enum FACE_LOCK + { + FACE_LOCK_OFF, + FACE_LOCK_ON, + FIRST_FACE_TRACKING, + FACE_LOCK_MAX + }; + + int m_touch_af_start_stop; + int m_focus_mode; + int m_iso; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + 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; +#endif + + +#endif + + SecCamera(); + ~SecCamera(); + + static SecCamera * createInstance(void) + { + static SecCamera singleton; + return &singleton; + } + status_t dump(int fd, const Vector<String16>& args); + + int flagCreate(void) const; + + + int setCameraId(int camera_id); + int getCameraId(void); + + int startPreview(void); + int stopPreview (void); +#ifdef DUAL_PORT_RECORDING + int startRecord(void); + int stopRecord (void); + int getRecord(void); + unsigned int getRecPhyAddrY(int); + unsigned int getRecPhyAddrC(int); +#endif + int flagPreviewStart(void); + // int getPreview (unsigned char * buffer, unsigned int buffer_size); + int getPreview(void); + //int getPreview(int *offset, int *size, unsigned char * buffer, unsigned int buffer_size); + 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 getSnapshot(unsigned char * buffer, unsigned int buffer_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); +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + 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 cancelAutofocus(void); + int setAEAWBLockUnlock(int ae_lockunlock, int awb_lockunlock); + 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 setCameraSensorReset(void); //s1_camera [ Defense process by ESD input ] + 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); +#endif + + void setFrameRate(int frame_rate); +// void setJpegQuality(int quality); + unsigned char* getJpeg(int*, unsigned int*); + unsigned char* getSnapshotAndJpeg(void); + //[zzangdol] add function + int getExif(unsigned char *pExifDst, unsigned char *pThumbSrc); + +#ifdef JPEG_FROM_SENSOR + void getPostViewConfig(int*, int*, int*); +#endif + +#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA + int getPostViewOffset(void); +#endif + int getCameraFd(void); + int getJpegFd(void); + void SetJpgAddr(unsigned char *addr); + unsigned int getPhyAddrY(int); + unsigned int getPhyAddrC(int); +#ifdef SEND_YUV_RECORD_DATA + void getYUVBuffers(unsigned char** virYAddr, unsigned char** virCaddr, int index); +#endif + void pausePreview(); + int initCamera(); + void DeinitCamera(); + +private: + int m_flag_init; + + int m_camera_id; + + int m_cam_fd; + + int m_cam_fd_temp; + int m_cam_fd2_temp; +#ifdef DUAL_PORT_RECORDING + int m_cam_fd2; + struct pollfd m_events_c2; + int m_flag_record_start; + struct fimc_buffer m_buffers_c2[MAX_BUFFERS]; +#endif + + 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_fps; + int m_autofocus; + int m_white_balance; + int m_brightness; + int m_image_effect; +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + int m_anti_banding; + int m_scene_mode; + int m_flash_mode; +// int m_iso; + int m_metering; + int m_contrast; + int m_saturation; + int m_sharpness; + int m_wdr; + int m_anti_shake; +// int m_jpeg_quality; + int m_zoom_level; + int m_object_tracking; + int m_smart_auto; + int m_beauty_shot; + int m_vintage_mode; +// int m_focus_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; +#endif + + 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; + + exif_attribute_t mExifInfo; + + struct fimc_buffer m_buffers_c[MAX_BUFFERS]; + struct pollfd m_events_c; + + inline int m_frameSize(int format, int width, int height); + + void setExifChangedAttribute(); + void setExifFixedAttribute(); + void resetCamera(); +}; + +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 new file mode 100644 index 0000000..5c2dc76 --- /dev/null +++ b/libcamera/SecCameraHWInterface.cpp @@ -0,0 +1,2370 @@ +/* +** +** Copyright 2008, The Android Open Source Project +** Copyright@ 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 <utils/Log.h> + +#include "SecCameraHWInterface.h" +#include <utils/threads.h> +#include <fcntl.h> +#include <sys/mman.h> + +#ifdef SEND_YUV_RECORD_DATA +#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) +#define RECORD_HEAP_SIZE (ALIGN_TO_8KB(ALIGN_TO_128B(1280) * ALIGN_TO_32B(720)) + ALIGN_TO_8KB(ALIGN_TO_128B(1280) * ALIGN_TO_32B(720/2))) +#endif + +namespace android { + +struct ADDRS +{ + unsigned int addr_y; + unsigned int addr_cbcr; +}; + +struct ADDRS_CAP +{ + unsigned int addr_y; + unsigned int width; + unsigned int height; +}; + +CameraHardwareSec::CameraHardwareSec() + : mParameters(), + mPreviewHeap(0), + mRawHeap(0), + mRecordHeap(0), + mJpegHeap(0), + mSecCamera(NULL), + mPreviewRunning(false), + mPreviewFrameSize(0), + mRawFrameSize(0), + mPreviewFrameRateMicrosec(33000), + mNotifyCb(0), + mDataCb(0), + mDataCbTimestamp(0), + mCallbackCookie(0), + mMsgEnabled(0), + mCurrentPreviewFrame(0), + mRecordRunning(false) +#ifdef JPEG_FROM_SENSOR + , + mPostViewWidth(0), + mPostViewHeight(0), + mPostViewSize(0) +#endif + #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + , + mObjectTrackingStatus(0), + mSmartautosceneRunning(false), + mSmartautoscene_current_status(0), + mSmartautoscene_previous_status(0) + #endif +{ + LOGV("%s()", __FUNCTION__); + int ret = 0; + mNoHwHandle = 0; + + mSecCamera = SecCamera::createInstance(); + if(mSecCamera == NULL) + { + LOGE("ERR(%s):Fail on mSecCamera object creation", __FUNCTION__); + } + + ret = mSecCamera->initCamera(); + if(ret < 0) + { + LOGE("ERR(%s):Fail on mSecCamera init", __FUNCTION__); + } + + if(mSecCamera->flagCreate() == 0) + { + LOGE("ERR(%s):Fail on mSecCamera->flagCreate()", __FUNCTION__); + } + +#ifndef PREVIEW_USING_MMAP + int previewHeapSize = sizeof(struct ADDRS) * kBufferCount; + LOGV("mPreviewHeap : MemoryHeapBase(previewHeapSize(%d))", previewHeapSize); + mPreviewHeap = new MemoryHeapBase(previewHeapSize); + if (mPreviewHeap->getHeapID() < 0) + { + LOGE("ERR(%s): Preview heap creation fail", __func__); + mPreviewHeap.clear(); + } +#endif + +#ifdef SEND_YUV_RECORD_DATA + int recordHeapSize = RECORD_HEAP_SIZE; +#else + int recordHeapSize = sizeof(struct ADDRS) * kBufferCount; +#endif + LOGV("mRecordHeap : MemoryHeapBase(recordHeapSize(%d))", recordHeapSize); + mRecordHeap = new MemoryHeapBase(recordHeapSize); + if (mRecordHeap->getHeapID() < 0) + { + LOGE("ERR(%s): Record heap creation fail", __func__); + mRecordHeap.clear(); + } + +#ifdef JPEG_FROM_SENSOR + mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); + LOGV("mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",mPostViewWidth,mPostViewHeight,mPostViewSize); +#endif + +#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA + int rawHeapSize = mPostViewSize; +#else + int rawHeapSize = sizeof(struct ADDRS_CAP); +#endif + 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(); +} + +void CameraHardwareSec::initDefaultParameters() +{ + if(mSecCamera == NULL) + { + LOGE("ERR(%s):mSecCamera object is NULL", __FUNCTION__); + return; + } + + CameraParameters p; + + int preview_max_width = 0; + int preview_max_height = 0; + int snapshot_max_width = 0; + int snapshot_max_height = 0; + + int camera_id = 1; + + p.set("camera-id", camera_id); + + if(camera_id == 1) + mSecCamera->setCameraId(SecCamera::CAMERA_ID_BACK); + else + mSecCamera->setCameraId(SecCamera::CAMERA_ID_FRONT); + + if(mSecCamera->getPreviewMaxSize(&preview_max_width, &preview_max_height) < 0) + { + LOGE("getPreviewMaxSize fail (%d / %d) \n", preview_max_width, preview_max_height); + preview_max_width = LCD_WIDTH; + preview_max_height = LCD_HEIGHT; + } + if(mSecCamera->getSnapshotMaxSize(&snapshot_max_width, &snapshot_max_height) < 0) + { + LOGE("getSnapshotMaxSize fail (%d / %d) \n", snapshot_max_width, snapshot_max_height); + snapshot_max_width = LCD_WIDTH; + snapshot_max_height = LCD_HEIGHT; + } + +#ifdef PREVIEW_USING_MMAP + p.setPreviewFormat("yuv420sp"); +#else + p.setPreviewFormat("yuv420sp_custom"); +#endif + p.setPreviewSize(preview_max_width, preview_max_height); + p.setPreviewFrameRate(30); + + p.setPictureFormat("jpeg"); + p.setPictureSize(snapshot_max_width, snapshot_max_height); + p.set("jpeg-quality", "100"); // maximum quality +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + p.set("preview-size-values","640x480,800x480"); //s1_camera [ 3-party application ¿¡¼ get supported preview size ¾ÈµÇ´Â Çö»ó ¼öÁ¤ ] + p.set("picture-size-values","2560x1920,2048x1536,1600x1200,640x480,2560x1536,2048x1232,1600x960,800x480"); + p.set("preview-format-values", "yuv420sp"); + p.set("preview-frame-rate-values", "15,30"); + p.set("picture-format-values", "jpeg"); + p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, "160x120,0x0"); + p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, CameraParameters::PIXEL_FORMAT_YUV420SP); + p.set("focus-mode-values", "auto,macro"); + p.set("antibanding-values", "auto,50hz,60hz,off"); + p.set("effect-values", "none,mono,negative,sepia"); + p.set("flash-mode-values", "off"); +// p.set("focus-mode-values", "auto,infinity,macro"); + p.set("scene-mode-values", "auto,portrait,landscape,night,beach,snow,sunset,fireworks,sports,party,candlelight"); + p.set("whitebalance-values", "auto,incandescent,fluorescent,daylight,cloudy-daylight"); +//add the max and min for adjust value[20100728 giung.jung] + p.set("sharpness-min", 0); + p.set("sharpness-max", 4); + p.set("saturation-min", 0); + p.set("saturation-max", 4); + p.set("contrast-min", 0); + p.set("contrast-max", 4); + +#else + // List supported picture size values //Kamat + p.set("picture-size-values", "2560x1920,2048x1536,1600x1200,1280x960"); +#endif + // These values must be multiples of 16, so we can't do 427x320, which is the exact size on + // screen we want to display at. 480x360 doesn't work either since it's a multiple of 8. + p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160"); + p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120"); + p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100"); + + p.set("rotation", 0); + p.set("whitebalance", "auto"); +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + p.set("effect", "none"); + p.set("scene-mode", "auto"); + p.set("vintagemode", "off"); + p.set("sharpness", 2); + p.set("contrast", 2); + p.set("saturation", 2); + p.set("iso", "auto"); + p.set("metering", "center"); + //p.set("facedetect", 0); + p.set("flash-mode", "off"); + p.set("focus-mode", "auto"); + p.set("anti-shake", 0); + p.set("wdr", 0); + p.set("smart-auto",0); + p.set("beauty-shot", 0); + p.set("antibanding", "auto"); + p.set("video_recording_gamma", "off"); + p.set("slow_ae", "off"); + p.set("vtmode", 0); + p.set("chk_dataline", 0); + p.set("blur", 0); +#else + p.set("image-effects", "original"); +#endif + + p.set(CameraParameters::KEY_ZOOM, "0"); + p.set(CameraParameters::KEY_ZOOM_SUPPORTED, "true"); + p.set(CameraParameters::KEY_MAX_ZOOM, "12"); + p.set(CameraParameters::KEY_ZOOM_RATIOS, "100,125,150,175,200,225,250,275,300,324,350,375,400"); + + p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.79"); + + 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"); + + p.set("AppShutterSound", 0); + if (setParameters(p) != NO_ERROR) + { + LOGE("ERR(%s):Fail on setParameters(p)", __FUNCTION__); + } +} + +CameraHardwareSec::~CameraHardwareSec() +{ + LOGV("%s()", __FUNCTION__); + + mSecCamera->DeinitCamera(); + + if(mRawHeap != NULL) + mRawHeap.clear(); + + if(mJpegHeap != NULL) + mJpegHeap.clear(); + + if(mPreviewHeap != NULL) + mPreviewHeap.clear(); + + if(mRecordHeap != NULL) + mRecordHeap.clear(); + + mSecCamera = NULL; + + singleton.clear(); +} + +sp<IMemoryHeap> CameraHardwareSec::getPreviewHeap() const +{ + return mPreviewHeap; +} + +sp<IMemoryHeap> CameraHardwareSec::getRawHeap() const +{ + return mRawHeap; +} + +//Kamat added: New code as per eclair framework +void CameraHardwareSec::setCallbacks(notify_callback notify_cb, + data_callback data_cb, + data_callback_timestamp data_cb_timestamp, + void* user) +{ + Mutex::Autolock lock(mLock); + mNotifyCb = notify_cb; + mDataCb = data_cb; + mDataCbTimestamp = data_cb_timestamp; + mCallbackCookie = user; +} + +void CameraHardwareSec::enableMsgType(int32_t msgType) +{ + Mutex::Autolock lock(mLock); + mMsgEnabled |= msgType; +} + +void CameraHardwareSec::disableMsgType(int32_t msgType) +{ + Mutex::Autolock lock(mLock); + mMsgEnabled &= ~msgType; +} + +bool CameraHardwareSec::msgTypeEnabled(int32_t msgType) +{ + Mutex::Autolock lock(mLock); + return (mMsgEnabled & msgType); +} + +// --------------------------------------------------------------------------- + +int CameraHardwareSec::previewThread() +{ + int index; + + index = mSecCamera->getPreview(); + if(index < 0) + { + LOGE("ERR(%s):Fail on SecCamera->getPreview()", __FUNCTION__); + return UNKNOWN_ERROR; + } + + nsecs_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC); + +#ifdef PREVIEW_USING_MMAP + int width, height, frame_size, offset; + mSecCamera->getPreviewSize(&width, &height, &frame_size); + + offset = (frame_size+8)*index; + sp<MemoryBase> buffer = new MemoryBase(mPreviewHeap, offset, frame_size); + + unsigned int phyYAddr = mSecCamera->getPhyAddrY(index); + unsigned int phyCAddr = mSecCamera->getPhyAddrC(index); + if(phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) + { + LOGE("ERR(%s):Fail on SecCamera. Invalid PhyAddr, Y addr = %0x C addr = %0x", __FUNCTION__, phyYAddr, phyCAddr); + return UNKNOWN_ERROR; + } + memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset+frame_size ), &phyYAddr, 4); + memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset+frame_size+4), &phyCAddr, 4); +#else + unsigned int phyYAddr = mSecCamera->getPhyAddrY(index); + unsigned int phyCAddr = mSecCamera->getPhyAddrC(index); + if(phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) + { + LOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x", __FUNCTION__, phyYAddr, phyCAddr); + return UNKNOWN_ERROR; + } + struct ADDRS *addrs = (struct ADDRS *)mPreviewHeap->base(); + + sp<MemoryBase> buffer = new MemoryBase(mPreviewHeap, index * sizeof(struct ADDRS), sizeof(struct ADDRS)); + addrs[index].addr_y = phyYAddr; + addrs[index].addr_cbcr = phyCAddr; +#endif //PREVIEW_USING_MMAP + + // Notify the client of a new frame. //Kamat --eclair + if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) + { + mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie); + } +// LOG_CAMERA_PREVIEW("previewThread: addr_y(0x%08X) addr_cbcr(0x%08X)", addrs[index].addr_y, addrs[index].addr_cbcr); + + if(mRecordRunning == true) + { +#ifdef SEND_YUV_RECORD_DATA + int width, height, frame_size; + unsigned char* virYAddr; + unsigned char* virCAddr; + mSecCamera->getPreviewSize(&width, &height, &frame_size); + mSecCamera->getYUVBuffers(&virYAddr, &virCAddr, index); + sp<MemoryBase> buffer = new MemoryBase(mRecordHeap, 0, frame_size); + //memcpy(mRecordHeap->base(), (void*)virYAddr, width*height); + //memcpy(mRecordHeap->base()+(width*height),(void*)virCAddr, width*height*0.5); + memcpy(mRecordHeap->base(), (void*)virYAddr, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height))); + memcpy(mRecordHeap->base() + ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)),(void*)virCAddr, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height/2))); +#else +#ifdef DUAL_PORT_RECORDING + int index = mSecCamera->getRecord(); + if(index < 0) + { + LOGE("ERR(%s):Fail on SecCamera->getRecord()", __FUNCTION__); + return UNKNOWN_ERROR; + } + unsigned int phyYAddr = mSecCamera->getRecPhyAddrY(index); + unsigned int phyCAddr = mSecCamera->getRecPhyAddrC(index); + if(phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) + { + LOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __FUNCTION__, phyYAddr, phyCAddr); + return UNKNOWN_ERROR; + } +#endif//DUAL_PORT_RECORDING + struct ADDRS *addrs = (struct ADDRS *)mRecordHeap->base(); + + sp<MemoryBase> buffer = new MemoryBase(mRecordHeap, index * sizeof(struct ADDRS), sizeof(struct ADDRS)); + addrs[index].addr_y = phyYAddr; + addrs[index].addr_cbcr = phyCAddr; +#endif + // Notify the client of a new frame. //Kamat --eclair + if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) + { + //nsecs_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC); + mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, buffer, mCallbackCookie); + } + } +#ifdef DUAL_PORT_RECORDING + else if(mRecordRunning == false) + { + if(mSecCamera->stopRecord() < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __FUNCTION__); + return UNKNOWN_ERROR; + } + } +#endif + +// buffer.clear(); + + // Wait for it... + if(mTimeStart.tv_sec == 0 && mTimeStart.tv_usec == 0) + { + gettimeofday(&mTimeStart, NULL); + } else + { + gettimeofday(&mTimeStop, NULL); + long time = measure_time(&mTimeStart, &mTimeStop); + + int delay = (mPreviewFrameRateMicrosec > time) ? mPreviewFrameRateMicrosec - time : 0; + usleep(delay); + //LOG_CAMERA_PREVIEW("delay = %d time = %ld us\n ", delay, time); + gettimeofday(&mTimeStart, NULL); + } + + return NO_ERROR; +} + +status_t CameraHardwareSec::startPreview() +{ + int ret = 0; //s1 [Apply factory standard] + + LOGE("%s()", __FUNCTION__); + + Mutex::Autolock lock(mLock); + if (mPreviewThread != 0) { + // already running + return INVALID_OPERATION; + } + + memset(&mTimeStart, 0, sizeof(mTimeStart)); + memset(&mTimeStop, 0, sizeof(mTimeStop)); + + mSecCamera->stopPreview(); + +#if 1 //s1 [Apply factory standard] + ret = mSecCamera->startPreview(); + LOGE("%s : return startPreview %d", __FUNCTION__, ret); + + if(ret < 0) +#else + if(mSecCamera->startPreview() < 0) +#endif + { + LOGE("ERR(%s):Fail on mSecCamera->startPreview()", __FUNCTION__); + if (mMsgEnabled & CAMERA_MSG_ERROR) + { + mNotifyCb(CAMERA_MSG_ERROR, -2, 0, mCallbackCookie); + } + return -1; //UNKNOWN_ERROR; + } + +#ifdef PREVIEW_USING_MMAP + if(mPreviewHeap != NULL) + mPreviewHeap.clear(); + int width, height, frame_size; + mSecCamera->getPreviewSize(&width, &height, &frame_size); + int previewHeapSize = (frame_size+8) * 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); +#endif + +#ifdef JPEG_FROM_SENSOR + mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); + LOGE("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",mPostViewWidth,mPostViewHeight,mPostViewSize); +#endif + +#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA + int rawHeapSize = mPostViewSize; +#else + int rawHeapSize = sizeof(struct ADDRS_CAP); +#endif + LOGE("CameraHardwareSec: mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize); + mRawHeap = new MemoryHeapBase(rawHeapSize); + if (mRawHeap->getHeapID() < 0) + { + LOGE("ERR(%s): Raw heap creation fail", __func__); + mRawHeap.clear(); + } + +#if 0 + mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); + struct ADDRS_CAP *addrs = (struct ADDRS_CAP *)mRawHeap->base(); + + LOGE("[5B 1] mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",mPostViewWidth,mPostViewHeight); + + addrs[0].width = mPostViewWidth; + addrs[0].height = mPostViewHeight; + +#endif + + mPreviewRunning = true; + mPreviewThread = new PreviewThread(this); + return NO_ERROR; +} + +void CameraHardwareSec::stopPreview() +{ + LOGV("%s()", __FUNCTION__); + + sp<PreviewThread> previewThread; + + { // scope for the lock + Mutex::Autolock lock(mLock); + previewThread = mPreviewThread; + } + + // don't hold the lock while waiting for the thread to quit +// if (previewThread != 0) { +// previewThread->requestExitAndWait(); +// } + + Mutex::Autolock lock(mLock); + mPreviewThread.clear(); + + if(!mNoHwHandle) + if(mSecCamera->stopPreview() < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->stopPreview()", __FUNCTION__); + } + + mPreviewRunning = false; +} + +bool CameraHardwareSec::previewEnabled() { + LOGV("%s() : %d", __FUNCTION__, mPreviewThread != 0); + return mPreviewThread != 0; +} + +// --------------------------------------------------------------------------- + +status_t CameraHardwareSec::startRecording() +{ + LOGV("%s()", __FUNCTION__); + +#ifdef DUAL_PORT_RECORDING + if(mSecCamera->startRecord() < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __FUNCTION__); + return UNKNOWN_ERROR; + } +#endif + + mRecordRunning = true; + return NO_ERROR; +} + +void CameraHardwareSec::stopRecording() +{ + LOGV("%s()", __FUNCTION__); + + mRecordRunning = false; +} + +bool CameraHardwareSec::recordingEnabled() +{ + LOGV("%s()", __FUNCTION__); + + return mRecordRunning; +} + +void CameraHardwareSec::releaseRecordingFrame(const sp<IMemory>& mem) +{ + LOG_CAMERA_PREVIEW("%s()", __FUNCTION__); + +// ssize_t offset; size_t size; +// sp<MemoryBase> mem1 = mem; +// sp<MemoryHeapBase> heap = mem->getMemory(&offset, &size); +// sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); + +// mem1.clear(); +// heap.clear(); +} + +// --------------------------------------------------------------------------- + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +int CameraHardwareSec::smartautosceneThread() +{ + + mSmartautoscene_current_status = mSecCamera->getAutosceneStatus(); + + if(mSmartautoscene_current_status < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->getAutosceneStatus()", __FUNCTION__); + return UNKNOWN_ERROR; + } + + if(mSmartautoscene_current_status != mSmartautoscene_previous_status) + { + //if (mMsgEnabled & CAMERA_MSG_SMARTAUTO_SCENE_STATUS) + //mNotifyCb(CAMERA_MSG_SMARTAUTO_SCENE_STATUS, mSmartautoscene_current_status, 0, mCallbackCookie); + LOGE("%s CAMERA_MSG_SMARTAUTO_SCENE_STATUS(%d) Callback!!!!!!!! ", __FUNCTION__,mSmartautoscene_current_status); + mSmartautoscene_previous_status = mSmartautoscene_current_status; + } + else + { + LOGE("%s current_status(%d) is same with previous_status(%d)", __FUNCTION__,mSmartautoscene_current_status,mSmartautoscene_previous_status); + } + usleep(2000*1000); //2000ms delay + LOGE("DELAY(2000ms)!!!!!!!"); + return NO_ERROR; +} + +status_t CameraHardwareSec::startSmartautoscene() +{ + LOGV("%s()", __FUNCTION__); + +// Mutex::Autolock lock(mLock); + + if (mSmartautosceneThread != 0) { + // already running + return INVALID_OPERATION; + } + + mSmartautosceneRunning = true; + mSmartautosceneThread = new SmartautosceneThread(this); + return NO_ERROR; +} + +void CameraHardwareSec::stopSmartautoscene() +{ + LOGV("%s()", __FUNCTION__); + + sp<SmartautosceneThread> smartautosceneThread; + + { // scope for the lock +// Mutex::Autolock lock(mLock); + smartautosceneThread = mSmartautosceneThread; + } + + // don't hold the lock while waiting for the thread to quit + if (smartautosceneThread != 0) { + smartautosceneThread->requestExitAndWait(); + } + +// Mutex::Autolock lock(mLock); + mSmartautosceneThread.clear(); + + mSmartautosceneRunning = false; +} + +bool CameraHardwareSec::smartautosceneEnabled() { + LOGV("%s() : %d", __FUNCTION__, mSmartautosceneThread != 0); + return mSmartautosceneThread != 0; +} + +#endif + + +int CameraHardwareSec::beginAutoFocusThread(void *cookie) +{ + LOGV("%s()", __FUNCTION__); + CameraHardwareSec *c = (CameraHardwareSec *)cookie; + return c->autoFocusThread(); +} + +int CameraHardwareSec::autoFocusThread() +{ +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + int count =0; + int af_status =0 ; +#endif + + LOGV("%s()", __FUNCTION__); +// usleep(50000); // 1frame delay 50ms + if(mSecCamera->setAutofocus() < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __FUNCTION__); + return UNKNOWN_ERROR; + } + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +// usleep(10000); + af_status = mSecCamera->getAutoFocusResult(); + + if (af_status == 0x01) + { + LOGV("%s() AF Success!!", __FUNCTION__); + if (mMsgEnabled & CAMERA_MSG_FOCUS) + mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); + } + else if (af_status == 0x02) + { + LOGV("%s() AF Cancelled !!", __FUNCTION__); + if (mMsgEnabled & CAMERA_MSG_FOCUS) + mNotifyCb(CAMERA_MSG_FOCUS, 0x02, 0, mCallbackCookie); + } + else + { + LOGV("%s() AF Fail !!", __FUNCTION__); + if (mMsgEnabled & CAMERA_MSG_FOCUS) + mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie); + } +#else + if (mMsgEnabled & CAMERA_MSG_FOCUS) + mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); +#endif + return NO_ERROR; +} + +status_t CameraHardwareSec::autoFocus() +{ + LOGV("%s()", __FUNCTION__); + Mutex::Autolock lock(mLock); + if (createThread(beginAutoFocusThread, this) == false) + return UNKNOWN_ERROR; + return NO_ERROR; +} + +/* 2009.10.14 by icarus for added interface */ +status_t CameraHardwareSec::cancelAutoFocus() +{ +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGV("%s()", __FUNCTION__); + + if(mSecCamera->cancelAutofocus() < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __FUNCTION__); + return UNKNOWN_ERROR; + } +#endif + return NO_ERROR; +} + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION +status_t CameraHardwareSec::objectTracking(int onoff) +{ + LOGV("%s() onoff = %d", __FUNCTION__, onoff); + + Mutex::Autolock lock(mLock); + if(onoff) + { + if (mObjectTrackingThread == 0) { + mObjectTrackingThread = new ObjectTrackingThread(this); + } + mObjectTrackingRunning=true; + } + else + { + if (mObjectTrackingThread != 0) { + mObjectTrackingThread->requestExitAndWait(); + } + mObjectTrackingThread.clear(); + mObjectTrackingRunning=false; + } + return 0; +} + +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; + } + + LOGE("[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; +} + + +int CameraHardwareSec::objectTrackingThread() +{ + int new_obj_status; + new_obj_status = mSecCamera->getObjectTrackingStatus(); +#if 0 //temp till define callback msg + if (mObjectTrackingStatus != new_obj_status) + { + mObjectTrackingStatus = new_obj_status; + if (mMsgEnabled & CAMERA_MSG_OBJ_TRACKING) + mNotifyCb(CAMERA_MSG_OBJ_TRACKING, new_obj_status, 0, mCallbackCookie); + } +#endif + usleep(100000); //100ms + return NO_ERROR; +} +#endif +/*static*/ int CameraHardwareSec::beginPictureThread(void *cookie) +{ + LOGV("%s()", __FUNCTION__); + CameraHardwareSec *c = (CameraHardwareSec *)cookie; + return c->pictureThread(); +} + +void CameraHardwareSec::save_postview(const char *fname, uint8_t *buf, uint32_t size) +{ + int nw, 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); +} + +int CameraHardwareSec::pictureThread() +{ + LOGV("%s()", __FUNCTION__); + + int jpeg_size = 0; + int ret = NO_ERROR; + unsigned char * jpeg_data = NULL; + int postview_offset = 0; + unsigned char * postview_data = NULL; + + //unsigned int addr; + unsigned char * addr = NULL; + int mPostViewWidth, mPostViewHeight, mPostViewSize; + int cap_width, cap_height, cap_frame_size; + + mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); + int postviewHeapSize = mPostViewWidth*mPostViewHeight*2; //*size = (BACK_CAMERA_POSTVIEW_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP)/8; + mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size); + LOGE("[kidggang]:func(%s):line(%d)&cap_width(%d), &cap_height(%d), &cap_frame_size(%d)\n",__FUNCTION__,__LINE__,cap_width, cap_height, cap_frame_size); + +// sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, postviewHeapSize); + + LOG_TIME_DEFINE(0) + LOG_TIME_START(0) +#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA + sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, mPostViewSize+8); +#else + sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, sizeof(struct ADDRS_CAP)); +#endif + + struct ADDRS_CAP *addrs = (struct ADDRS_CAP *)mRawHeap->base(); + +#ifdef JPEG_FROM_SENSOR + addrs[0].width = mPostViewWidth; + addrs[0].height = mPostViewHeight; + LOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight); +#else + mParameters.getPictureSize((int*)&addrs[0].width, (int*)&addrs[0].height); +#endif + + + if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) { //[zzangdol] CAMERA_ID_BACK +#ifndef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if (mMsgEnabled & CAMERA_MSG_SHUTTER) + { + mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie); + } +#endif + }//[zzangdol]CAMERA_ID_BACK + + 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; +#ifdef JPEG_FROM_SENSOR + // Modified the shutter sound timing for Jpeg capture + if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) + mSecCamera->setSnapshotCmd(); +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if (mMsgEnabled & CAMERA_MSG_SHUTTER) + { + mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie); + } +#endif + + if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){ //[zzangdol] CAMERA_ID_BACK + jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr); + if(jpeg_data == NULL) + { + LOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __FUNCTION__); + ret = UNKNOWN_ERROR; + } + }//[zzangdol] CAMERA_ID_BACK + else + { + addr = mSecCamera->getSnapshotAndJpeg(); + //LOGV("[zzangdol] getSnapshotAndJpeg\n"); + } +#else + phyAddr = mSecCamera->getSnapshotAndJpeg(); + jpeg_data = mSecCamera->yuv2Jpeg((unsigned char*)phyAddr, 0, &jpeg_size, picture_width, picture_height, picture_format); +#endif + +#ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA + postview_offset = mSecCamera->getPostViewOffset(); + if(jpeg_data != NULL) + memcpy(mRawHeap->base(), jpeg_data+postview_offset, mPostViewSize); +#else + addrs[0].addr_y = phyAddr; +#endif + + LOG_TIME_END(1) + LOG_CAMERA("getSnapshotAndJpeg interval: %lu us", LOG_TIME(1)); + } + + int JpegImageSize, JpegExifSize; + sp<MemoryHeapBase> PostviewHeap = new MemoryHeapBase(mPostViewSize); + sp<MemoryHeapBase> JpegHeap = new MemoryHeapBase(4300000); + decodeInterleaveData(jpeg_data, 4261248, mPostViewWidth, mPostViewHeight, + &JpegImageSize, JpegHeap->base(), PostviewHeap->base()); + + sp<MemoryBase> postview = new MemoryBase(PostviewHeap, 0, postviewHeapSize); + memcpy(mRawHeap->base(),PostviewHeap->base(), postviewHeapSize); +#if 0//def SWP1_CAMERA_ADD_ADVANCED_FUNCTION + if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) + { + int postviewHeapSize = mPostViewSize; + sp<MemoryHeapBase> mPostviewHeap = new MemoryHeapBase(postviewHeapSize); + + postview_data = jpeg_data + postview_offset; + sp<MemoryBase> postview = new MemoryBase(mPostviewHeap, 0, postviewHeapSize); + + if(postview_data != NULL) + memcpy(mPostviewHeap->base(), postview_data, postviewHeapSize); + + mDataCb(CAMERA_MSG_POSTVIEW_FRAME, postview, mCallbackCookie); + } +#endif //#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + + if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) + { + if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){ + sp<MemoryHeapBase> ExifHeap = new MemoryHeapBase(EXIF_FILE_SIZE + JPG_STREAM_BUF_SIZE); + JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->base(), + (unsigned char *)PostviewHeap->base()); + + LOGE("JpegExifSize=%d", JpegExifSize); + unsigned char *ExifStart = (unsigned char *)JpegHeap->base() + 2; + unsigned char *ImageStart = ExifStart + JpegExifSize; + + memmove(ImageStart, ExifStart, JpegImageSize - 2); + memcpy(ExifStart, ExifHeap->base(), JpegExifSize); + sp<MemoryBase> mem = new MemoryBase(JpegHeap, 0, JpegImageSize + JpegExifSize); + + mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie); + + mDataCb(CAMERA_MSG_RAW_IMAGE, buffer, mCallbackCookie); + }//[zzangdol] CAMERA_ID_BACK + else + { + LOGV("[zzangdol] COMPRESSED_IMAGE\n"); + //mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size); + //sp<MemoryHeapBase> mHeap = new MemoryHeapBase((int)mSecCamera->getCameraFd(), (size_t)(cap_frame_size * kBufferCount), (uint32_t)0); + sp<MemoryHeapBase> mHeap = new MemoryHeapBase(2000000); + memcpy(mHeap->base(), addr, cap_frame_size); + sp<MemoryBase> mem = new MemoryBase(mHeap , 0, cap_frame_size); + //save_postview("/data/front.yuv", (uint8_t *)mHeap->base(), yuv_frame_size2); + mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie);//[zzangdol] + } + } + + LOG_TIME_END(0) + LOG_CAMERA("pictureThread interval: %lu us", LOG_TIME(0)); + + return ret; +} + +status_t CameraHardwareSec::takePicture() +{ + LOGV("%s()", __FUNCTION__); + + stopPreview(); + mNoHwHandle = 0; + + if (createThread(beginPictureThread, this) == false) + return -1; + + return NO_ERROR; +} + +status_t CameraHardwareSec::cancelPicture() +{ + return NO_ERROR; +} + +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; + + LOGE("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; + } + } + } + LOGE("decodeInterleaveData End~~~"); + return ret; +} + +status_t CameraHardwareSec::dump(int fd, const Vector<String16>& args) const +{ + const size_t SIZE = 256; + char buffer[SIZE]; + String8 result; + AutoMutex lock(&mLock); + if (mSecCamera != 0) { + mSecCamera->dump(fd, args); + mParameters.dump(fd, args); + snprintf(buffer, 255, " preview frame(%d), size (%d), running(%s)\n", mCurrentPreviewFrame, mPreviewFrameSize, mPreviewRunning?"true": "false"); + result.append(buffer); + } else { + result.append("No camera client yet.\n"); + } + write(fd, result.string(), result.size()); + return NO_ERROR; +} + +status_t CameraHardwareSec::setParameters(const CameraParameters& params) +{ + LOGV("%s()", __FUNCTION__); + + Mutex::Autolock lock(mLock); + + status_t ret = NO_ERROR; + + mParameters = params; + + // set camera id + int new_camera_id = params.getInt("camera-id"); + if(0 <= new_camera_id) + { + if(mSecCamera->setCameraId(new_camera_id) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setCameraId(camera_id(%d))", __FUNCTION__, new_camera_id); + ret = UNKNOWN_ERROR; + } + } + + // 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(); + 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, "rgb565") == 0) + new_preview_format = V4L2_PIX_FMT_RGB565; + else if (strcmp(new_str_preview_format, "yuv420sp") == 0) + new_preview_format = V4L2_PIX_FMT_NV21; //Kamat + else if (strcmp(new_str_preview_format, "yuv420sp_custom") == 0) + new_preview_format = V4L2_PIX_FMT_NV12T; //Kamat + else if (strcmp(new_str_preview_format, "yuv420p") == 0) + new_preview_format = V4L2_PIX_FMT_YUV420; + else if (strcmp(new_str_preview_format, "yuv422i") == 0) + new_preview_format = V4L2_PIX_FMT_YUYV; + else if (strcmp(new_str_preview_format, "yuv422p") == 0) + 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))", __FUNCTION__, new_preview_width, new_preview_height, new_preview_format); + ret = UNKNOWN_ERROR; + } + } + + int new_picture_width = 0; + int new_picture_height = 0; + params.getPictureSize(&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))", __FUNCTION__, new_picture_width, new_picture_height); + ret = UNKNOWN_ERROR; + } + } + + // picture format + const char * new_str_picture_format = params.getPictureFormat(); + if(new_str_picture_format != NULL) + { + int new_picture_format = 0; + + if (strcmp(new_str_picture_format, "rgb565") == 0) + new_picture_format = V4L2_PIX_FMT_RGB565; + else if (strcmp(new_str_picture_format, "yuv420sp") == 0) + new_picture_format = V4L2_PIX_FMT_NV21; //Kamat: Default format + else if (strcmp(new_str_picture_format, "yuv420sp_custom") == 0) + new_picture_format = V4L2_PIX_FMT_NV12T; + else if (strcmp(new_str_picture_format, "yuv420p") == 0) + new_picture_format = V4L2_PIX_FMT_YUV420; + else if (strcmp(new_str_picture_format, "yuv422i") == 0) + new_picture_format = V4L2_PIX_FMT_YUYV; + else if (strcmp(new_str_picture_format, "uyv422i_custom") == 0) //Zero copy UYVY format + new_picture_format = V4L2_PIX_FMT_UYVY; + else if (strcmp(new_str_picture_format, "uyv422i") == 0) //Non-zero copy UYVY format + new_picture_format = V4L2_PIX_FMT_UYVY; + else if (strcmp(new_str_picture_format, "jpeg") == 0) +#ifdef JPEG_FROM_SENSOR + new_picture_format = V4L2_PIX_FMT_UYVY; +#else + new_picture_format = V4L2_PIX_FMT_YUYV; +#endif + else if (strcmp(new_str_picture_format, "yuv422p") == 0) + 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))", __FUNCTION__, new_picture_format); + ret = UNKNOWN_ERROR; + } + } + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + //JPEG image quality + int new_jpeg_quality = params.getInt("jpeg-quality"); + + if (new_jpeg_quality < 1 || new_jpeg_quality > 100) { + LOGE("ERR(%s): Invalid quality(%d))", __FUNCTION__, new_jpeg_quality); + + new_jpeg_quality = 100; + + mParameters.set("jpeg-quality", "100"); + } + + mSecCamera->setJpegQuality(new_jpeg_quality); +#else + //JPEG image quality + int new_jpeg_quality = params.getInt("jpeg-quality"); + if (new_jpeg_quality < 0) + { + LOGW("JPEG-image quality is not specified or is negative, defaulting to 100"); + new_jpeg_quality = 100; + mParameters.set("jpeg-quality", "100"); + } + mSecCamera->setJpegQuality(new_jpeg_quality); +#endif + + // JPEG thumbnail size + int new_jpeg_thumbnail_width = params.getInt("jpeg-thumbnail-width"); + int new_jpeg_thumbnail_height= params.getInt("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))", __FUNCTION__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height); + ret = UNKNOWN_ERROR; + } + } + + // frame rate + int new_frame_rate = params.getPreviewFrameRate(); + if(new_frame_rate < 5 || new_frame_rate > 30) + { + new_frame_rate = 30; + } + + mParameters.setPreviewFrameRate(new_frame_rate); + // Calculate how long to wait between frames. + mPreviewFrameRateMicrosec = (int)(1000000.0f / float(new_frame_rate)); + + LOGD("frame rate:%d, mPreviewFrameRateMicrosec:%d", new_frame_rate, mPreviewFrameRateMicrosec); + + mSecCamera->setFrameRate(new_frame_rate); + + //vt mode + int new_vtmode = params.getInt("vtmode"); + if(0 <= new_vtmode) + { + if(mSecCamera->setVTmode(new_vtmode) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __FUNCTION__, new_vtmode); + ret = UNKNOWN_ERROR; + } + } + + // rotation + int new_rotation = params.getInt("rotation"); + int new_exif_rotation = 1; + if(new_rotation != -1) + { + if(new_vtmode == SecCamera::VT_MODE_ON ) // vt preview rotation + { + LOGE("ERR(%s):VT mode is on. Rotate(%d))", __FUNCTION__, new_rotation); + + if(mSecCamera->SetRotate(new_rotation) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->SetRotate(rotation(%d))", __FUNCTION__, new_rotation); + ret = UNKNOWN_ERROR; + } + } + else //exif orientation information + { + if(mSecCamera->SetRotate(0) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->SetRotate(rotation(%d))", __FUNCTION__, new_rotation); + ret = UNKNOWN_ERROR; + } + + if(new_rotation == 0) + new_exif_rotation = 1; + else if (new_rotation == 90) + new_exif_rotation = 6; + else if (new_rotation == 180) + new_exif_rotation = 3; + else if (new_rotation == 270) + new_exif_rotation = 8; + else + new_exif_rotation = 1; + } + } + +#ifndef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + // 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); + + 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))", __FUNCTION__, new_exposure_compensation); + ret = UNKNOWN_ERROR; + } + + } + + // whitebalance + const char * new_white_str = params.get("whitebalance"); + if(new_white_str != NULL) + { + int new_white = -1; + + if(strcmp(new_white_str, "auto") == 0) + new_white = SecCamera::WHITE_BALANCE_AUTO; + else if(strcmp(new_white_str, "indoor3100") == 0) + new_white = SecCamera::WHITE_BALANCE_INDOOR3100; + else if(strcmp(new_white_str, "outdoor5100") == 0) + new_white = SecCamera::WHITE_BALANCE_OUTDOOR5100; + else if(strcmp(new_white_str, "indoor2000") == 0) + new_white = SecCamera::WHITE_BALANCE_INDOOR2000; + else if(strcmp(new_white_str, "halt") == 0) + new_white = SecCamera::WHITE_BALANCE_HALT; + else if(strcmp(new_white_str, "cloudy") == 0) + new_white = SecCamera::WHITE_BALANCE_CLOUDY; + else if(strcmp(new_white_str, "sunny") == 0) + new_white = SecCamera::WHITE_BALANCE_SUNNY; + else + { + LOGE("ERR(%s):Invalid white balance(%s)", __FUNCTION__, new_white_str); + ret = UNKNOWN_ERROR; + } + + if(0 <= new_white) + { + // white_balance + if(mSecCamera->setWhiteBalance(new_white) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __FUNCTION__, new_white); + ret = UNKNOWN_ERROR; + } + } + } + + // image effect + const char * new_image_effect_str = params.get("image-effects"); + if(new_image_effect_str != NULL) + { + int new_image_effect = -1; + + if(strcmp(new_image_effect_str, "original") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_ORIGINAL; + else if(strcmp(new_image_effect_str, "arbitrary") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_ARBITRARY; + else if(strcmp(new_image_effect_str, "negative") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_NEGATIVE; + else if(strcmp(new_image_effect_str, "freeze") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_FREEZE; + else if(strcmp(new_image_effect_str, "embossing") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_EMBOSSING; + else if(strcmp(new_image_effect_str, "silhouette") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_SILHOUETTE; + else + { + LOGE("ERR(%s):Invalid effect(%s)", __FUNCTION__, new_image_effect_str); + ret = UNKNOWN_ERROR; + } + + if(new_image_effect >= 0) + { + // white_balance + if(mSecCamera->setImageEffect(new_image_effect) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __FUNCTION__, new_image_effect); + ret = UNKNOWN_ERROR; + } + } + } + +#else + // scene mode + const char * new_scene_mode_str = params.get("scene-mode"); + + LOGV("%s() new_scene_mode_str %s", __FUNCTION__,new_scene_mode_str); + + if(new_scene_mode_str != NULL) + { + int new_scene_mode = -1; + + const char * new_iso_str = NULL; + const char * new_metering_str = NULL; + int new_exposure_compensation = 0; + const char * new_white_str = NULL; + int new_sharpness = 0; + int new_saturation = 0; + const char * new_focus_mode_str = NULL; + const char * new_flash_mode_str = NULL; + + if(strcmp(new_scene_mode_str, "auto") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_NONE; + + new_iso_str = params.get("iso"); + new_metering_str = params.get("metering"); + new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); + new_white_str = params.get("whitebalance"); + new_sharpness = params.getInt("sharpness"); + new_saturation = params.getInt("saturation"); + new_focus_mode_str = params.get("focus-mode"); + new_flash_mode_str = params.get("flash-mode"); + } + else + { + if(strcmp(new_scene_mode_str, "portrait") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_PORTRAIT; + + mParameters.set("iso", "auto"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_MINUS_1); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "facedetect"); + } + else if(strcmp(new_scene_mode_str, "landscape") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_LANDSCAPE; + + mParameters.set("iso", "auto"); + mParameters.set("metering", "matrix"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_PLUS_1); + mParameters.set("saturation", SecCamera::SATURATION_PLUS_1); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "sports") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_SPORTS; + + mParameters.set("iso", "sports"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "party") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_PARTY_INDOOR; + + mParameters.set("iso", "200"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_PLUS_1); + mParameters.set("focus-mode", "auto"); + } + else if((strcmp(new_scene_mode_str, "beach") == 0) || (strcmp(new_scene_mode_str, "snow") == 0)) + { + new_scene_mode = SecCamera::SCENE_MODE_BEACH_SNOW; + + mParameters.set("iso", "50"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_PLUS_2); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_PLUS_1); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "sunset") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_SUNSET; + + mParameters.set("iso", "auto"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "daylight"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "dusk-dawn") == 0) //added + { + new_scene_mode = SecCamera::SCENE_MODE_DUSK_DAWN; + + mParameters.set("iso", "auto"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "fluorescent"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "fall-color") == 0) //added + { + new_scene_mode = SecCamera::SCENE_MODE_FALL_COLOR; + + mParameters.set("iso", "auto"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_PLUS_2); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "night") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_NIGHTSHOT; + + mParameters.set("iso", "night"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "back-light") == 0) //added + { + const char * flash_mode_str = params.get("flash-mode"); + + new_scene_mode = SecCamera::SCENE_MODE_BACK_LIGHT; + + mParameters.set("iso", "auto"); + if(strcmp(flash_mode_str, "off") == 0) + mParameters.set("metering", "spot"); + else + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "auto"); + } + else if(strcmp(new_scene_mode_str, "fireworks") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_FIREWORKS; + + mParameters.set("iso", "50"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else if(strcmp(new_scene_mode_str, "text") == 0) //added + { + new_scene_mode = SecCamera::SCENE_MODE_TEXT; + + mParameters.set("iso", "auto"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "auto"); + mParameters.set("sharpness", SecCamera::SHARPNESS_PLUS_2); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "macro"); + } + else if(strcmp(new_scene_mode_str, "candlelight") == 0) + { + new_scene_mode = SecCamera::SCENE_MODE_CANDLE_LIGHT; + + mParameters.set("iso", "auto"); + mParameters.set("metering", "center"); + mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, SecCamera::BRIGHTNESS_NORMAL); + mParameters.set("whitebalance", "daylight"); + mParameters.set("sharpness", SecCamera::SHARPNESS_NORMAL); + mParameters.set("saturation", SecCamera::SATURATION_NORMAL); + mParameters.set("focus-mode", "auto"); + mParameters.set("flash-mode", "off"); + } + else + { + LOGE("%s::unmatched scene_mode(%s)", __FUNCTION__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto + ret = UNKNOWN_ERROR; + } + + new_iso_str = mParameters.get("iso"); + new_metering_str = mParameters.get("metering"); + new_exposure_compensation = mParameters.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); + new_white_str = mParameters.get("whitebalance"); + new_sharpness = mParameters.getInt("sharpness"); + new_saturation = mParameters.getInt("saturation"); + new_focus_mode_str = mParameters.get("focus-mode"); + new_flash_mode_str = mParameters.get("flash-mode"); + } + + // 1. ISO + if(new_iso_str != NULL ) + { + int new_iso = -1; + if(strcmp(new_iso_str, "auto") == 0) + new_iso = SecCamera::ISO_AUTO; + else if(strcmp(new_iso_str, "50") == 0) + new_iso = SecCamera::ISO_50; + else if(strcmp(new_iso_str, "100") == 0) + new_iso = SecCamera::ISO_100; + else if(strcmp(new_iso_str, "200") == 0) + new_iso = SecCamera::ISO_200; + else if(strcmp(new_iso_str, "400") == 0) + new_iso = SecCamera::ISO_400; + else if(strcmp(new_iso_str, "800") == 0) + new_iso = SecCamera::ISO_800; + else if(strcmp(new_iso_str, "1600") == 0) + new_iso = SecCamera::ISO_1600; + else if(strcmp(new_iso_str, "sports") == 0) + new_iso = SecCamera::ISO_SPORTS; + else if(strcmp(new_iso_str, "night") == 0) + new_iso = SecCamera::ISO_NIGHT; + else if(strcmp(new_iso_str, "movie") == 0) + new_iso = SecCamera::ISO_MOVIE; + else + { + LOGE("%s::unmatched iso(%d)", __FUNCTION__, new_iso); + ret = UNKNOWN_ERROR; + } + if(0 <= new_iso) + { + if(mSecCamera->setISO(new_iso) < 0) + { + LOGE("%s::mSecCamera->setISO(%d) fail", __FUNCTION__, new_iso); + ret = UNKNOWN_ERROR; + } + } + } + + // 2. metering + if(new_metering_str != NULL ) + { + int new_metering = -1; + if(strcmp(new_metering_str, "matrix") == 0) + new_metering = SecCamera::METERING_MATRIX; + else if(strcmp(new_metering_str, "center") == 0) + new_metering = SecCamera::METERING_CENTER; + else if(strcmp(new_metering_str, "spot") == 0) + new_metering = SecCamera::METERING_SPOT; + else + { + LOGE("%s::unmatched metering(%s)", __FUNCTION__, new_metering_str); + ret = UNKNOWN_ERROR; + } + if(0 <= new_metering) + { + if(mSecCamera->setMetering(new_metering) < 0) + { + LOGE("%s::mSecCamera->setMetering(%d) fail", __FUNCTION__, new_metering); + ret = UNKNOWN_ERROR; + } + } + } + + // 3. brightness + int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION); + int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_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))", __FUNCTION__, new_exposure_compensation); + ret = UNKNOWN_ERROR; + } + + } + + // 4. whitebalance + if(new_white_str != NULL) + { + int new_white = -1; + + if(strcmp(new_white_str, "auto") == 0) + new_white = SecCamera::WHITE_BALANCE_AUTO; + else if(strcmp(new_white_str, "daylight") == 0) + new_white = SecCamera::WHITE_BALANCE_DAYLIGHT; + else if((strcmp(new_white_str, "cloudy") == 0) || (strcmp(new_white_str, "cloudy-daylight") == 0)) + new_white = SecCamera::WHITE_BALANCE_CLOUDY; + else if(strcmp(new_white_str, "fluorescent") == 0) + new_white = SecCamera::WHITE_BALANCE_FLUORESCENT; + else if(strcmp(new_white_str, "incandescent") == 0) + new_white = SecCamera::WHITE_BALANCE_INCANDESCENT; + else + { + LOGE("ERR(%s):Invalid white balance(%s)", __FUNCTION__, new_white_str); //twilight, shade, warm_flourescent + ret = UNKNOWN_ERROR; + } + + if(0 <= new_white) + { + // white_balance + if(mSecCamera->setWhiteBalance(new_white) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __FUNCTION__, new_white); + ret = UNKNOWN_ERROR; + } + } + } + + //5. sharpness + if(0 <= new_sharpness) + { + if(mSecCamera->setSharpness(new_sharpness) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setSharpness(%d)", __FUNCTION__,new_sharpness); + ret = UNKNOWN_ERROR; + } + } + + //6. saturation + if(0 <= new_saturation) + { + if(mSecCamera->setSaturation(new_saturation) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setSaturation(%d)", __FUNCTION__, new_saturation); + ret = UNKNOWN_ERROR; + } + } + + // 7. focus mode + if(new_focus_mode_str != NULL) + { + int new_focus_mode = -1; + + if((strcmp(new_focus_mode_str, "auto") == 0) || (strcmp(new_focus_mode_str, "fixed") == 0) ||(strcmp(new_focus_mode_str, "infinity") == 0)) + new_focus_mode = SecCamera::FOCUS_MODE_AUTO; + else if(strcmp(new_focus_mode_str, "macro") == 0) + new_focus_mode = SecCamera::FOCUS_MODE_MACRO; + else if(strcmp(new_focus_mode_str, "facedetect") == 0) + new_focus_mode = SecCamera::FOCUS_MODE_FACEDETECT; + else + { + LOGE("%s::unmatched focus_mode(%s)", __FUNCTION__, new_focus_mode_str); //infinity + ret = UNKNOWN_ERROR; + } + + if(0 <= new_focus_mode) + { + if(mSecCamera->setFocusMode(new_focus_mode) < 0) + { + LOGE("%s::mSecCamera->setFocusMode(%d) fail", __FUNCTION__, new_focus_mode); + ret = UNKNOWN_ERROR; + } + } + } + + // 8. flash.. + if(new_flash_mode_str != NULL ) + { + int new_flash_mode = -1; + if(strcmp(new_flash_mode_str, "off") == 0) + new_flash_mode = SecCamera::FLASH_MODE_OFF; + else if(strcmp(new_flash_mode_str, "auto") == 0) + new_flash_mode = SecCamera::FLASH_MODE_AUTO; + else if(strcmp(new_flash_mode_str, "on") == 0) + new_flash_mode = SecCamera::FLASH_MODE_ON; + else if(strcmp(new_flash_mode_str, "torch") == 0) + new_flash_mode = SecCamera::FLASH_MODE_TORCH; + else + { + LOGE("%s::unmatched flash_mode(%s)", __FUNCTION__, 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", __FUNCTION__, new_flash_mode); + ret = UNKNOWN_ERROR; + } + } + } + + // 9. scene.. + if(0 <= new_scene_mode) + { + if(mSecCamera->setSceneMode(new_scene_mode) < 0) + { + LOGE("%s::mSecCamera->setSceneMode(%d) fail", __FUNCTION__, new_scene_mode); + ret = UNKNOWN_ERROR; + } + } + } + +// --------------------------------------------------------------------------- + + // image effect + const char * new_image_effect_str = params.get("effect"); + if(new_image_effect_str != NULL) + { + int new_image_effect = -1; + + if((strcmp(new_image_effect_str, "auto") == 0) || (strcmp(new_image_effect_str, "none") == 0)) + new_image_effect = SecCamera::IMAGE_EFFECT_NONE; + else if((strcmp(new_image_effect_str, "bnw") == 0) || (strcmp(new_image_effect_str, "mono") == 0)) + new_image_effect = SecCamera::IMAGE_EFFECT_BNW; + else if(strcmp(new_image_effect_str, "sepia") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_SEPIA; + else if(strcmp(new_image_effect_str, "aqua") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_AQUA; + else if(strcmp(new_image_effect_str, "antique") == 0) //added at samsung + new_image_effect = SecCamera::IMAGE_EFFECT_ANTIQUE; + else if(strcmp(new_image_effect_str, "negative") == 0) + new_image_effect = SecCamera::IMAGE_EFFECT_NEGATIVE; + else if(strcmp(new_image_effect_str, "sharpen") == 0) //added at samsung + new_image_effect = SecCamera::IMAGE_EFFECT_SHARPEN; + else + { + LOGE("ERR(%s):Invalid effect(%s)", __FUNCTION__, new_image_effect_str); //posterize, whiteboard, blackboard, solarize + ret = UNKNOWN_ERROR; + } + + if(new_image_effect >= 0) + { + if(mSecCamera->setImageEffect(new_image_effect) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __FUNCTION__, new_image_effect); + ret = UNKNOWN_ERROR; + } + } + } + + //antiBanding + const char * new_antibanding_str = params.get("antibanding"); + if(new_antibanding_str != NULL) + { + int new_antibanding = -1; + + if(strcmp(new_antibanding_str,"auto") == 0) + new_antibanding = SecCamera::ANTI_BANDING_AUTO; + else if(strcmp(new_antibanding_str,"50hz") == 0) + new_antibanding = SecCamera::ANTI_BANDING_50HZ; + else if(strcmp(new_antibanding_str,"60hz") == 0) + new_antibanding = SecCamera::ANTI_BANDING_60HZ; + else if(strcmp(new_antibanding_str,"off") == 0) + new_antibanding = SecCamera::ANTI_BANDING_OFF; + else + { + LOGE("%s::unmatched antibanding(%s)", __FUNCTION__, new_antibanding_str); + ret = UNKNOWN_ERROR; + } + + if(0 <= new_antibanding) + { + if(mSecCamera->setAntiBanding(new_antibanding) < 0) + { + LOGE("%s::mSecCamera->setAntiBanding(%d) fail", __FUNCTION__, new_antibanding); + ret = UNKNOWN_ERROR; + } + } + + } + + //contrast + int new_contrast = params.getInt("contrast"); + if(0 <= new_contrast) + { + if(mSecCamera->setContrast(new_contrast) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setContrast(%d)", __FUNCTION__, new_contrast); + ret = UNKNOWN_ERROR; + } + } + + //WDR + int new_wdr = params.getInt("wdr"); + if(0 <= new_wdr) + { + if(mSecCamera->setWDR(new_wdr) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __FUNCTION__, new_wdr); + ret = UNKNOWN_ERROR; + } + } + + //anti shake + int new_anti_shake = params.getInt("anti-shake"); + if(0 <= new_anti_shake) + { + if(mSecCamera->setAntiShake(new_anti_shake) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __FUNCTION__, new_anti_shake); + ret = UNKNOWN_ERROR; + } + } + + //zoom + int new_zoom_level = params.getInt(CameraParameters::KEY_ZOOM); + if(0 <= new_zoom_level) + { + if(mSecCamera->setZoom(new_zoom_level) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setZoom(%d)", __FUNCTION__, new_zoom_level); + ret = UNKNOWN_ERROR; + } + } + + //object tracking + int new_obj_tracking = params.getInt("obj-tracking"); + if(0 <= new_obj_tracking) + { + if(mSecCamera->setObjectTracking(new_obj_tracking) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setObjectTracking(%d)", __FUNCTION__, new_obj_tracking); + ret = UNKNOWN_ERROR; + } + } + + // smart auto + int new_smart_auto = params.getInt("smart-auto"); + if(0 <= new_smart_auto) + { + if(mSecCamera->setSmartAuto(new_smart_auto) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setSmartAuto(%d)", __FUNCTION__, new_smart_auto); + ret = UNKNOWN_ERROR; + } + + //smart auto on => start Smartautoscene Thread + if(mSecCamera->getSmartAuto() == 1) + { + if(startSmartautoscene() == INVALID_OPERATION) + { + LOGE("Smartautoscene thread is already running"); + } + else + LOGE("Smartautoscene thread start"); + } + //smart auto off => stop Smartautoscene Thread + else + { + if(mSmartautosceneRunning == true) + { + stopSmartautoscene(); + LOGV("Smartautoscene thread stop"); + } + else + LOGV("Smartautoscene thread was already stop"); + } + } + + // beauty_shot + int new_beauty_shot = params.getInt("face_beauty"); + if(0 <= new_beauty_shot) + { + if(mSecCamera->setBeautyShot(new_beauty_shot) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setBeautyShot(%d)", __FUNCTION__, new_beauty_shot); + ret = UNKNOWN_ERROR; + } + } + + // vintage mode + const char * new_vintage_mode_str = params.get("vintagemode"); + if(new_vintage_mode_str != NULL) + { + int new_vintage_mode = -1; + + if(strcmp(new_vintage_mode_str, "off") == 0) + new_vintage_mode = SecCamera::VINTAGE_MODE_OFF; + else if(strcmp(new_vintage_mode_str, "normal") == 0) + new_vintage_mode = SecCamera::VINTAGE_MODE_NORMAL; + else if(strcmp(new_vintage_mode_str, "warm") == 0) + new_vintage_mode = SecCamera::VINTAGE_MODE_WARM; + else if(strcmp(new_vintage_mode_str, "cool") == 0) + new_vintage_mode = SecCamera::VINTAGE_MODE_COOL; + else if(strcmp(new_vintage_mode_str, "bnw") == 0) + new_vintage_mode = SecCamera::VINTAGE_MODE_BNW; + else + { + LOGE("%s::unmatched vintage_mode(%d)", __FUNCTION__, new_vintage_mode); + ret = UNKNOWN_ERROR; + } + + if(0 <= new_vintage_mode) + { + if(mSecCamera->setVintageMode(new_vintage_mode) < 0) + { + LOGE("%s::mSecCamera->setVintageMode(%d) fail", __FUNCTION__, new_vintage_mode); + ret = UNKNOWN_ERROR; + } + } + } + + // gps latitude + const char * new_gps_latitude_str = params.get("gps-latitude"); + if(mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) + { + LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __FUNCTION__, new_gps_latitude_str); + ret = UNKNOWN_ERROR; + } + + // gps longitude + const char * new_gps_longitute_str = params.get("gps-longitude"); + if(mSecCamera->setGPSLongitude(new_gps_longitute_str) < 0) + { + LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __FUNCTION__, new_gps_longitute_str); + ret = UNKNOWN_ERROR; + } + + // gps altitude + const char * new_gps_altitude_str = params.get("gps-altitude"); + if(mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) + { + LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __FUNCTION__, new_gps_altitude_str); + ret = UNKNOWN_ERROR; + } + + // gps timestamp + const char * new_gps_timestamp_str = params.get("gps-timestamp"); + if(mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) + { + LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __FUNCTION__, new_gps_timestamp_str); + ret = UNKNOWN_ERROR; + } + + // Recording size + int new_recording_width = params.getInt("recording-size-width"); + int new_recording_height= params.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))", __FUNCTION__, 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))", __FUNCTION__, new_preview_width, new_preview_height); + ret = UNKNOWN_ERROR; + } + } + + //gamma + const char * new_gamma_str = params.get("video_recording_gamma"); + if(new_gamma_str != NULL) + { + int new_gamma = -1; + + if(strcmp(new_gamma_str, "off") == 0) + new_gamma = SecCamera::GAMMA_OFF; + else if(strcmp(new_gamma_str, "on") == 0) + new_gamma = SecCamera::GAMMA_ON; + else + { + LOGE("%s::unmatched gamma(%s)", __FUNCTION__, new_gamma_str); + ret = UNKNOWN_ERROR; + } + + if(0 <= new_gamma) + { + if(mSecCamera->setGamma(new_gamma) < 0) + { + LOGE("%s::mSecCamera->setGamma(%d) fail", __FUNCTION__, new_gamma); + ret = UNKNOWN_ERROR; + } + } + } + + //slow ae + const char * new_slow_ae_str = params.get("slow_ae"); + if(new_slow_ae_str != NULL) + { + int new_slow_ae = -1; + + if(strcmp(new_slow_ae_str, "off") == 0) + new_slow_ae = SecCamera::SLOW_AE_OFF; + else if(strcmp(new_slow_ae_str, "on") == 0) + new_slow_ae = SecCamera::SLOW_AE_ON; + else + { + LOGE("%s::unmatched slow_ae(%s)", __FUNCTION__, 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", __FUNCTION__, new_slow_ae); + ret = UNKNOWN_ERROR; + } + } + } + + //exif orientation info + int new_exif_orientation = params.getInt("exifOrientation"); //kidggang + if(0 <= new_exif_orientation) + { + if(mSecCamera->setExifOrientationInfo(new_exif_orientation) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __FUNCTION__, new_exif_orientation); + ret = UNKNOWN_ERROR; + } + } + + /*Camcorder fix fps*/ + int new_sensor_mode = params.getInt("cam_mode"); + if(0 <= new_sensor_mode) + { + if(mSecCamera->setSensorMode(new_sensor_mode) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __FUNCTION__, new_sensor_mode); + ret = UNKNOWN_ERROR; + } + } + else + { + new_sensor_mode=0; + } + + /*Shot mode*/ + int new_shot_mode = params.getInt("shot_mode"); + if(0 <= new_shot_mode) + { + if(mSecCamera->setShotMode(new_shot_mode) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __FUNCTION__, new_shot_mode); + ret = UNKNOWN_ERROR; + } + } + else + { + new_shot_mode=0; + } + + //blur for Video call + int new_blur_level = params.getInt("blur"); + if(0 <= new_blur_level) + { + if(mSecCamera->setBlur(new_blur_level) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setBlur(%d)", __FUNCTION__, new_blur_level); + ret = UNKNOWN_ERROR; + } + } + + + // chk_dataline + int new_dataline = params.getInt("chk_dataline"); + if(0 <= new_dataline) + { + if(mSecCamera->setDataLineCheck(new_dataline) < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __FUNCTION__, new_dataline); + ret = UNKNOWN_ERROR; + } + } + + //Batch Command + if(new_camera_id == SecCamera::CAMERA_ID_BACK) + { + if(mSecCamera->setBatchReflection() < 0) + { + LOGE("ERR(%s):Fail on mSecCamera->setBatchCmd", __FUNCTION__); + ret = UNKNOWN_ERROR; + } + } +#endif + + return ret; +} + +CameraParameters CameraHardwareSec::getParameters() const +{ + LOGV("%s()", __FUNCTION__); + Mutex::Autolock lock(mLock); + return mParameters; +} + +status_t CameraHardwareSec::sendCommand(int32_t command, int32_t arg1, int32_t arg2) +{ +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + LOGV("%s() : command = %d, arg1 =%d, arg2= %d", __FUNCTION__,command, arg1, arg2); + switch(command) + { + case COMMAND_AE_AWB_LOCK_UNLOCK: + mSecCamera->setAEAWBLockUnlock(arg1, arg2); + break; + case COMMAND_FACE_DETECT_LOCK_UNLOCK: + mSecCamera->setFaceDetectLockUnlock(arg1); + break; + case COMMAND_OBJECT_POSITION: + mSecCamera->setObjectPosition(arg1, arg2); + break; + case COMMAND_OBJECT_TRACKING_STARTSTOP: + mSecCamera->setObjectTrackingStartStop(arg1); + objectTracking(arg1); + break; + case CONTINUOUS_SHOT_START_CAPTURE: + break; + case CONTINUOUS_SHOT_STOP_AND_ENCODING: + mSecCamera->setAEAWBLockUnlock(arg1, arg2); + LOGV("Continuous shot command received"); + break; + case COMMAND_TOUCH_AF_STARTSTOP: + mSecCamera->setTouchAFStartStop(arg1); + break; + case COMMAND_CHECK_DATALINE: + mSecCamera->setDataLineCheckStop(); + break; + case COMMAND_DEFAULT_IMEI: + mSecCamera->setDefultIMEI(arg1); + break; + defualt: + LOGV("%s()", __FUNCTION__); + break; + } + + return NO_ERROR; +#else + return BAD_VALUE; +#endif +} + +void CameraHardwareSec::release() +{ + LOGV("%s()", __FUNCTION__); +} + +wp<CameraHardwareInterface> CameraHardwareSec::singleton; + +sp<CameraHardwareInterface> CameraHardwareSec::createInstance() +{ + LOGV("%s()", __FUNCTION__); + if (singleton != 0) { + sp<CameraHardwareInterface> hardware = singleton.promote(); + if (hardware != 0) { + return hardware; + } + } + sp<CameraHardwareInterface> hardware(new CameraHardwareSec()); + singleton = hardware; + return hardware; +} +#if 0 +extern "C" sp<CameraHardwareInterface> openCameraHardware() +{ + LOGV("%s()", __FUNCTION__); + return CameraHardwareSec::createInstance(); +} +#endif + +static CameraInfo sCameraInfo[] = { + { + CAMERA_FACING_BACK, + 90, /* orientation */ + } +}; + +extern "C" int HAL_getNumberOfCameras() +{ + return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]); +} + +extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo) +{ + memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo)); +} + +extern "C" sp<CameraHardwareInterface> HAL_openCameraHardware(int cameraId) +{ + return CameraHardwareSec::createInstance(); +} + +}; // namespace android diff --git a/libcamera/SecCameraHWInterface.h b/libcamera/SecCameraHWInterface.h new file mode 100644 index 0000000..9e4fb79 --- /dev/null +++ b/libcamera/SecCameraHWInterface.h @@ -0,0 +1,257 @@ +/* +** +** Copyright 2008, The Android Open Source Project +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +#ifndef ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H +#define ANDROID_HARDWARE_CAMERA_HARDWARE_SEC_H + +#include "SecCamera.h" +#include <utils/threads.h> +#include <camera/CameraHardwareInterface.h> +#include <binder/MemoryBase.h> +#include <binder/MemoryHeapBase.h> +#include <utils/threads.h> + +namespace android { +class CameraHardwareSec : public CameraHardwareInterface { +public: + virtual sp<IMemoryHeap> getPreviewHeap() const; + virtual sp<IMemoryHeap> getRawHeap() const; + +//Kamat --eclair + virtual void setCallbacks(notify_callback notify_cb, + data_callback data_cb, + data_callback_timestamp data_cb_timestamp, + void* user); + + virtual void enableMsgType(int32_t msgType); + virtual void disableMsgType(int32_t msgType); + virtual bool msgTypeEnabled(int32_t msgType); + + virtual status_t startPreview(); + virtual void stopPreview(); + virtual bool previewEnabled(); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + virtual status_t startSmartautoscene(); + virtual void stopSmartautoscene(); + virtual bool smartautosceneEnabled(); +#endif + + virtual status_t startRecording(); + virtual void stopRecording(); + virtual bool recordingEnabled(); + virtual void releaseRecordingFrame(const sp<IMemory>& mem); + + virtual status_t autoFocus(); + virtual status_t cancelAutoFocus(); + virtual status_t takePicture(); + virtual status_t cancelPicture(); + virtual status_t dump(int fd, const Vector<String16>& args) const; + virtual status_t setParameters(const CameraParameters& params); + virtual CameraParameters getParameters() const; + virtual status_t sendCommand(int32_t command, int32_t arg1, + int32_t arg2); + virtual void release(); + + static sp<CameraHardwareInterface> createInstance(); + +private: + CameraHardwareSec(); + virtual ~CameraHardwareSec(); + + static wp<CameraHardwareInterface> singleton; + + static const int kBufferCount = MAX_BUFFERS; + static const int kBufferCountForRecord = MAX_BUFFERS; + + class PreviewThread : public Thread { + CameraHardwareSec* mHardware; + public: + PreviewThread(CameraHardwareSec* hw): +#ifdef SINGLE_PROCESS + // In single process mode this thread needs to be a java thread, + // since we won't be calling through the binder. + Thread(true), +#else + Thread(false), +#endif + mHardware(hw) { } + virtual void onFirstRef() { + run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY); + } + virtual bool threadLoop() { + int ret = mHardware->previewThread(); + // loop until we need to quit + if(ret == NO_ERROR) + return true; + else + return false; + } + }; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + class SmartautosceneThread : public Thread { + CameraHardwareSec* mHardware; + public: + SmartautosceneThread(CameraHardwareSec* hw): +#ifdef SINGLE_PROCESS + // In single process mode this thread needs to be a java thread, + // since we won't be calling through the binder. + Thread(true), +#else + Thread(false), +#endif + mHardware(hw) { } + virtual void onFirstRef() { + run("CameraSmartautosceneThread", PRIORITY_URGENT_DISPLAY); + } + virtual bool threadLoop() { + int ret = mHardware->smartautosceneThread(); + // loop until we need to quit + if(ret == NO_ERROR) + return true; + else + return false; + } + }; +#endif + void initDefaultParameters(); + void initHeapLocked(); + + int previewThread(); +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + int smartautosceneThread(); +#endif + + static int beginAutoFocusThread(void *cookie); + int autoFocusThread(); + + static int beginPictureThread(void *cookie); + int pictureThread(); + 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); + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + static int beginObjectTrackingThread(void *cookie); + int objectTrackingThread(); + status_t objectTracking(int onoff); +#endif + + mutable Mutex mLock; + + CameraParameters mParameters; + + sp<MemoryHeapBase> mPreviewHeap; + sp<MemoryHeapBase> mRawHeap; + sp<MemoryHeapBase> mRecordHeap; + sp<MemoryHeapBase> mJpegHeap; + sp<MemoryBase> mBuffers[kBufferCount]; + sp<MemoryBase> mRecordBuffers[kBufferCountForRecord]; + + SecCamera *mSecCamera; + bool mPreviewRunning; + int mPreviewFrameSize; + int mRawFrameSize; + int mPreviewFrameRateMicrosec; + + + // protected by mLock + sp<PreviewThread> mPreviewThread; +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + sp<SmartautosceneThread> mSmartautosceneThread; +#endif + notify_callback mNotifyCb; + data_callback mDataCb; + data_callback_timestamp mDataCbTimestamp; + void *mCallbackCookie; + + int32_t mMsgEnabled; + + // only used from PreviewThread + int mCurrentPreviewFrame; + int mCurrentRecordFrame; + + bool mRecordRunning; +#ifdef JPEG_FROM_SENSOR + int mPostViewWidth; + int mPostViewHeight; + int mPostViewSize; +#endif + + int mNoHwHandle; + struct timeval mTimeStart; + struct timeval mTimeStop; + +#ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION + enum COMMAND_DEFINE + { + COMMAND_AE_AWB_LOCK_UNLOCK = 1101, + COMMAND_FACE_DETECT_LOCK_UNLOCK = 1102, + COMMAND_OBJECT_POSITION = 1103, + COMMAND_OBJECT_TRACKING_STARTSTOP = 1104, + COMMAND_TOUCH_AF_STARTSTOP = 1105, + COMMAND_CHECK_DATALINE = 1106, + CONTINUOUS_SHOT_START_CAPTURE = 1023, + CONTINUOUS_SHOT_STOP_AND_ENCODING = 1024, + COMMAND_DEFAULT_IMEI = 1107, + }; + +class ObjectTrackingThread : public Thread { + CameraHardwareSec* mHardware; + public: + ObjectTrackingThread(CameraHardwareSec* hw): +#ifdef SINGLE_PROCESS + // In single process mode this thread needs to be a java thread, + // since we won't be calling through the binder. + Thread(true), +#else + Thread(false), +#endif + mHardware(hw) { } + virtual void onFirstRef() { + run("CameraObjectTrackingThread", PRIORITY_URGENT_DISPLAY); + } + virtual bool threadLoop() { + int ret = mHardware->objectTrackingThread(); + // loop until we need to quit + if(ret == NO_ERROR) + return true; + else + return false; + } + }; + bool mObjectTrackingRunning; + sp<ObjectTrackingThread> mObjectTrackingThread; + int mObjectTrackingStatus; + + bool mSmartautosceneRunning; + int mSmartautoscene_current_status; + int mSmartautoscene_previous_status; + int af_thread_status; +#endif +}; + +}; // namespace android + +#endif |