/libcamera/SecCamera.cpp
C++ | 3191 lines | 2399 code | 603 blank | 189 comment | 454 complexity | 0c8e951b9605131b7260588ccd81c035 MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- /*
- * Copyright 2008, The Android Open Source Project
- * Copyright 2010, Samsung Electronics Co. LTD
- * Copyright 2011, The CyanogenMod 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.
- */
- /*
- ************************************
- * Filename: SecCamera.cpp
- * Author: Sachin P. Kamat
- * Purpose: This file interacts with the Camera and JPEG drivers.
- *************************************
- */
- //#define LOG_NDEBUG 0
- #define LOG_TAG "SecCamera"
- #include <utils/Log.h>
- #include <math.h>
- #include <string.h>
- #include <stdlib.h>
- #include <sys/poll.h>
- #include "SecCamera.h"
- #include "cutils/properties.h"
- using namespace android;
- #define CHECK(return_value) \
- if (return_value < 0) { \
- ALOGE("%s::%d fail. errno: %s, m_camera_id = %d\n", \
- __func__, __LINE__, strerror(errno), m_camera_id); \
- return -1; \
- }
- #define CHECK_PTR(return_value) \
- if (return_value < 0) { \
- ALOGE("%s::%d fail, errno: %s, m_camera_id = %d\n", \
- __func__,__LINE__, strerror(errno), m_camera_id); \
- return NULL; \
- }
- #define ALIGN_TO_32B(x) ((((x) + (1 << 5) - 1) >> 5) << 5)
- #define ALIGN_TO_128B(x) ((((x) + (1 << 7) - 1) >> 7) << 7)
- #define ALIGN_TO_8KB(x) ((((x) + (1 << 13) - 1) >> 13) << 13)
- namespace android {
- // ======================================================================
- // Camera controls
- static struct timeval time_start;
- static struct timeval time_stop;
- unsigned long measure_time(struct timeval *start, struct timeval *stop)
- {
- unsigned long sec, usec, time;
- sec = stop->tv_sec - start->tv_sec;
- if (stop->tv_usec >= start->tv_usec) {
- usec = stop->tv_usec - start->tv_usec;
- } else {
- usec = stop->tv_usec + 1000000 - start->tv_usec;
- sec--;
- }
- time = (sec * 1000000) + usec;
- return time;
- }
- static int get_pixel_depth(unsigned int fmt)
- {
- int depth = 0;
- switch (fmt) {
- case V4L2_PIX_FMT_NV12:
- depth = 12;
- break;
- case V4L2_PIX_FMT_NV12T:
- depth = 12;
- break;
- case V4L2_PIX_FMT_NV21:
- depth = 12;
- break;
- case V4L2_PIX_FMT_YUV420:
- depth = 12;
- break;
- case V4L2_PIX_FMT_RGB565:
- case V4L2_PIX_FMT_YUYV:
- case V4L2_PIX_FMT_YVYU:
- case V4L2_PIX_FMT_UYVY:
- case V4L2_PIX_FMT_VYUY:
- case V4L2_PIX_FMT_NV16:
- case V4L2_PIX_FMT_NV61:
- case V4L2_PIX_FMT_YUV422P:
- depth = 16;
- break;
- case V4L2_PIX_FMT_RGB32:
- depth = 32;
- break;
- }
- return depth;
- }
- #define ALIGN_W(x) (((x) + 0x7F) & (~0x7F)) // Set as multiple of 128
- #define ALIGN_H(x) (((x) + 0x1F) & (~0x1F)) // Set as multiple of 32
- #define ALIGN_BUF(x) (((x) + 0x1FFF)& (~0x1FFF)) // Set as multiple of 8K
- static int fimc_poll(struct pollfd *events)
- {
- int ret;
- /* 10 second delay is because sensor can take a long time
- * to do auto focus and capture in dark settings
- */
- ret = poll(events, 1, 10000);
- if (ret < 0) {
- ALOGE("ERR(%s):poll error\n", __func__);
- return ret;
- }
- if (ret == 0) {
- ALOGE("ERR(%s):No data in 10 secs..\n", __func__);
- return ret;
- }
- return ret;
- }
- int SecCamera::previewPoll(bool preview)
- {
- int ret;
- if (preview) {
- #ifdef ENABLE_ESD_PREVIEW_CHECK
- int status = 0;
- if (!(++m_esd_check_count % 60)) {
- status = getCameraSensorESDStatus();
- m_esd_check_count = 0;
- if (status) {
- ALOGE("ERR(%s) ESD status(%d)", __func__, status);
- return status;
- }
- }
- #endif
- ret = poll(&m_events_c, 1, 1000);
- } else {
- ret = poll(&m_events_c2, 1, 1000);
- }
- if (ret < 0) {
- ALOGE("ERR(%s):poll error\n", __func__);
- return ret;
- }
- if (ret == 0) {
- ALOGE("ERR(%s):No data in 1 secs.. Camera Device Reset \n", __func__);
- return ret;
- }
- return ret;
- }
- static int fimc_v4l2_querycap(int fp)
- {
- struct v4l2_capability cap;
- int ret = 0;
- ret = ioctl(fp, VIDIOC_QUERYCAP, &cap);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_QUERYCAP failed\n", __func__);
- return -1;
- }
- if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
- ALOGE("ERR(%s):no capture devices\n", __func__);
- return -1;
- }
- return ret;
- }
- static const __u8* fimc_v4l2_enuminput(int fp, int index)
- {
- static struct v4l2_input input;
- input.index = index;
- if (ioctl(fp, VIDIOC_ENUMINPUT, &input) != 0) {
- ALOGE("ERR(%s):No matching index found\n", __func__);
- return NULL;
- }
- ALOGI("Name of input channel[%d] is %s\n", input.index, input.name);
- return input.name;
- }
- static int fimc_v4l2_s_input(int fp, int index)
- {
- struct v4l2_input input;
- int ret;
- input.index = index;
- ret = ioctl(fp, VIDIOC_S_INPUT, &input);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_S_INPUT failed\n", __func__);
- return ret;
- }
- return ret;
- }
- static int fimc_v4l2_s_fmt(int fp, int width, int height, unsigned int fmt, int flag_capture)
- {
- struct v4l2_format v4l2_fmt;
- struct v4l2_pix_format pixfmt;
- int ret;
- v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- memset(&pixfmt, 0, sizeof(pixfmt));
- pixfmt.width = width;
- pixfmt.height = height;
- pixfmt.pixelformat = fmt;
- pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8;
- pixfmt.field = V4L2_FIELD_NONE;
- v4l2_fmt.fmt.pix = pixfmt;
- /* Set up for capture */
- ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__);
- return -1;
- }
- return 0;
- }
- static int fimc_v4l2_s_fmt_cap(int fp, int width, int height, unsigned int fmt)
- {
- struct v4l2_format v4l2_fmt;
- struct v4l2_pix_format pixfmt;
- int ret;
- memset(&pixfmt, 0, sizeof(pixfmt));
- v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- pixfmt.width = width;
- pixfmt.height = height;
- pixfmt.pixelformat = fmt;
- if (fmt == V4L2_PIX_FMT_JPEG) {
- pixfmt.colorspace = V4L2_COLORSPACE_JPEG;
- }
- pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8;
- v4l2_fmt.fmt.pix = pixfmt;
- //ALOGE("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) {
- ALOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__);
- return ret;
- }
- return ret;
- }
- static int fimc_v4l2_enum_fmt(int fp, unsigned int fmt)
- {
- struct v4l2_fmtdesc fmtdesc;
- int found = 0;
- fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- fmtdesc.index = 0;
- while (ioctl(fp, VIDIOC_ENUM_FMT, &fmtdesc) == 0) {
- if (fmtdesc.pixelformat == fmt) {
- ALOGV("passed fmt = %#x found pixel format[%d]: %s\n", fmt, fmtdesc.index, fmtdesc.description);
- found = 1;
- break;
- }
- fmtdesc.index++;
- }
- if (!found) {
- ALOGE("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) {
- ALOGE("ERR(%s):VIDIOC_REQBUFS failed\n", __func__);
- return -1;
- }
- return req.count;
- }
- static int fimc_v4l2_querybuf(int fp, struct fimc_buffer *buffer, enum v4l2_buf_type type)
- {
- struct v4l2_buffer v4l2_buf;
- int ret;
- ALOGI("%s :", __func__);
- v4l2_buf.type = type;
- v4l2_buf.memory = V4L2_MEMORY_MMAP;
- v4l2_buf.index = 0;
- ret = ioctl(fp , VIDIOC_QUERYBUF, &v4l2_buf);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_QUERYBUF failed\n", __func__);
- return -1;
- }
- buffer->length = v4l2_buf.length;
- if ((buffer->start = (char *)mmap(0, v4l2_buf.length,
- PROT_READ | PROT_WRITE, MAP_SHARED,
- fp, v4l2_buf.m.offset)) < 0) {
- ALOGE("%s %d] mmap() failed\n",__func__, __LINE__);
- return -1;
- }
- ALOGI("%s: buffer->start = %p v4l2_buf.length = %d",
- __func__, buffer->start, v4l2_buf.length);
- return 0;
- }
- static int fimc_v4l2_streamon(int fp)
- {
- enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- int ret;
- ret = ioctl(fp, VIDIOC_STREAMON, &type);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_STREAMON failed\n", __func__);
- return ret;
- }
- return ret;
- }
- static int fimc_v4l2_streamoff(int fp)
- {
- enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- int ret;
- ALOGV("%s :", __func__);
- ret = ioctl(fp, VIDIOC_STREAMOFF, &type);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_STREAMOFF failed\n", __func__);
- return ret;
- }
- return ret;
- }
- static int fimc_v4l2_qbuf(int fp, int index)
- {
- struct v4l2_buffer v4l2_buf;
- int ret;
- v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- v4l2_buf.memory = V4L2_MEMORY_MMAP;
- v4l2_buf.index = index;
- ret = ioctl(fp, VIDIOC_QBUF, &v4l2_buf);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_QBUF failed\n", __func__);
- return ret;
- }
- return 0;
- }
- static int fimc_v4l2_dqbuf(int fp)
- {
- struct v4l2_buffer v4l2_buf;
- int ret;
- v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- v4l2_buf.memory = V4L2_MEMORY_MMAP;
- ret = ioctl(fp, VIDIOC_DQBUF, &v4l2_buf);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame\n", __func__);
- return ret;
- }
- return v4l2_buf.index;
- }
- static int fimc_v4l2_g_ctrl(int fp, unsigned int id)
- {
- struct v4l2_control ctrl;
- int ret;
- ctrl.id = id;
- ret = ioctl(fp, VIDIOC_G_CTRL, &ctrl);
- if (ret < 0) {
- ALOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d\n",
- __func__, id, id-V4L2_CID_PRIVATE_BASE, ret);
- return ret;
- }
- return ctrl.value;
- }
- static int fimc_v4l2_s_ctrl(int fp, unsigned int id, unsigned int value)
- {
- struct v4l2_control ctrl;
- int ret;
- ctrl.id = id;
- ctrl.value = value;
- ret = ioctl(fp, VIDIOC_S_CTRL, &ctrl);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d\n",
- __func__, id, id-V4L2_CID_PRIVATE_BASE, value, ret);
- return ret;
- }
- return ctrl.value;
- }
- static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value)
- {
- struct v4l2_ext_controls ctrls;
- struct v4l2_ext_control ctrl;
- int ret;
- ctrl.id = id;
- ctrl.string = (char *) 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)
- ALOGE("ERR(%s):VIDIOC_S_EXT_CTRLS failed\n", __func__);
- return ret;
- }
- static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm)
- {
- int ret;
- streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- ret = ioctl(fp, VIDIOC_G_PARM, streamparm);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_G_PARM failed\n", __func__);
- return -1;
- }
- ALOGV("%s : timeperframe: numerator %d, denominator %d\n", __func__,
- streamparm->parm.capture.timeperframe.numerator,
- streamparm->parm.capture.timeperframe.denominator);
- return 0;
- }
- static int fimc_v4l2_s_parm(int fp, struct v4l2_streamparm *streamparm)
- {
- int ret;
- streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
- ret = ioctl(fp, VIDIOC_S_PARM, streamparm);
- if (ret < 0) {
- ALOGE("ERR(%s):VIDIOC_S_PARM failed\n", __func__);
- return ret;
- }
- return 0;
- }
- // ======================================================================
- // Constructor & Destructor
- SecCamera::SecCamera() :
- m_flag_init(0),
- m_camera_id(CAMERA_ID_BACK),
- m_cam_fd(-1),
- m_cam_fd2(-1),
- m_preview_v4lformat(V4L2_PIX_FMT_NV21),
- m_preview_width (0),
- m_preview_height (0),
- m_preview_max_width (MAX_BACK_CAMERA_PREVIEW_WIDTH),
- m_preview_max_height (MAX_BACK_CAMERA_PREVIEW_HEIGHT),
- m_snapshot_v4lformat(-1),
- m_snapshot_width (0),
- m_snapshot_height (0),
- m_snapshot_max_width (MAX_BACK_CAMERA_SNAPSHOT_WIDTH),
- m_snapshot_max_height (MAX_BACK_CAMERA_SNAPSHOT_HEIGHT),
- m_angle(-1),
- m_anti_banding(-1),
- m_wdr(-1),
- m_anti_shake(-1),
- m_zoom_level(-1),
- m_object_tracking(-1),
- m_smart_auto(-1),
- m_beauty_shot(-1),
- m_vintage_mode(-1),
- m_face_detect(-1),
- m_gps_enabled(false),
- m_gps_latitude(-1),
- m_gps_longitude(-1),
- m_gps_altitude(-1),
- m_gps_timestamp(-1),
- m_vtmode(0),
- m_sensor_mode(-1),
- m_shot_mode(-1),
- m_exif_orientation(-1),
- m_blur_level(-1),
- m_chk_dataline(-1),
- m_video_gamma(-1),
- m_slow_ae(-1),
- m_camera_af_flag(-1),
- m_flag_camera_start(0),
- m_jpeg_thumbnail_width (0),
- m_jpeg_thumbnail_height(0),
- m_jpeg_quality(100)
- #ifdef ENABLE_ESD_PREVIEW_CHECK
- ,
- m_esd_check_count(0)
- #endif // ENABLE_ESD_PREVIEW_CHECK
- {
- m_params = (struct sec_cam_parm*)&m_streamparm.parm.raw_data;
- struct v4l2_captureparm capture;
- m_params->capture.timeperframe.numerator = 1;
- m_params->capture.timeperframe.denominator = 0;
- m_params->contrast = -1;
- m_params->effects = -1;
- m_params->brightness = -1;
- m_params->flash_mode = -1;
- m_params->focus_mode = -1;
- m_params->iso = -1;
- m_params->metering = -1;
- m_params->saturation = -1;
- m_params->scene_mode = -1;
- m_params->sharpness = -1;
- m_params->white_balance = -1;
- memset(&m_capture_buf, 0, sizeof(m_capture_buf));
- ALOGV("%s :", __func__);
- }
- SecCamera::~SecCamera()
- {
- ALOGV("%s :", __func__);
- }
- int SecCamera::initCamera(int index)
- {
- ALOGV("%s :", __func__);
- int ret = 0;
- if (!m_flag_init) {
- /* Arun C
- * Reset the lense position only during camera starts; don't do
- * reset between shot to shot
- */
- m_camera_af_flag = -1;
- m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR);
- if (m_cam_fd < 0) {
- ALOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME, strerror(errno));
- return -1;
- }
- ALOGV("%s: open(%s) --> m_cam_fd %d", __FUNCTION__, CAMERA_DEV_NAME, m_cam_fd);
- ALOGE("initCamera: m_cam_fd(%d), m_jpeg_fd(%d)", m_cam_fd, m_jpeg_fd);
- ret = fimc_v4l2_querycap(m_cam_fd);
- CHECK(ret);
- if (!fimc_v4l2_enuminput(m_cam_fd, index))
- return -1;
- ret = fimc_v4l2_s_input(m_cam_fd, index);
- CHECK(ret);
- m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR);
- ALOGV("%s: open(%s) --> m_cam_fd2 = %d", __FUNCTION__, CAMERA_DEV_NAME2, m_cam_fd2);
- if (m_cam_fd2 < 0) {
- ALOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME2, strerror(errno));
- return -1;
- }
- ALOGE("initCamera: m_cam_fd2(%d)", m_cam_fd2);
- ret = fimc_v4l2_querycap(m_cam_fd2);
- CHECK(ret);
- if (!fimc_v4l2_enuminput(m_cam_fd2, index))
- return -1;
- ret = fimc_v4l2_s_input(m_cam_fd2, index);
- CHECK(ret);
- m_camera_id = index;
- switch (m_camera_id) {
- case CAMERA_ID_FRONT:
- m_preview_max_width = MAX_FRONT_CAMERA_PREVIEW_WIDTH;
- m_preview_max_height = MAX_FRONT_CAMERA_PREVIEW_HEIGHT;
- m_snapshot_max_width = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH;
- m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT;
- break;
- case CAMERA_ID_BACK:
- m_preview_max_width = MAX_BACK_CAMERA_PREVIEW_WIDTH;
- m_preview_max_height = MAX_BACK_CAMERA_PREVIEW_HEIGHT;
- m_snapshot_max_width = MAX_BACK_CAMERA_SNAPSHOT_WIDTH;
- m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT;
- break;
- }
- setExifFixedAttribute();
- m_flag_init = 1;
- ALOGI("%s : initialized", __FUNCTION__);
- }
- return 0;
- }
- void SecCamera::resetCamera()
- {
- ALOGV("%s :", __func__);
- DeinitCamera();
- initCamera(m_camera_id);
- }
- void SecCamera::DeinitCamera()
- {
- ALOGV("%s :", __func__);
- if (m_flag_init) {
- stopRecord();
- /* close m_cam_fd after stopRecord() because stopRecord()
- * uses m_cam_fd to change frame rate
- */
- ALOGI("DeinitCamera: m_cam_fd(%d)", m_cam_fd);
- if (m_cam_fd > -1) {
- close(m_cam_fd);
- m_cam_fd = -1;
- }
- ALOGI("DeinitCamera: m_cam_fd2(%d)", m_cam_fd2);
- if (m_cam_fd2 > -1) {
- close(m_cam_fd2);
- m_cam_fd2 = -1;
- }
- m_flag_init = 0;
- }
- else ALOGI("%s : already deinitialized", __FUNCTION__);
- }
- int SecCamera::getCameraFd(void)
- {
- return m_cam_fd;
- }
- // ======================================================================
- // Preview
- int SecCamera::startPreview(void)
- {
- v4l2_streamparm streamparm;
- struct sec_cam_parm *parms;
- parms = (struct sec_cam_parm*)&streamparm.parm.raw_data;
- ALOGV("%s :", __func__);
- // aleady started
- if (m_flag_camera_start > 0) {
- ALOGE("ERR(%s):Preview was already started\n", __func__);
- return 0;
- }
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- memset(&m_events_c, 0, sizeof(m_events_c));
- m_events_c.fd = m_cam_fd;
- m_events_c.events = POLLIN | POLLERR;
- /* enum_fmt, s_fmt sample */
- int ret = fimc_v4l2_enum_fmt(m_cam_fd,m_preview_v4lformat);
- CHECK(ret);
- ret = fimc_v4l2_s_fmt(m_cam_fd, m_preview_width,m_preview_height,m_preview_v4lformat, 0);
- CHECK(ret);
- ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
- CHECK(ret);
- ALOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d\n",
- __func__, m_preview_width, m_preview_height, m_angle);
- ret = fimc_v4l2_s_ctrl(m_cam_fd,
- V4L2_CID_CAMERA_CHECK_DATALINE, m_chk_dataline);
- CHECK(ret);
- /* start with all buffers in queue */
- for (int i = 0; i < MAX_BUFFERS; i++) {
- ret = fimc_v4l2_qbuf(m_cam_fd, i);
- CHECK(ret);
- }
- if (m_camera_id == CAMERA_ID_BACK) {
- // Init some parameters required for CE147
- // Force antibanding for back camera - only value supported
- m_anti_banding = ANTI_BANDING_50HZ;
- // It doesn't hurt to keep these on as the kernel camera driver only
- // enables it when recording HD video. Turning it on before recording
- // doesn't work because it needs to be set before the preview is started.
- m_video_gamma = GAMMA_ON;
- m_slow_ae = SLOW_AE_ON;
- 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_params->iso);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, m_params->brightness);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, m_params->capture.timeperframe.denominator);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, m_params->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_params->effects);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, m_params->white_balance);
- CHECK(ret);
- }
- ret = fimc_v4l2_streamon(m_cam_fd);
- CHECK(ret);
- if (m_camera_id == CAMERA_ID_BACK) {
- // More parameters for CE147
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, m_params->focus_mode);
- CHECK(ret);
- m_face_detect = 0;
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACE_DETECTION, m_face_detect);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, m_params->sharpness);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, m_params->saturation);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, m_params->contrast);
- CHECK(ret);
- // TODO
- m_beauty_shot = 0;
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BEAUTY_SHOT, m_beauty_shot);
- CHECK(ret);
- m_zoom_level = 0;
- 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_BATCH_REFLECTION, 1);
- CHECK(ret);
- }
- m_flag_camera_start = 1;
- if (m_camera_id == CAMERA_ID_FRONT) {
- /* Activate preview mode */
- ALOGV("activate preview mode for front camera");
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAM_PREVIEW_ONOFF,
- 1);
- CHECK(ret);
- }
- ret = fimc_v4l2_s_parm(m_cam_fd, &m_streamparm);
- CHECK(ret);
- #ifdef HAVE_FLASH
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FLASH_MODE, m_params->flash_mode);
- 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);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_RETURN_FOCUS, 0);
- CHECK(ret);
- ALOGV("%s: got the first frame of the preview\n", __func__);
- return 0;
- }
- int SecCamera::stopPreview(void)
- {
- int ret;
- ALOGV("%s :", __func__);
- if (m_flag_camera_start == 0) {
- ALOGW("%s: doing nothing because m_flag_camera_start is zero", __func__);
- return 0;
- }
- if (m_params->flash_mode == FLASH_MODE_TORCH)
- setFlashMode(FLASH_MODE_OFF);
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- ret = fimc_v4l2_streamoff(m_cam_fd);
- CHECK(ret);
- m_flag_camera_start = 0;
- return ret;
- }
- //Recording
- int SecCamera::startRecord(void)
- {
- int ret, i;
- ALOGV("%s :", __func__);
- // aleady started
- if (m_flag_record_start > 0) {
- ALOGE("ERR(%s):Preview was already started\n", __func__);
- return 0;
- }
- if (m_cam_fd2 <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- /* enum_fmt, s_fmt sample */
- ret = fimc_v4l2_enum_fmt(m_cam_fd2, V4L2_PIX_FMT_NV12T);
- CHECK(ret);
- ALOGI("%s: m_recording_width = %d, m_recording_height = %d\n",
- __func__, m_recording_width, m_recording_height);
- if (m_camera_id == CAMERA_ID_BACK) {
- // Some properties for back camera video recording
- setISO(ISO_MOVIE);
- setMetering(METERING_MATRIX);
- setBatchReflection();
- }
- ret = fimc_v4l2_s_fmt(m_cam_fd2, m_recording_width,
- m_recording_height, V4L2_PIX_FMT_NV12T, 0);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE,
- m_params->capture.timeperframe.denominator);
- CHECK(ret);
- ret = fimc_v4l2_reqbufs(m_cam_fd2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS);
- CHECK(ret);
- /* start with all buffers in queue */
- for (i = 0; i < MAX_BUFFERS; i++) {
- ret = fimc_v4l2_qbuf(m_cam_fd2, i);
- CHECK(ret);
- }
- ret = fimc_v4l2_streamon(m_cam_fd2);
- CHECK(ret);
- // Get and throw away the first frame since it is often garbled.
- memset(&m_events_c2, 0, sizeof(m_events_c2));
- m_events_c2.fd = m_cam_fd2;
- m_events_c2.events = POLLIN | POLLERR;
- ret = fimc_poll(&m_events_c2);
- CHECK(ret);
- // Continuous autofocus for main camera
- if (m_camera_id == CAMERA_ID_BACK) {
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CAF_START_STOP, 1);
- CHECK(ret);
- }
- m_flag_record_start = 1;
- return 0;
- }
- int SecCamera::stopRecord(void)
- {
- int ret;
- ALOGV("%s :", __func__);
- if (m_flag_record_start == 0) {
- ALOGW("%s: doing nothing because m_flag_record_start is zero", __func__);
- return 0;
- }
- if (m_cam_fd2 <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- // Continuous autofocus for main camera
- if (m_camera_id == CAMERA_ID_BACK) {
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CAF_START_STOP, 0);
- CHECK(ret);
- // Need to switch focus mode so that the camera can focus properly
- // after using caf.
- // Note: This bug is not affected when the original mode is macro
- // so we can safely use that as a mode to switch to.
- int orig_mode = m_params->focus_mode;
- setFocusMode(FOCUS_MODE_MACRO);
- setFocusMode(orig_mode);
- }
- m_flag_record_start = 0;
- ret = fimc_v4l2_streamoff(m_cam_fd2);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE,
- FRAME_RATE_AUTO);
- CHECK(ret);
- // Properties for back camera non-video recording
- if (m_camera_id == CAMERA_ID_BACK) {
- setISO(ISO_AUTO);
- setMetering(METERING_CENTER);
- setBatchReflection();
- }
- return 0;
- }
- unsigned int SecCamera::getRecPhyAddrY(int index)
- {
- unsigned int addr_y;
- addr_y = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_Y, index);
- CHECK((int)addr_y);
- return addr_y;
- }
- unsigned int SecCamera::getRecPhyAddrC(int index)
- {
- unsigned int addr_c;
- addr_c = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_CBCR, index);
- CHECK((int)addr_c);
- return addr_c;
- }
- unsigned int SecCamera::getPhyAddrY(int index)
- {
- unsigned int addr_y;
- addr_y = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_Y, index);
- CHECK((int)addr_y);
- return addr_y;
- }
- unsigned int SecCamera::getPhyAddrC(int index)
- {
- unsigned int addr_c;
- addr_c = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_CBCR, index);
- CHECK((int)addr_c);
- return addr_c;
- }
- void SecCamera::pausePreview()
- {
- fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
- }
- int SecCamera::getPreview()
- {
- int index;
- int ret;
- if (m_flag_camera_start == 0 || previewPoll(true) == 0) {
- ALOGE("ERR(%s):Start Camera Device Reset \n", __func__);
- /* GAUDI Project([arun.c@samsung.com]) 2010.05.20. [Implemented ESD code] */
- /*
- * When there is no data for more than 1 second from the camera we inform
- * the FIMC driver by calling fimc_v4l2_s_input() with a special value = 1000
- * FIMC driver identify that there is something wrong with the camera
- * and it restarts the sensor.
- */
- stopPreview();
- /* Reset Only Camera Device */
- ret = fimc_v4l2_querycap(m_cam_fd);
- CHECK(ret);
- if (fimc_v4l2_enuminput(m_cam_fd, m_camera_id))
- return -1;
- ret = fimc_v4l2_s_input(m_cam_fd, 1000);
- CHECK(ret);
- ret = startPreview();
- if (ret < 0) {
- ALOGE("ERR(%s): startPreview() return %d\n", __func__, ret);
- return 0;
- }
- }
- index = fimc_v4l2_dqbuf(m_cam_fd);
- if (!(0 <= index && index < MAX_BUFFERS)) {
- ALOGE("ERR(%s):wrong index = %d\n", __func__, index);
- return -1;
- }
- ret = fimc_v4l2_qbuf(m_cam_fd, index);
- CHECK(ret);
- return index;
- }
- int SecCamera::getRecordFrame()
- {
- if (m_flag_record_start == 0) {
- ALOGE("%s: m_flag_record_start is 0", __func__);
- return -1;
- }
- previewPoll(false);
- return fimc_v4l2_dqbuf(m_cam_fd2);
- }
- int SecCamera::releaseRecordFrame(int index)
- {
- if (!m_flag_record_start) {
- /* this can happen when recording frames are returned after
- * the recording is stopped at the driver level. we don't
- * need to return the buffers in this case and we've seen
- * cases where fimc could crash if we called qbuf and it
- * wasn't expecting it.
- */
- ALOGI("%s: recording not in progress, ignoring", __func__);
- return 0;
- }
- return fimc_v4l2_qbuf(m_cam_fd2, index);
- }
- int SecCamera::setPreviewSize(int width, int height, int pixel_format)
- {
- ALOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format);
- int v4lpixelformat = pixel_format;
- #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
- if (v4lpixelformat == V4L2_PIX_FMT_YUV420)
- ALOGV("PreviewFormat:V4L2_PIX_FMT_YUV420");
- else if (v4lpixelformat == V4L2_PIX_FMT_NV12)
- ALOGV("PreviewFormat:V4L2_PIX_FMT_NV12");
- else if (v4lpixelformat == V4L2_PIX_FMT_NV12T)
- ALOGV("PreviewFormat:V4L2_PIX_FMT_NV12T");
- else if (v4lpixelformat == V4L2_PIX_FMT_NV21)
- ALOGV("PreviewFormat:V4L2_PIX_FMT_NV21");
- else if (v4lpixelformat == V4L2_PIX_FMT_YUV422P)
- ALOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P");
- else if (v4lpixelformat == V4L2_PIX_FMT_YUYV)
- ALOGV("PreviewFormat:V4L2_PIX_FMT_YUYV");
- else if (v4lpixelformat == V4L2_PIX_FMT_RGB565)
- ALOGV("PreviewFormat:V4L2_PIX_FMT_RGB565");
- else
- ALOGV("PreviewFormat:UnknownFormat");
- #endif
- m_preview_width = width;
- m_preview_height = height;
- m_preview_v4lformat = v4lpixelformat;
- return 0;
- }
- int SecCamera::getPreviewSize(int *width, int *height, int *frame_size)
- {
- *width = m_preview_width;
- *height = m_preview_height;
- *frame_size = m_frameSize(m_preview_v4lformat, m_preview_width, m_preview_height);
- return 0;
- }
- int SecCamera::getPreviewMaxSize(int *width, int *height)
- {
- *width = m_preview_max_width;
- *height = m_preview_max_height;
- return 0;
- }
- int SecCamera::getPreviewPixelFormat(void)
- {
- return m_preview_v4lformat;
- }
- // ======================================================================
- // Snapshot
- /*
- * Devide getJpeg() as two funcs, setSnapshotCmd() & getJpeg() because of the shutter sound timing.
- * Here, just send the capture cmd to camera ISP to start JPEG capture.
- */
- int SecCamera::setSnapshotCmd(void)
- {
- ALOGV("%s :", __func__);
- int ret = 0;
- LOG_TIME_DEFINE(0)
- LOG_TIME_DEFINE(1)
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return 0;
- }
- if (m_flag_camera_start > 0) {
- LOG_TIME_START(0)
- ALOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__);
- stopPreview();
- LOG_TIME_END(0)
- }
- memset(&m_events_c, 0, sizeof(m_events_c));
- m_events_c.fd = m_cam_fd;
- m_events_c.events = POLLIN | POLLERR;
- LOG_TIME_START(1) // prepare
- int nframe = 1;
- ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat);
- CHECK(ret);
- ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG);
- CHECK(ret);
- ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
- CHECK(ret);
- ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE);
- CHECK(ret);
- ret = fimc_v4l2_qbuf(m_cam_fd, 0);
- CHECK(ret);
- ret = fimc_v4l2_streamon(m_cam_fd);
- CHECK(ret);
- // Orientation
- int orientation;
- switch (m_exif_orientation) {
- case 0:
- orientation = EXIF_ORIENTATION_UP;
- break;
- case 90:
- orientation = EXIF_ORIENTATION_90;
- break;
- case 180:
- orientation = EXIF_ORIENTATION_180;
- break;
- case 270:
- orientation = EXIF_ORIENTATION_270;
- break;
- default:
- orientation = EXIF_ORIENTATION_UP;
- break;
- }
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EXIF_ORIENTATION, orientation);
- CHECK(ret);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CAPTURE, 0);
- CHECK(ret);
- LOG_TIME_END(1)
- return 0;
- }
- int SecCamera::endSnapshot(void)
- {
- int ret;
- ALOGI("%s :", __func__);
- if (m_capture_buf.start) {
- munmap(m_capture_buf.start, m_capture_buf.length);
- ALOGI("munmap():virt. addr %p size = %d\n",
- m_capture_buf.start, m_capture_buf.length);
- m_capture_buf.start = NULL;
- m_capture_buf.length = 0;
- }
- return 0;
- }
- /*
- * Set Jpeg quality & exif info and get JPEG data from camera ISP
- */
- unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr)
- {
- ALOGV("%s :", __func__);
- int index, ret = 0;
- unsigned char *addr;
- LOG_TIME_DEFINE(2)
- // capture
- ret = fimc_poll(&m_events_c);
- CHECK_PTR(ret);
- index = fimc_v4l2_dqbuf(m_cam_fd);
- if (index != 0) {
- ALOGE("ERR(%s):wrong index = %d\n", __func__, index);
- return NULL;
- }
- *jpeg_size = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_SIZE);
- CHECK_PTR(*jpeg_size);
- int main_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_OFFSET);
- CHECK_PTR(main_offset);
- m_postview_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET);
- CHECK_PTR(m_postview_offset);
- ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
- CHECK_PTR(ret);
- ALOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d\n\n",
- index, m_snapshot_width, m_snapshot_height, *jpeg_size);
- addr = (unsigned char*)(m_capture_buf.start) + main_offset;
- *phyaddr = getPhyAddrY(index) + m_postview_offset;
- LOG_TIME_START(2) // post
- ret = fimc_v4l2_streamoff(m_cam_fd);
- CHECK_PTR(ret);
- LOG_TIME_END(2)
- return addr;
- }
- int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc)
- {
- JpegEncoder jpgEnc;
- //FIXME: Disabled thumbnails for now as they're always green
- #if 0
- ALOGV("%s : m_jpeg_thumbnail_width = %d, height = %d",
- __func__, m_jpeg_thumbnail_width, m_jpeg_thumbnail_height);
- if ((m_jpeg_thumbnail_width > 0) && (m_jpeg_thumbnail_height > 0)) {
- int inFormat = JPG_MODESEL_YCBCR;
- int outFormat = JPG_422;
- switch (m_snapshot_v4lformat) {
- case V4L2_PIX_FMT_NV12:
- case V4L2_PIX_FMT_NV21:
- case V4L2_PIX_FMT_NV12T:
- case V4L2_PIX_FMT_YUV420:
- outFormat = JPG_420;
- break;
- case V4L2_PIX_FMT_YUYV:
- case V4L2_PIX_FMT_UYVY:
- case V4L2_PIX_FMT_YUV422P:
- outFormat = JPG_422;
- break;
- }
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS)
- return -1;
- if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS)
- return -1;
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPG_SUCCESS)
- return -1;
- int thumbWidth, thumbHeight, thumbSrcSize;
- getThumbnailConfig(&thumbWidth, &thumbHeight, &thumbSrcSize);
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, thumbWidth) != JPG_SUCCESS)
- return -1;
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, thumbHeight) != JPG_SUCCESS)
- return -1;
- char *pInBuf = (char *)jpgEnc.getInBuf(thumbSrcSize);
- if (pInBuf == NULL)
- return -1;
- memcpy(pInBuf, pThumbSrc, thumbSrcSize);
- unsigned int thumbSize;
- jpgEnc.encode(&thumbSize, NULL);
- ALOGV("%s : enableThumb set to true", __func__);
- mExifInfo.enableThumb = true;
- } else {
- #endif
- ALOGV("%s : enableThumb set to false", __func__);
- mExifInfo.enableThumb = false;
- #if 0
- }
- #endif
- unsigned int exifSize;
- setExifChangedAttribute();
- ALOGV("%s: calling jpgEnc.makeExif, mExifInfo.width set to %d, height to %d\n",
- __func__, mExifInfo.width, mExifInfo.height);
- jpgEnc.makeExif(pExifDst, &mExifInfo, &exifSize, true);
- return exifSize;
- }
- void SecCamera::getPostViewConfig(int *width, int *height, int *size)
- {
- if (m_preview_width == 1024) {
- *width = BACK_CAMERA_POSTVIEW_WIDE_WIDTH;
- *height = BACK_CAMERA_POSTVIEW_HEIGHT;
- *size = BACK_CAMERA_POSTVIEW_WIDE_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8;
- } else {
- *width = BACK_CAMERA_POSTVIEW_WIDTH;
- *height = BACK_CAMERA_POSTVIEW_HEIGHT;
- *size = BACK_CAMERA_POSTVIEW_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8;
- }
- ALOGV("[5B] m_preview_width : %d, mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",
- m_preview_width, *width, *height, *size);
- }
- void SecCamera::getThumbnailConfig(int *width, int *height, int *size)
- {
- if (m_camera_id == CAMERA_ID_BACK) {
- *width = BACK_CAMERA_THUMBNAIL_WIDTH;
- *height = BACK_CAMERA_THUMBNAIL_HEIGHT;
- *size = BACK_CAMERA_THUMBNAIL_WIDTH * BACK_CAMERA_THUMBNAIL_HEIGHT
- * BACK_CAMERA_THUMBNAIL_BPP / 8;
- } else {
- *width = FRONT_CAMERA_THUMBNAIL_WIDTH;
- *height = FRONT_CAMERA_THUMBNAIL_HEIGHT;
- *size = FRONT_CAMERA_THUMBNAIL_WIDTH * FRONT_CAMERA_THUMBNAIL_HEIGHT
- * FRONT_CAMERA_THUMBNAIL_BPP / 8;
- }
- }
- int SecCamera::getPostViewOffset(void)
- {
- return m_postview_offset;
- }
- int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf,
- unsigned int *output_size)
- {
- ALOGV("%s :", __func__);
- int index;
- //unsigned int addr;
- unsigned char *addr;
- int ret = 0;
- LOG_TIME_DEFINE(0)
- LOG_TIME_DEFINE(1)
- LOG_TIME_DEFINE(2)
- LOG_TIME_DEFINE(3)
- LOG_TIME_DEFINE(4)
- LOG_TIME_DEFINE(5)
- //fimc_v4l2_streamoff(m_cam_fd); [zzangdol] remove - it is separate in HWInterface with camera_id
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- if (m_flag_camera_start > 0) {
- LOG_TIME_START(0)
- ALOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__);
- stopPreview();
- LOG_TIME_END(0)
- }
- memset(&m_events_c, 0, sizeof(m_events_c));
- m_events_c.fd = m_cam_fd;
- m_events_c.events = POLLIN | POLLERR;
- #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
- if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_YUV420");
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_NV12");
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_NV12T");
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_NV21");
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_YUV422P");
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_YUYV");
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_UYVY");
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
- ALOGV("SnapshotFormat:V4L2_PIX_FMT_RGB565");
- else
- ALOGV("SnapshotFormat:UnknownFormat");
- #endif
- LOG_TIME_START(1) // prepare
- int nframe = 1;
- ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat);
- CHECK(ret);
- ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat);
- CHECK(ret);
- ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe);
- CHECK(ret);
- ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE);
- CHECK(ret);
- ret = fimc_v4l2_qbuf(m_cam_fd, 0);
- CHECK(ret);
- ret = fimc_v4l2_streamon(m_cam_fd);
- CHECK(ret);
- LOG_TIME_END(1)
- LOG_TIME_START(2) // capture
- fimc_poll(&m_events_c);
- index = fimc_v4l2_dqbuf(m_cam_fd);
- fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0);
- ALOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d\n\n",
- index, m_snapshot_width, m_snapshot_height);
- LOG_TIME_END(2)
- ALOGI("%s : calling memcpy from m_capture_buf", __func__);
- memcpy(yuv_buf, (unsigned char*)m_capture_buf.start, m_snapshot_width * m_snapshot_height * 2);
- LOG_TIME_START(5) // post
- fimc_v4l2_streamoff(m_cam_fd);
- LOG_TIME_END(5)
- LOG_CAMERA("getSnapshotAndJpeg intervals : stopPreview(%lu), prepare(%lu),"
- " capture(%lu), memcpy(%lu), yuv2Jpeg(%lu), post(%lu) us",
- LOG_TIME(0), LOG_TIME(1), LOG_TIME(2), LOG_TIME(3), LOG_TIME(4), LOG_TIME(5));
- /* JPEG encoding */
- JpegEncoder jpgEnc;
- int inFormat = JPG_MODESEL_YCBCR;
- int outFormat = JPG_422;
- switch (m_snapshot_v4lformat) {
- case V4L2_PIX_FMT_NV12:
- case V4L2_PIX_FMT_NV21:
- case V4L2_PIX_FMT_NV12T:
- case V4L2_PIX_FMT_YUV420:
- outFormat = JPG_420;
- break;
- case V4L2_PIX_FMT_YUYV:
- case V4L2_PIX_FMT_UYVY:
- case V4L2_PIX_FMT_YUV422P:
- default:
- outFormat = JPG_422;
- break;
- }
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS)
- ALOGE("[JPEG_SET_ENCODE_IN_FORMAT] Error\n");
- if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS)
- ALOGE("[JPEG_SET_SAMPING_MODE] Error\n");
- image_quality_type_t jpegQuality;
- if (m_jpeg_quality >= 90)
- jpegQuality = JPG_QUALITY_LEVEL_1;
- else if (m_jpeg_quality >= 80)
- jpegQuality = JPG_QUALITY_LEVEL_2;
- else if (m_jpeg_quality >= 70)
- jpegQuality = JPG_QUALITY_LEVEL_3;
- else
- jpegQuality = JPG_QUALITY_LEVEL_4;
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, jpegQuality) != JPG_SUCCESS)
- ALOGE("[JPEG_SET_ENCODE_QUALITY] Error\n");
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, m_snapshot_width) != JPG_SUCCESS)
- ALOGE("[JPEG_SET_ENCODE_WIDTH] Error\n");
- if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, m_snapshot_height) != JPG_SUCCESS)
- ALOGE("[JPEG_SET_ENCODE_HEIGHT] Error\n");
- unsigned int snapshot_size = m_snapshot_width * m_snapshot_height * 2;
- unsigned char *pInBuf = (unsigned char *)jpgEnc.getInBuf(snapshot_size);
- if (pInBuf == NULL) {
- ALOGE("JPEG input buffer is NULL!!\n");
- return -1;
- }
- memcpy(pInBuf, yuv_buf, snapshot_size);
- setExifChangedAttribute();
- jpgEnc.encode(output_size, NULL);
- uint64_t outbuf_size;
- unsigned char *pOutBuf = (unsigned char *)jpgEnc.getOutBuf(&outbuf_size);
- if (pOutBuf == NULL) {
- ALOGE("JPEG output buffer is NULL!!\n");
- return -1;
- }
- memcpy(jpeg_buf, pOutBuf, outbuf_size);
- return 0;
- }
- int SecCamera::setSnapshotSize(int width, int height)
- {
- ALOGV("%s(width(%d), height(%d))", __func__, width, height);
- m_snapshot_width = width;
- m_snapshot_height = height;
- return 0;
- }
- int SecCamera::getSnapshotSize(int *width, int *height, int *frame_size)
- {
- *width = m_snapshot_width;
- *height = m_snapshot_height;
- int frame = 0;
- frame = m_frameSize(m_snapshot_v4lformat, m_snapshot_width, m_snapshot_height);
- // set it big.
- if (frame == 0)
- frame = m_snapshot_width * m_snapshot_height * BPP;
- *frame_size = frame;
- return 0;
- }
- int SecCamera::getSnapshotMaxSize(int *width, int *height)
- {
- switch (m_camera_id) {
- case CAMERA_ID_FRONT:
- m_snapshot_max_width = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH;
- m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT;
- break;
- default:
- case CAMERA_ID_BACK:
- m_snapshot_max_width = MAX_BACK_CAMERA_SNAPSHOT_WIDTH;
- m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT;
- break;
- }
- *width = m_snapshot_max_width;
- *height = m_snapshot_max_height;
- return 0;
- }
- int SecCamera::setSnapshotPixelFormat(int pixel_format)
- {
- int v4lpixelformat= pixel_format;
- if (m_snapshot_v4lformat != v4lpixelformat) {
- m_snapshot_v4lformat = v4lpixelformat;
- }
- #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0
- if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420)
- ALOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__);
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12)
- ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__);
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T)
- ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__);
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21)
- ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__);
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P)
- ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__);
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV)
- ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__);
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY)
- ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__);
- else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565)
- ALOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__);
- else
- ALOGD("SnapshotFormat:UnknownFormat");
- #endif
- return 0;
- }
- int SecCamera::getSnapshotPixelFormat(void)
- {
- return m_snapshot_v4lformat;
- }
- // ======================================================================
- // Settings
- int SecCamera::getCameraId(void)
- {
- return m_camera_id;
- }
- // -----------------------------------
- int SecCamera::setAutofocus(void)
- {
- ALOGV("%s :", __func__);
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) {
- ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
- return -1;
- }
- return 0;
- }
- int SecCamera::getAutoFocusResult(void)
- {
- int af_result = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT_FIRST);
- ALOGV("%s : AF was successful, returning %d", __func__, af_result);
- return af_result;
- }
- int SecCamera::cancelAutofocus(void)
- {
- ALOGV("%s :", __func__);
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) {
- ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__);
- return -1;
- }
- return 0;
- }
- // -----------------------------------
- int SecCamera::zoomIn(void)
- {
- ALOGV("%s :", __func__);
- return 0;
- }
- int SecCamera::zoomOut(void)
- {
- ALOGV("%s :", __func__);
- return 0;
- }
- // -----------------------------------
- int SecCamera::SetRotate(int angle)
- {
- ALOGE("%s(angle(%d))", __func__, angle);
- if (m_angle != angle) {
- switch (angle) {
- case -360:
- case 0:
- case 360:
- m_angle = 0;
- break;
- case -270:
- case 90:
- m_angle = 90;
- break;
- case -180:
- case 180:
- m_angle = 180;
- break;
- case -90:
- case 270:
- m_angle = 270;
- break;
- default:
- ALOGE("ERR(%s):Invalid angle(%d)", __func__, angle);
- return -1;
- }
- if (m_flag_camera_start) {
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_ROTATION, angle) < 0) {
- ALOGE("ERR(%s):Fail on V4L2_CID_ROTATION", __func__);
- return -1;
- }
- }
- }
- return 0;
- }
- int SecCamera::getRotate(void)
- {
- ALOGV("%s : angle(%d)", __func__, m_angle);
- return m_angle;
- }
- int SecCamera::setFrameRate(int frame_rate)
- {
- ALOGV("%s(FrameRate(%d))", __func__, frame_rate);
- if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate )
- ALOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate);
- if (m_params->capture.timeperframe.denominator != (unsigned)frame_rate) {
- m_params->capture.timeperframe.denominator = frame_rate;
- if (m_flag_camera_start) {
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0) {
- ALOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__);
- return -1;
- }
- }
- }
- return 0;
- }
- // -----------------------------------
- int SecCamera::setVerticalMirror(void)
- {
- ALOGV("%s :", __func__);
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func__);
- return -1;
- }
- if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_VFLIP, 0) < 0) {
- ALOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __func__);
- return -1;
- }
- return 0;
- }
- int SecCamera::setHorizontalMirror(void)
- {
- ALOGV("%s :", __func__);
- if (m_cam_fd <= 0) {
- ALOGE("ERR(%s):Camera was closed\n", __func_…
Large files files are truncated, but you can click here to view the full file