diff options
Diffstat (limited to 'camerasrc')
| -rw-r--r-- | camerasrc/Makefile.am | 10 | ||||
| -rw-r--r-- | camerasrc/src/Makefile.am | 30 | ||||
| -rw-r--r-- | camerasrc/src/camerasrc-internal.c | 1463 | ||||
| -rw-r--r-- | camerasrc/src/camerasrc.c | 4870 | ||||
| -rw-r--r-- | camerasrc/src/gstcamerasrc.c | 3894 | ||||
| -rw-r--r-- | camerasrc/src/gstcamerasrccolorbalance.c | 117 | ||||
| -rw-r--r-- | camerasrc/src/gstcamerasrccontrol.c | 1098 | ||||
| -rw-r--r-- | camerasrc/src/include/camerasrc-common.h | 408 | ||||
| -rw-r--r-- | camerasrc/src/include/camerasrc-error.h | 140 | ||||
| -rw-r--r-- | camerasrc/src/include/camerasrc-internal.h | 247 | ||||
| -rw-r--r-- | camerasrc/src/include/camerasrc.h | 1488 | ||||
| -rw-r--r-- | camerasrc/src/include/gstcamerasrc.h | 175 | ||||
| -rw-r--r-- | camerasrc/src/include/gstcamerasrccolorbalance.h | 93 | ||||
| -rw-r--r-- | camerasrc/src/include/gstcamerasrccontrol.h | 384 |
14 files changed, 14417 insertions, 0 deletions
diff --git a/camerasrc/Makefile.am b/camerasrc/Makefile.am new file mode 100644 index 0000000..d46fc5c --- /dev/null +++ b/camerasrc/Makefile.am @@ -0,0 +1,10 @@ +# Copyright (c) 2006 Software Laboratory, SAMSUNG Electronics, Inc. +# All rights reserved. +# +# This software is the confidential and proprietary information of +# SAMSUNG Electronics, Inc. ("Confidential Information"). +# You shall not disclose such Confidential Information and shall use it +# only in accordance with the terms of the license agreement you entered into +# with SAMSUNG Electronics. + +SUBDIRS = src diff --git a/camerasrc/src/Makefile.am b/camerasrc/src/Makefile.am new file mode 100644 index 0000000..ecec7e7 --- /dev/null +++ b/camerasrc/src/Makefile.am @@ -0,0 +1,30 @@ +# plugindir is set in configure + +plugin_LTLIBRARIES = libgstcamerasrc.la + +# sources used to compile this plug-in +libgstcamerasrc_la_SOURCES = gstcamerasrccontrol.c \ + gstcamerasrccolorbalance.c \ + camerasrc.c \ + camerasrc-internal.c \ + gstcamerasrc.c + +libgstcamerasrc_la_CFLAGS = $(GST_CFLAGS) \ + $(GST_BASE_CFLAGS) \ + $(GST_VIDEO_FLAGS) \ + $(MMTA_CFLAGS) \ + -I$(srcdir)/include \ + $(GST_INTERFACES_CFLAGS) + + +libgstcamerasrc_la_LIBADD = $(GST_LIBS) \ + $(GST_BASE_LIBS) \ + $(GST_VIDEO_LIBS) \ + $(MMTA_LIBS) \ + -ldl -lpthread -lrt -lm \ + $(GST_INTERFACES_LIBS) + +libgstcamerasrc_la_LDFLAGS = $(GST_PLUGIN_LDFLAGS) + +libgstcamerasrc_la_CPPFLAGS = -I$(srcdir)/include + diff --git a/camerasrc/src/camerasrc-internal.c b/camerasrc/src/camerasrc-internal.c new file mode 100644 index 0000000..e820bd9 --- /dev/null +++ b/camerasrc/src/camerasrc-internal.c @@ -0,0 +1,1463 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include <math.h> +#include "camerasrc-internal.h" + +/*#define USE_IOCTL_DEBUG*/ +#if defined (USE_IOCTL_DEBUG) +static char* get_request_name(int request, char* res_str) { + switch (request) { + case VIDIOC_QBUF: + sprintf(res_str, "[VIDIOC_QBUF]"); + break; + case VIDIOC_DQBUF: + sprintf(res_str, "[VIDIOC_DQBUF]"); + break; + case VIDIOC_S_INPUT: + sprintf(res_str, "[VIDIOC_S_INPUT]"); + break; + case VIDIOC_G_INPUT: + sprintf(res_str, "[VIDIOC_G_INPUT]"); + break; + case VIDIOC_S_PARM: + sprintf(res_str, "[VIDIOC_S_PARM]"); + break; + case VIDIOC_G_PARM: + sprintf(res_str, "[VIDIOC_G_PARM]"); + break; + case VIDIOC_S_FMT: + sprintf(res_str, "[VIDIOC_S_FMT]"); + break; + case VIDIOC_G_FMT: + sprintf(res_str, "[VIDIOC_G_FMT]"); + break; + case VIDIOC_REQBUFS: + sprintf(res_str, "[VIDIOC_REQBUFS]"); + break; + case VIDIOC_QUERYBUF: + sprintf(res_str, "[VIDIOC_QUERYBUF]"); + break; + case VIDIOC_STREAMON: + sprintf(res_str, "[VIDIOC_STREAMON]"); + break; + case VIDIOC_STREAMOFF: + sprintf(res_str, "[VIDIOC_STREAMOFF]"); + break; + case VIDIOC_S_CTRL: + sprintf(res_str, "[VIDIOC_S_CTRL] "); + break; + case VIDIOC_G_CTRL: + sprintf(res_str, "[VIDIOC_G_CTRL]"); + break; + case VIDIOC_ENUMINPUT: + sprintf(res_str, "[VIDIOC_ENUMINPUT]"); + break; + case VIDIOC_S_JPEGCOMP: + sprintf(res_str, "[VIDIOC_S_JPEGCOMP]"); + break; + case VIDIOC_G_JPEGCOMP: + sprintf(res_str, "[VIDIOC_G_JPEGCOMP]"); + break; + /* Extension */ + case VIDIOC_S_STROBE: + sprintf(res_str, "[VIDIOC_S_STROBE]"); + break; + case VIDIOC_G_STROBE: + sprintf(res_str, "[VIDIOC_G_STROBE]"); + break; + case VIDIOC_S_RECOGNITION: + sprintf(res_str, "[VIDIOC_S_RECOGNITION]"); + break; + case VIDIOC_G_RECOGNITION: + sprintf(res_str, "[VIDIOC_G_RECOGNITION]"); + break; + case VIDIOC_G_EXIF: + sprintf(res_str, "[VIDIOC_G_EXIF]"); + break; + default: + sprintf(res_str, "[UNKNOWN IOCTL(%x)]", request); + break; + } + + return 0; +} + +#define PRINT_IOCTL_INFO(request, arg) {\ + char res_str[255];\ + get_request_name(request, res_str);\ + camsrc_info("[request : %s, argument address : %x]", res_str, arg);\ +} +#else + +#define PRINT_IOCTL_INFO(request, arg) + +#endif + + +#define LOCK(x) {\ + if(0 != pthread_mutex_lock(&(x->mutex))) {\ + camsrc_error("Mutex lock error");\ + camsrc_assert(0);\ + }\ +} + +#define UNLOCK(x) {\ + if(0 != pthread_mutex_unlock(&(x->mutex))) {\ + camsrc_error("Mutex unlock error");\ + camsrc_assert(0);\ + }\ +} + +#define AF_MUT_LOCK(p) {\ + if(0 != pthread_mutex_lock(&(p->af_mutex))) {\ + camsrc_error("AF Mutex locking error");\ + camsrc_assert(0);\ + }\ +} + +#define AF_MUT_UNLOCK(p) {\ + if(0 != pthread_mutex_unlock(&(p->af_mutex))) {\ + camsrc_error("AF Mutex unlocking error");\ + camsrc_assert(0);\ + }\ +} + +#define SET_CTRL_VAL(cid, in_value) {\ + int err = CAMERASRC_ERR_UNKNOWN;\ + struct v4l2_control control;\ + control.id = cid;\ + control.value = in_value;\ + camsrc_info("[VIDIOC_S_CTRL] >> [%x] request with value %d", cid, in_value); \ + err = _camerasrc_ioctl(handle, VIDIOC_S_CTRL, &control);\ + if(err != CAMERASRC_SUCCESS) {\ + return err;\ + }\ +} + +#define GET_CTRL_VAL(cid, ret_value) {\ + int err = CAMERASRC_ERR_UNKNOWN;\ + struct v4l2_control control;\ + control.id = cid;\ + err = _camerasrc_ioctl(handle, VIDIOC_G_CTRL, &control);\ + if(err != CAMERASRC_SUCCESS) {\ + return err;\ + }\ + ret_value = control.value;\ + camsrc_info("[VIDIOC_G_CTRL] << [%x] request with value %d", cid, ret_value); \ +} + +#define SET_CTRL_VAL_ERR(cid, in_value, err) {\ + struct v4l2_control control;\ + control.id = cid;\ + control.value = in_value;\ + camsrc_info("[VIDIOC_S_CTRL] >> [%x] request with value %d", cid, in_value); \ + _camerasrc_ioctl_with_err(handle, VIDIOC_S_CTRL, &control, &err);\ +} + +#define GET_CTRL_VAL_ERR(cid, ret_value, err) {\ + struct v4l2_control control;\ + control.id = cid;\ + _camerasrc_ioctl_with_err(handle, VIDIOC_G_CTRL, &control, &err);\ + ret_value = control.value;\ + camsrc_info("[VIDIOC_G_CTRL] << [%x] request with value %d", cid, ret_value); \ +} + +/* AF function */ +static int _camerasrc_start_autofocusing(camerasrc_handle_t *handle); +static int _camerasrc_stop_autofocusing(camerasrc_handle_t *handle); +static int _camerasrc_destroy_autofocusing(camerasrc_handle_t *handle); +static int _camerasrc_release_autofocusing(camerasrc_handle_t *handle); + + +int static af_retry_cnt = 0; + +static int _camerasrc_ioctl(camerasrc_handle_t *handle, int request, void *arg) +{ + int fd = handle->dev_fd; + int err; + int nAgain = 10; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + LOCK(handle); + + if (handle->check_esd == 1) { + camsrc_warning("ESD shock occured. All device control will success"); + UNLOCK(handle); + return CAMERASRC_SUCCESS; + } + + if (handle->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) { + camsrc_warning("Device emergency closed. All device control will success"); + UNLOCK(handle); + return CAMERASRC_SUCCESS; + } + + PRINT_IOCTL_INFO(request, arg); + +again: + do { + err = ioctl (fd, request, arg); + } while (-1 == err && EINTR == errno); + + if (err != 0) { + handle->errnum = errno; + err = errno; + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("ioctl[%x] err : %s", request, err_msg); + if (err == EEXIST) { + camsrc_info("EEXIST occured, but can go."); + err = 0; + } else if (err == ENOENT) { + camsrc_info("ENOENT occured, but can go."); + err = 0; +#if defined (ENABLE_Q_ERROR) +#warning "ENABLE_Q_ERROR enabled" + } else if (request == VIDIOC_DQBUF) { + goto DQ_ERROR; + } else if (request == VIDIOC_QBUF) { + goto ENQ_ERROR; +#endif + } else if (err == EINVAL) { + camsrc_error("EINVAL occured, Shutdown"); + UNLOCK(handle); + return CAMERASRC_ERR_INVALID_PARAMETER; + } else if (err == EBUSY) { + camsrc_error("EBUSY occured, Shutdown"); + UNLOCK(handle); + return CAMERASRC_ERR_PRIVILEGE; + } else if (err == EAGAIN && nAgain--) { + goto again; + } else { + /* Why does this return SUCCESS? */ + camsrc_error("Unhandled exception occured on IOCTL"); + } + } + + UNLOCK(handle); + + return CAMERASRC_SUCCESS; + +#if defined (ENABLE_Q_ERROR) +DQ_ERROR: + camsrc_error("DQ Frame error occured"); + printf("DQ Frame error occured"); + UNLOCK(handle); + return CAMERASRC_ERR_INTERNAL; + +ENQ_ERROR: + camsrc_error("Q Frame error occured"); + printf("Q Frame error occured"); + UNLOCK(handle); + return CAMERASRC_ERR_INTERNAL; +#endif +} + + +static int _camerasrc_ioctl_with_err(camerasrc_handle_t *handle, int request, void *arg, int *error) +{ + int fd = handle->dev_fd; + int err; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + LOCK(handle); + + *error = 0; + + if (handle->check_esd == 1) { + camsrc_warning("ESD shock occured. All device control will success"); + UNLOCK(handle); + return CAMERASRC_SUCCESS; + } + + if (handle->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) { + camsrc_warning("Device emergency closed. All device control will success"); + UNLOCK(handle); + return CAMERASRC_SUCCESS; + } + + PRINT_IOCTL_INFO(request, arg); + + do { + err = ioctl (fd, request, arg); + } while (-1 == err && EINTR == errno); + + if (err != 0) { + handle->errnum = errno; + *error = errno; + strerror_r(*error, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("ioctl[%x] err : %s", request, err_msg); + UNLOCK(handle); + return CAMERASRC_ERR_IO_CONTROL; + } + + UNLOCK(handle); + + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_ioctl_once(camerasrc_handle_t *handle, int request, void *arg) +{ + int fd = handle->dev_fd; + int err = -1; + int nAgain = 10; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + LOCK(handle); + + if (handle->check_esd == 1) { + camsrc_warning("ESD shock occured. All device control will success"); + UNLOCK(handle); + return CAMERASRC_SUCCESS; + } + + if (handle->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) { + camsrc_warning("Device emergency closed. All device control will success"); + UNLOCK(handle); + return CAMERASRC_SUCCESS; + } + + PRINT_IOCTL_INFO(request, arg); + +again: + err = ioctl (fd, request, arg); + + if (err != 0) { + handle->errnum = errno; + err = errno; + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("ioctl[%x] err : %s", request, err_msg); + if (err == EEXIST) { + camsrc_info("EEXIST occured, but can go."); + err = 0; + } else if (err == ENOENT) { + camsrc_info("ENOENT occured, but can go."); + err = 0; +#if defined (ENABLE_Q_ERROR) +#warning "ENABLE_Q_ERROR enabled" + } else if (request == VIDIOC_DQBUF) { + goto DQ_ERROR; + } else if (request == VIDIOC_QBUF) { + goto ENQ_ERROR; +#endif + } else if (err == EINVAL) { + camsrc_error("EINVAL occured, Shutdown"); + UNLOCK(handle); + return CAMERASRC_ERR_INVALID_PARAMETER; + } else if (err == EAGAIN && nAgain--) { + goto again; + } else { + camsrc_error("Unhandled exception occured on IOCTL"); + } + } + + UNLOCK(handle); + + return CAMERASRC_SUCCESS; + +#if defined (ENABLE_Q_ERROR) +DQ_ERROR: + camsrc_error("DQ Frame error occured"); + printf("DQ Frame error occured"); + UNLOCK(handle); + return CAMERASRC_ERR_INTERNAL; + +ENQ_ERROR: + camsrc_error("Q Frame error occured"); + printf("Q Frame error occured"); + UNLOCK(handle); + return CAMERASRC_ERR_INTERNAL; +#endif +} + + +static int _camerasrc_skip_frame(camerasrc_handle_t *handle, long int timeout, int skip_frame) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + fd_set fds; + struct timeval tv; + int r; + int skip_frame_num = skip_frame; + + camsrc_error("enter"); + + p = handle; + + while (skip_frame_num--) { + camsrc_error("SKIP FRAME #%d", skip_frame-skip_frame_num+1); + + struct v4l2_buffer buf; + + FD_ZERO (&fds); + FD_SET (p->dev_fd, &fds); + + camsrc_error("************Still capture wait frame start"); + + /* Timeout. */ + tv.tv_sec = (long int)timeout/1000; + tv.tv_usec = timeout - tv.tv_sec * 1000; + + r = select (p->dev_fd + 1, &fds, NULL, NULL, &tv); + + if (-1 == r) { + if (EINTR == errno) { + return CAMERASRC_SUCCESS; + } + camsrc_error("select() failed."); + return CAMERASRC_ERR_INTERNAL; + } + + if (0 == r) { + camsrc_error("select() timeout."); + return CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT; + } + + /**@note from samsung camera sample. *****************************************/ + /*SKIP FRAME START*/ + CLEAR(buf); + buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + buf.memory = V4L2_MEMORY_MMAP; + buf.index = p->buffer_idx; + + if (-1 == _camerasrc_ioctl (p, VIDIOC_DQBUF, &buf)) { + switch (errno) { + case EAGAIN: + camsrc_info("VIDIOC_DQBUF [EAGAIN]"); + return CAMERASRC_SUCCESS; + case EIO: + /* Could ignore EIO, see spec. */ + /* fall through */ + camsrc_info("VIDIOC_DQBUF [EIO]"); + default: + camsrc_info("VIDIOC_DQBUF [%d]", errno); + return CAMERASRC_ERR_IO_CONTROL; + } + } + + if (-1 == _camerasrc_ioctl (p, VIDIOC_QBUF, &buf)) { + return CAMERASRC_ERR_IO_CONTROL; + } + } + + camsrc_error("leave"); + err = CAMERASRC_SUCCESS; + + return err; +} + +static int _camerasrc_init_autofocusing_mode(camerasrc_handle_t *handle) +{ + int ctrl_id = V4L2_CID_FOCUS_AUTO_MODE; + int mode; + + camsrc_info("enter"); + + if (handle->af_status == CAMERASRC_AUTO_FOCUS_STATUS_ONGOING) { + camsrc_info("Dev BUSY. Init failed."); + return CAMERASRC_ERR_INVALID_STATE; + } + + switch (handle->cur_af_mode) { + case CAMERASRC_AF_MODE_AUTO: + mode = V4L2_FOCUS_AUTO_NORMAL; + camsrc_info("ON AUTOFOCUSING...BY AUTO"); + break; + case CAMERASRC_AF_MODE_MANUAL: + ctrl_id = V4L2_CID_FOCUS_MODE; + mode = V4L2_FOCUS_MODE_MANUAL; + camsrc_info("ON AUTOFOCUSING...BY MANUAL"); + break; + case CAMERASRC_AF_MODE_CONTINUOUS: + mode = V4L2_FOCUS_AUTO_CONTINUOUS; + camsrc_info("ON AUTOFOCUSING...BY CONTINUOUS"); + if (handle->format.pix_format != CAMERASRC_PIX_NV12 && + handle->format.pix_format != CAMERASRC_PIX_SN12) { + camsrc_info("DO NOT CONTINUOUS AF when NV12 or SN12 format"); + return CAMERASRC_SUCCESS; + } + break; + case CAMERASRC_AF_MODE_TOUCH_AUTO: + mode = V4L2_FOCUS_AUTO_RECTANGLE; + camsrc_info("ON AUTOFOCUSING...BY TOUCH AUTO"); + break; + case CAMERASRC_AF_MODE_PAN: + camsrc_warning("PAN MODE focusing is not supported."); + default: + camsrc_warning("Unsupported AF mode[%d]", handle->cur_af_mode ); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + /* MACRO is prior than other setting. FIXME */ + if (handle->cur_af_range == CAMERASRC_AF_RANGE_MACRO) { + mode = V4L2_FOCUS_AUTO_MACRO; + camsrc_info("ON AUTOFOCUSING...BY MACRO"); + } + + SET_CTRL_VAL(ctrl_id, mode); + + /* Start AF if continuous mode and preview is running */ + if (mode == V4L2_FOCUS_AUTO_CONTINUOUS && + handle->cur_state >= CAMERASRC_STATE_PREVIEW) { + _camerasrc_start_autofocusing(handle); + } + + return CAMERASRC_SUCCESS; +} + +static void __CAMERASRC_FUJITSU_GET_AF_CTRL_VAL(camerasrc_handle_t* handle, int* status) +{ + int err = 0; + + if (af_retry_cnt >= (int)CAMERASRC_AF_TOTALTIME/CAMERASRC_AF_INTERVAL) { + *status = CAMERASRC_SENSOR_AF_STATUS_FAILED; + af_retry_cnt = 0; + return; + } else { + af_retry_cnt++; + camsrc_info("retry count = %d", af_retry_cnt); + } + + SET_CTRL_VAL_ERR(V4L2_CID_CAMERA_SET_AUTO_FOCUS, 1, err); + switch (err) { + case 0: + camsrc_info("Succeeded"); + *status = CAMERASRC_SENSOR_AF_STATUS_FOCUSED; + af_retry_cnt = 0; + break; + case EBUSY: + camsrc_info("Busy"); + *status = CAMERASRC_SENSOR_AF_STATUS_ONGOING; + break; + default: + camsrc_info("Failed"); + *status = CAMERASRC_SENSOR_AF_STATUS_FAILED; + af_retry_cnt = 0; + break; + } + + return; +} + +static void* _camerasrc_run_autofocusing(camerasrc_handle_t *handle) +{ + int err = 0; + int sensor_status = 0; + + camsrc_info("enter"); + + while(1) { + AF_MUT_LOCK(handle); + switch (handle->af_cmd) { + case CAMERASRC_AUTO_FOCUS_CMD_START: + { + camsrc_info("AF CMD:START"); + __CAMERASRC_FUJITSU_GET_AF_CTRL_VAL(handle, &sensor_status); + + switch (sensor_status) { + case CAMERASRC_SENSOR_AF_STATUS_ONGOING: + camsrc_info("FOCUSING. IN PROGRESS..."); + handle->af_status = CAMERASRC_AUTO_FOCUS_STATUS_ONGOING; + break; + case CAMERASRC_SENSOR_AF_STATUS_FOCUSED: /* focus operation success. Go to Null. */ + camsrc_info("FOCUSED. stop autofocusing..."); + + handle->af_status = CAMERASRC_AUTO_FOCUS_STATUS_RELEASED; + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_NULL; + + CAMERASRC_SET_STATE(handle, CAMERASRC_STATE_PREVIEW); + + if (handle->af_cb != NULL) { + if (handle->af_usr_data != NULL) { + handle->af_cb(handle, CAMERASRC_AUTO_FOCUS_RESULT_FOCUSED, handle->af_usr_data); + } else { + handle->af_cb(handle, CAMERASRC_AUTO_FOCUS_RESULT_FOCUSED, NULL); + } + } + + AF_MUT_UNLOCK(handle); + continue; + case CAMERASRC_SENSOR_AF_STATUS_FAILED: /* focus operation failed. Set stop and go to NULL. */ + camsrc_info("FOCUSING FAILED"); + + if (handle->cur_af_mode != CAMERASRC_AF_MODE_CONTINUOUS ) { + SET_CTRL_VAL_ERR(V4L2_CID_CAMERA_SET_AUTO_FOCUS, 0, err); + camsrc_info("Stopping AF done. err = %d", err); + } + + handle->af_status = CAMERASRC_AUTO_FOCUS_STATUS_RELEASED; + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_NULL; + + CAMERASRC_SET_STATE(handle, CAMERASRC_STATE_PREVIEW); + + if (handle->af_cb != NULL) { + if(handle->af_usr_data != NULL) { + handle->af_cb(handle, CAMERASRC_AUTO_FOCUS_RESULT_FAILED, handle->af_usr_data); + } else { + handle->af_cb(handle, CAMERASRC_AUTO_FOCUS_RESULT_FAILED, NULL); + } + } + + AF_MUT_UNLOCK(handle); + continue; + default: + camsrc_error("Unrecognizable status"); + break; + } + break; + } + case CAMERASRC_AUTO_FOCUS_CMD_STOP: + { + camsrc_info("AF CMD:STOP"); + SET_CTRL_VAL_ERR(V4L2_CID_CAMERA_SET_AUTO_FOCUS, 0, err); + handle->af_status = CAMERASRC_AUTO_FOCUS_STATUS_RELEASED; + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_NULL; + camsrc_info("Stopping AF done. err = %d", err); + AF_MUT_UNLOCK(handle); + continue; + } + case CAMERASRC_AUTO_FOCUS_CMD_KILL: + { + camsrc_info("AF CMD:KILL"); + + SET_CTRL_VAL_ERR(V4L2_CID_CAMERA_SET_AUTO_FOCUS, 0, err); + camsrc_info("Stopping AF done. err = %d", err); + + handle->af_status = CAMERASRC_AUTO_FOCUS_STATUS_RELEASED; + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_NULL; + + AF_MUT_UNLOCK(handle); + goto OUT_OF_LOOP; + } + case CAMERASRC_AUTO_FOCUS_CMD_NULL: + default: + { + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + camsrc_info("AF CMD:NULL...."); + err = pthread_cond_wait(&handle->af_wait_cond, &handle->af_mutex); + if (err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("AF CMD pthread_cond_wait - err:(%s)", err_msg); + } + + af_retry_cnt = 0; + + /* Start AF delay for AE */ + if (handle->af_cmd == CAMERASRC_AUTO_FOCUS_CMD_START) { + struct timeval cur_time; + int sec = 0; + int usec = 0; + int diff = 0; /* msec */ + int sleep_time = 0; /* usec */ + + SET_CTRL_VAL_ERR(V4L2_CID_CAMERA_SET_AUTO_FOCUS, 0, err); + + camsrc_info("Check set AF area Time(Delay:%d)", CAMERASRC_AF_DELAY_AFTER_SET_AF_AREA); + + if (handle->set_af_area_time.tv_sec != 0) { + gettimeofday(&cur_time, NULL); + sec = cur_time.tv_sec - handle->set_af_area_time.tv_sec; + usec = cur_time.tv_usec - handle->set_af_area_time.tv_usec; + + camsrc_info("diff sec:%d, usec:%d", sec, usec); + diff = (sec * 1000) + (usec / 1000); + + /* Skip sleep if diff is less than zero or greater than minimum exposure time */ + if (diff < 0 || diff > CAMERASRC_AF_DELAY_AFTER_SET_AF_AREA) { + camsrc_info("no need to sleep(diff: %d ms)", diff); + } else { + sleep_time = (CAMERASRC_AF_DELAY_AFTER_SET_AF_AREA - diff) * 1000; + camsrc_info("usleep(%d)", sleep_time); + usleep(sleep_time); + } + } + } + + AF_MUT_UNLOCK(handle); + continue; + } + } + + AF_MUT_UNLOCK(handle); + usleep(CAMERASRC_AF_INTERVAL); + } + +OUT_OF_LOOP: + camsrc_info("AF thread is finished."); + return NULL; +} + +static int _camerasrc_start_autofocusing(camerasrc_handle_t *handle) +{ + int err; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + camsrc_info("enter"); + + AF_MUT_LOCK(handle); + + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_START; + err = pthread_cond_signal(&handle->af_wait_cond); + if (err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF wait cond err(%s)", err_msg); + } + + AF_MUT_UNLOCK(handle); + + return CAMERASRC_SUCCESS; +} + +static int _camerasrc_stop_autofocusing(camerasrc_handle_t *handle) +{ + int err; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + camsrc_info("enter"); + + AF_MUT_LOCK(handle); + + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_STOP; + err = pthread_cond_signal(&handle->af_wait_cond); + if (err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF wait cond err(%s)", err_msg); + } + + AF_MUT_UNLOCK(handle); + + return CAMERASRC_SUCCESS; +} + +static int _camerasrc_destroy_autofocusing(camerasrc_handle_t *handle) +{ + int err; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + camsrc_info("enter"); + + AF_MUT_LOCK(handle); + + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_KILL; + err = pthread_cond_signal(&handle->af_wait_cond); + if (err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF wait cond err(%s)", err_msg); + } + + AF_MUT_UNLOCK(handle); + + return CAMERASRC_SUCCESS; +} + +static int _camerasrc_release_autofocusing(camerasrc_handle_t *handle) +{ + int err; + camsrc_info("enter"); + + SET_CTRL_VAL_ERR(V4L2_CID_CAMERA_SET_AUTO_FOCUS, 0, err); + + return CAMERASRC_SUCCESS; +} + +static int _camerasrc_copy_frame(camerasrc_handle_t *handle, camerasrc_buffer_t *src_buffer, camerasrc_buffer_t *dst_buffer, int isThumbnail) +{ + if (handle == NULL || src_buffer == NULL || dst_buffer == NULL) { + camsrc_error("handle[%p], src_buffer[%p], dst_buffer[%p]", + handle, src_buffer, dst_buffer); + return CAMERASRC_ERR_NULL_POINTER; + } + + if (src_buffer->start == NULL || dst_buffer->start == NULL) { + camsrc_error("src_buffer->start[%p], dst_buffer->start[%p]", + src_buffer->start, dst_buffer->start); + return CAMERASRC_ERR_NULL_POINTER; + } + + if (handle->format.colorspace == CAMERASRC_COL_RAW) { + int cpy_len; + + if (handle->format.pix_format == CAMERASRC_PIX_YUV422P || + handle->format.pix_format == CAMERASRC_PIX_YUY2 || + handle->format.pix_format == CAMERASRC_PIX_UYVY) { + cpy_len = (YUV422_SIZE(handle)>=src_buffer->length)?src_buffer->length:YUV422_SIZE(handle); + } else if (handle->format.pix_format == CAMERASRC_PIX_YUV420P || + handle->format.pix_format == CAMERASRC_PIX_YUV420 || + handle->format.pix_format == CAMERASRC_PIX_NV12) { + cpy_len = (YUV420_SIZE(handle)>=src_buffer->length)?src_buffer->length:YUV420_SIZE(handle); + } else { + camsrc_error("UNSUPPORTED format [%x]", handle->format.pix_format ); + return CAMERASRC_ERR_INVALID_FORMAT; + } + +#if defined (USE_FRAME_COPY_BOUNDARY_CHECK) + camsrc_info("Boundary check %p ~ %p ... [length = %d] ", dst_buffer->start, dst_buffer->start+cpy_len, cpy_len); + memset(dst_buffer->start, 0, cpy_len); + camsrc_info("Boundary check OK"); +#endif + + camsrc_info("RAW frame dequeing..."); + dst_buffer->length = cpy_len; + + if (handle->format.pix_format == CAMERASRC_PIX_SN12) { + camsrc_error("Can't copy the frame with SN12 option"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } else if (handle->format.pix_format == CAMERASRC_PIX_ST12) { + camsrc_error("Can't copy the frame with ST12 option"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + camsrc_error("format[%d] copy occured. copy len = %d", handle->format.pix_format, cpy_len); + memcpy(dst_buffer->start, src_buffer->start, cpy_len ); + } else if (handle->format.colorspace == CAMERASRC_COL_JPEG) { +#if defined (USE_FRAME_COPY_BOUNDARY_CHECK) + camsrc_info("Boundary check %p ~ %p ...", dst_buffer->start, dst_buffer->start+src_buffer->length); + memset(dst_buffer->start, 0, src_buffer->length); + camsrc_info("Boundary check OK"); +#endif + + if (!isThumbnail) { + if (src_buffer->length <= 0) { + camsrc_error("length[%d] is too small", src_buffer->length ); + return CAMERASRC_ERR_INVALID_VALUE; + } + + dst_buffer->length = src_buffer->length; + camsrc_info("JPEG main frame copy... img length = %d", dst_buffer->length); + memcpy(dst_buffer->start, src_buffer->start, dst_buffer->length); + camsrc_info("JPEG main frame copy done."); + } else { + if (handle->format.pix_format == CAMERASRC_PIX_RGGB8) { + /* JPEG + JPEG */ + if (src_buffer->length <= 0) { + camsrc_error("length[%d] is too small", src_buffer->length ); + return CAMERASRC_ERR_INVALID_VALUE; + } + + dst_buffer->length = src_buffer->length; + camsrc_info("JPEG thm frame(JPEG) copy... img length = %d", dst_buffer->length); + memcpy(dst_buffer->start, src_buffer->start, dst_buffer->length); + camsrc_info("JPEG thm frame(JPEG) copy done."); + } else if (handle->format.pix_format == CAMERASRC_PIX_RGGB10) { + /* JPEG + YUV */ + dst_buffer->length = CAMERASRC_YUV_THMBNL_SIZE; + camsrc_info("JPEG thm frame(YUV) copy... img length = %d", CAMERASRC_YUV_THMBNL_SIZE); + memcpy(dst_buffer->start, src_buffer->start, CAMERASRC_YUV_THMBNL_SIZE); + camsrc_info("JPEG thm frame(YUV) copy done."); + } else { + camsrc_info("Unknown format [%d]", handle->format.pix_format ); + return CAMERASRC_ERR_INVALID_FORMAT; + } + } + } + + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_set_thumbnail_size(camerasrc_handle_t *handle) +{ + camsrc_info("enter"); + + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +} + +static int _camerasrc_start_facedetection (camerasrc_handle_t *handle) +{ + camsrc_info("enter"); + camsrc_info("FACE DETECTION START!"); + SET_CTRL_VAL(V4L2_CID_FACE_DETECTION, CAM_FACE_DETECTION_ON); + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_stop_facedetection (camerasrc_handle_t *handle) +{ + camsrc_info("enter"); + camsrc_info("FACE DETECTION STOP!"); + SET_CTRL_VAL(V4L2_CID_FACE_DETECTION, CAM_FACE_DETECTION_OFF); + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_check_emp_shock(camerasrc_handle_t *handle, int *check_val) +{ + camsrc_info("enter"); + int ret_value = 0; + + GET_CTRL_VAL(V4L2_CID_ESD_INT, ret_value); + *check_val = ret_value; + + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_get_frame_data(camerasrc_handle_t *handle, camerasrc_frame_data_t *data) +{ + /*camsrc_info("enter");*/ + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control control; + + /* Get Y physical address */ + /*camsrc_info("[VIDIOC_G_CTRL] << [V4L2_CID_PADDR_Y] request with value");*/ + control.id = V4L2_CID_PADDR_Y; + control.value = data->index; + err = _camerasrc_ioctl(handle, VIDIOC_S_CTRL, &control); + if (err != CAMERASRC_SUCCESS) { + return err; + } + + data->phyAddrY = control.value; + + /* Get CbCr physical address */ + /*camsrc_info("[VIDIOC_G_CTRL] << [V4L2_CID_PADDR_CBCR] request with value");*/ + control.id = V4L2_CID_PADDR_CBCR; + control.value = data->index; + err = _camerasrc_ioctl(handle, VIDIOC_S_CTRL, &control); + if (err != CAMERASRC_SUCCESS) { + return err; + } + + data->phyAddrCbCr = control.value; + + /* Distance between Y ptr and CbCr ptr of virtual address is same with that of Physical one. */ + data->virAddrY = (unsigned int)handle->buffer[data->index].start; + data->virAddrCbCr = data->virAddrY + (data->phyAddrCbCr - data->phyAddrY); + + /*camsrc_info("virAddrY(%p), virAddrCbCr(%p)", data->virAddrY, data->virAddrCbCr);*/ + + return CAMERASRC_SUCCESS; +} + + +static void _dump_exif_info(camerasrc_exif_t *exif_struct) +{ + camsrc_info("== Dynamic value =="); + camsrc_info("unsigned int exposure_time_numerator = %d", exif_struct->exposure_time_numerator); + camsrc_info("unsigned int exposure_time_denominator = %d", exif_struct->exposure_time_denominator); + camsrc_info("int shutter_speed_numerator = %d", exif_struct->shutter_speed_numerator); + camsrc_info("int shutter_speed_denominator = %d", exif_struct->shutter_speed_denominator); + camsrc_info("int brigtness_numerator = %d", exif_struct->brigtness_numerator); + camsrc_info("int brightness_denominator = %d", exif_struct->brightness_denominator); + camsrc_info("unsigned short int iso = %d", exif_struct->iso); + camsrc_info("unsigned short int flash = %d", exif_struct->flash); + camsrc_info("int metering_mode = %d", exif_struct->metering_mode); + camsrc_info("int exif_image_width = %d", exif_struct->exif_image_width); + camsrc_info("int exif_image_height = %d", exif_struct->exif_image_height); + camsrc_info("int exposure_bias_in_APEX = %d", exif_struct->exposure_bias_in_APEX); + camsrc_info("int software_used = %d", exif_struct->software_used); + camsrc_info("int focal_len_numerator = %d", exif_struct->focal_len_numerator); + camsrc_info("int focal_len_denominator = %d", exif_struct->focal_len_denominator); + camsrc_info("int aperture_f_num_numerator = %d", exif_struct->aperture_f_num_numerator); + camsrc_info("int aperture_f_num_denominator = %d", exif_struct->aperture_f_num_denominator); + camsrc_info("int aperture_in_APEX = %d", exif_struct->aperture_in_APEX); + camsrc_info("int max_lens_aperture_in_APEX = %d", exif_struct->max_lens_aperture_in_APEX); + + camsrc_info("== Fixed value =="); + camsrc_info("int component_configuration = %x", exif_struct->component_configuration); + camsrc_info("int colorspace = %d", exif_struct->colorspace); + + return; +} + + +static int _camerasrc_get_exif_info (camerasrc_handle_t *handle, camerasrc_exif_t *exif_struct) +{ + int photometry_mode = V4L2_PHOTOMETRY_MULTISEG; + + if (exif_struct == NULL) { + return CAMERASRC_ERR_INVALID_PARAMETER; + } + + /** Dynamic value **/ + + /* exposure time */ + GET_CTRL_VAL(V4L2_CID_CAMERA_EXIF_EXPTIME, exif_struct->exposure_time_numerator); + exif_struct->exposure_time_denominator = 1; + + /* shutter speed */ + GET_CTRL_VAL(V4L2_CID_CAMERA_EXIF_TV, exif_struct->shutter_speed_numerator); + exif_struct->shutter_speed_denominator = 1; + + /* brightness */ + GET_CTRL_VAL(V4L2_CID_CAMERA_EXIF_BV, exif_struct->brigtness_numerator); + exif_struct->brightness_denominator = 1; + + /* iso */ + GET_CTRL_VAL(V4L2_CID_CAMERA_EXIF_ISO, exif_struct->iso); + ISO_APPROXIMATE_VALUE(exif_struct->iso, exif_struct->iso); + + /* flash */ + GET_CTRL_VAL(V4L2_CID_CAMERA_EXIF_FLASH, exif_struct->flash); + + /* image size */ + exif_struct->exif_image_width = handle->format.img_size.dim.width; + exif_struct->exif_image_height = handle->format.img_size.dim.height; + + /*FIXME focal length - Set fixed value at gst_camerasrc_control_get_exif_info function */ + exif_struct->focal_len_numerator = 1; + exif_struct->focal_len_denominator = 1; + + /*FIXME f number - Set fixed value at gst_camerasrc_control_get_exif_info function */ + exif_struct->aperture_f_num_numerator = 1; + exif_struct->aperture_f_num_denominator = 1; + + /* FIXME APEX */ + exif_struct->aperture_in_APEX \ + = CAMERASRC_EXIF_APERTURE_VALUE_IN_APEX(exif_struct->aperture_f_num_numerator, exif_struct->aperture_f_num_denominator); + exif_struct->max_lens_aperture_in_APEX = 1; + /*= CAMERASRC_EXIF_APERTURE_VALUE_IN_APEX(exif_info.max_aperture_f_num_numerator, exif_info.max_aperture_f_num_denominator);*/ + exif_struct->exposure_bias_in_APEX = exif_struct->aperture_in_APEX \ + + CAMERASRC_EXIF_SHUTTERSPEED_VALUE_IN_APEX(exif_struct->exposure_time_numerator, exif_struct->exposure_time_denominator); + + /* Get the value using CID */ + /* Not implemented yet + GET_CTRL_VAL(V4L2_CID_FW_VERSION, exif_struct->software_used); + */ + GET_CTRL_VAL(V4L2_CID_PHOTOMETRY, photometry_mode); + PHOTOMETRY_MODE_TO_METERING_MODE(photometry_mode, exif_struct->metering_mode); + + /** Fixed value **/ + exif_struct->component_configuration = _CAMERASRC_EXIF_COMP_CONF; + exif_struct->colorspace = _CAMERASRC_EXIF_COLORSPACE; + + _dump_exif_info(exif_struct); + + return CAMERASRC_SUCCESS; +} + +static int fd_on = 0; + +static int _camerasrc_set_cmd(camerasrc_handle_t *handle, _camsrc_cmd_t cmd, void *value) +{ + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_jpegcompression comp_arg; + + switch (cmd) { + case _CAMERASRC_CMD_STROBE_MODE: + { + camerasrc_strobe_mode_t *mode = (camerasrc_strobe_mode_t*)value; + + camsrc_info("[_CAMERASRC_CMD_STROBE_MODE] cmd set value %d", *mode ); + + SET_CTRL_VAL(V4L2_CID_CAMERA_FLASH_MODE, *mode); + } + break; + case _CAMERASRC_CMD_FACEDETECTION: + { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_recognition recog; + + camsrc_info("[_CAMERASRC_CMD_FACEDETECTION] cmd set"); + if (((int)value) == _CAMERASRC_FACEDETECTION_START) { + camsrc_info("[_CAMERASRC_CMD_FACEDETECTION] start"); + recog.mode = V4L2_RECOGNITION_MODE_ON; + recog.pattern = V4L2_RECOG_PATTERN_FACE; + recog.obj_num = 10; + /*recog.detect_idx = 0;*/ + recog.action= V4L2_RECOGNITION_ACTION_NONE; + fd_on = 1; + } else if (((int)value) == _CAMERASRC_FACEDETECTION_STOP) { + camsrc_error("[_CAMERASRC_CMD_FACEDETECTION] stop"); + recog.mode = V4L2_RECOGNITION_MODE_OFF; + recog.pattern = V4L2_RECOG_PATTERN_FACE; + recog.obj_num = 10; + /*recog.detect_idx = 0;*/ + recog.action= V4L2_RECOGNITION_ACTION_NONE; + fd_on = 0; + } else { + camsrc_error("[_CAMERASRC_CMD_FACEDETECTION] not support cmd"); + } + + err = _camerasrc_ioctl(handle, VIDIOC_S_RECOGNITION, &recog); + if (err != CAMERASRC_SUCCESS) { + goto ERROR; + } + } + break; + case _CAMERASRC_CMD_SHUTTER_SPEED: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_SHUTTER_SPEED] cmd set"); + break; + case _CAMERASRC_CMD_JPEG_LENGTH: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_JPEG_LENGTH] cmd set"); + break; + case _CAMERASRC_CMD_JPEG_THMBNL_LENGTH: + camsrc_info("[_CAMERASRC_CMD_JPEG_THMBNL_LENGTH] cmd set"); + err = _camerasrc_set_thumbnail_size(handle); + if (err != CAMERASRC_SUCCESS) { + goto ERROR; + } + break; + case _CAMERASRC_CMD_EXPOSURE_VALUE: + camsrc_info("[_CAMERASRC_CMD_EXPOSURE_VALUE] cmd set"); + /* WRITEME */ + break; + case _CAMERASRC_CMD_ESD_CHECK: + camsrc_info("[_CAMERASRC_CMD_ESD_CHECK] cmd set"); + /* WRITEME */ + break; + case _CAMERASRC_CMD_CTRL: + camsrc_info("[_CAMERASRC_CMD_CTRL] cmd set"); + SET_CTRL_VAL(_CAMERASRC_GET_CID(((_camerasrc_ctrl_t *) value)->cid, handle->cur_dev_id), ((_camerasrc_ctrl_t *) value)->value); + break; + case _CAMERASRC_CMD_SUPPORT_EMBED_EXIF: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_SUPPORT_EMBED_EXIF] cmd set"); + break; + case _CAMERASRC_CMD_SUPPORT_JPEG_ENCODING: + camsrc_warning("[_CAMERASRC_CMD_SUPPORT_JPEG_ENCODING] cmd set isn't supported"); + break; + case _CAMERASRC_CMD_AF_CONTROL: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_AF_CONTROL] cmd set(value=%d)", value); + + /* FIXME : Please fix whole AF implementation!!! */ + switch ((int)value) { + case _CAMERASRC_AF_START: + _camerasrc_start_autofocusing(handle); + break; + case _CAMERASRC_AF_STOP: + _camerasrc_stop_autofocusing(handle); + break; + case _CAMERASRC_AF_DESTROY: + _camerasrc_destroy_autofocusing(handle); + break; + case _CAMERASRC_AF_RELEASE: + case _CAMERASRC_AF_INIT: + default: + _camerasrc_init_autofocusing_mode(handle); + break; + } + break; + case _CAMERASRC_CMD_AF_AREA: + { + camerasrc_rect_t *rect = (camerasrc_rect_t *)value; + + camsrc_info("[_CAMERASRC_CMD_AF_AREA] cmd set (%d,%d,%dx%d)", + rect->x, rect->y, rect->width, rect->height); + + SET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT, rect->x); + SET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP, rect->y); + SET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH, 0);/*rect->width); Not supported */ + SET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT, 0);/*rect->height); Not supported */ + + if (gettimeofday(&handle->set_af_area_time, NULL) == 0) { + camsrc_info("[_CAMERASRC_CMD_AF_AREA] Get Time Success" ); + } else { + handle->set_af_area_time.tv_sec = 0; + handle->set_af_area_time.tv_usec = 0; + camsrc_warning("[_CAMERASRC_CMD_AF_AREA] Get Time Failed" ); + } + break; + } + case _CAMERASRC_CMD_FRAME_DATA: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_FRAME_DATA] cmd set"); + break; + case _CAMERASRC_CMD_EXIF_INFO: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_EXIF_INFO] cmd set"); + break; + case _CAMERASRC_CMD_CHECK_ESD: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_CHECK_ESD] cmd set"); + break; + case _CAMERASRC_CMD_JPEG_COMPRESS_RATIO: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_JPEG_COMPRESS_RATIO] cmd set, val = %d", (int)(*((unsigned int*) value))); + if (handle->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY) { + comp_arg.quality = (int)(*((unsigned int*) value)); + err = _camerasrc_ioctl(handle, VIDIOC_S_JPEGCOMP, &comp_arg); + if (err != CAMERASRC_SUCCESS) { + goto ERROR; + } + } else if (handle->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) { + err = CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + goto ERROR; + } + break; + case _CAMERASRC_CMD_ROTATION: + { + int *rotate = (int *)value; + camsrc_info("[_CAMERASRC_CMD_ROTATION] cmd set : %d", *rotate); + SET_CTRL_VAL(V4L2_CID_ROTATION, (int)*rotate); + } + break; + case _CAMERASRC_CMD_SENSOR_MODE: + { + camerasrc_sensor_mode_t *mode = (camerasrc_sensor_mode_t *)value; + camsrc_info("[_CAMERASRC_CMD_SENSOR_MODE] cmd set : %d", *mode); + SET_CTRL_VAL(V4L2_CID_CAMERA_SENSOR_MODE, (int)*mode); + } + break; + case _CAMERASRC_CMD_VFLIP: + { + int *vflip = (int *)value; + camsrc_info("[_CAMERASRC_CMD_VFLIP] cmd set : %d", *vflip); + SET_CTRL_VAL(V4L2_CID_VFLIP, (int)*vflip); + } + break; + case _CAMERASRC_CMD_HFLIP: + { + int *hflip = (int *)value; + camsrc_info("[_CAMERASRC_CMD_HFLIP] cmd set : %d", *hflip); + SET_CTRL_VAL(V4L2_CID_HFLIP, (int)*hflip); + } + break; + default: + camsrc_error("[_CAMERASRC_CMD_UNKNOWN] cmd set"); + err = CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + goto ERROR; + } + + return CAMERASRC_SUCCESS; + +ERROR: + camsrc_error("cmd execution error occured"); + + return err; +} + +static int _camerasrc_get_cmd(camerasrc_handle_t *handle, _camsrc_cmd_t cmd, void *value) +{ + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_jpegcompression comp_arg; + + if (!value) { + camsrc_error("value is NULL"); + return CAMERASRC_ERR_NULL_POINTER; + } + + switch (cmd) { + case _CAMERASRC_CMD_SUPPORT_EMBED_EXIF: + camsrc_info("[_CAMERASRC_CMD_SUPPORT_EMBED_EXIF] cmd get"); + *((int*)value) = _CAMERASRC_CMD_SUPPORT_EMBED_EXIF_DEF; + break; + case _CAMERASRC_CMD_SUPPORT_JPEG_ENCODING: + camsrc_info("[_CAMERASRC_CMD_SUPPORT_JPEG_ENCODING] cmd get(cur_dev_id=%d)", handle->cur_dev_id); + if (handle->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY) { + *((int*)value) = 1; + } else { + *((int*)value) = 0; + } + break; + case _CAMERASRC_CMD_STROBE_MODE: + { + camerasrc_strobe_mode_t mode; + + GET_CTRL_VAL(V4L2_CID_CAMERA_FLASH_MODE, mode); + *((camerasrc_strobe_mode_t*)value) = mode; + + camsrc_info("[_CAMERASRC_CMD_STROBE_MODE] cmd get - %d", mode); + } + break; + case _CAMERASRC_CMD_FACEDETECTION: + camsrc_info("[_CAMERASRC_CMD_FACEDETECTION] cmd get - %d", fd_on); + *(int *)value = fd_on; + break; + case _CAMERASRC_CMD_SHUTTER_SPEED: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_SHUTTER_SPEED] cmd get"); + break; + case _CAMERASRC_CMD_JPEG_LENGTH: + { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control ctrl; + + ctrl.id = V4L2_CID_CAM_JPEG_MAIN_SIZE; + err = _camerasrc_ioctl( handle, VIDIOC_G_CTRL, &ctrl ); + if (err != CAMERASRC_SUCCESS) { + *((int*)value) = 0; + goto ERROR; + } + + *((int*)value) = ctrl.value; + camsrc_info("[_CAMERASRC_CMD_JPEG_LENGTH] cmd get"); + break; + } + case _CAMERASRC_CMD_JPEG_THMBNL_LENGTH: + { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control ctrl; + + ctrl.id = V4L2_CID_CAM_JPEG_THUMB_SIZE; + err = _camerasrc_ioctl( handle, VIDIOC_G_CTRL, &ctrl ); + if (err != CAMERASRC_SUCCESS) { + *((int*)value) = 0; + goto ERROR; + } + + *((int*)value) = ctrl.value; + camsrc_info("[_CAMERASRC_CMD_JPEG_THMBNL_LENGTH] cmd get : %d", *((int*)value)); + break; + } + case _CAMERASRC_CMD_JPEG_THMBNL_OFFSET: + { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control ctrl; + ctrl.id = V4L2_CID_CAM_JPEG_THUMB_OFFSET; + + err = _camerasrc_ioctl( handle, VIDIOC_G_CTRL, &ctrl ); + if(err != CAMERASRC_SUCCESS) + { + *((int*)value) = 0; + goto ERROR; + } + + *((int*)value) = ctrl.value; + camsrc_info("[_CAMERASRC_CMD_JPEG_THMBNL_OFFSET] cmd get : %x", *((int*)value)); + break; + } + case _CAMERASRC_CMD_JPEG_SCRNL_LENGTH: + { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control ctrl; + ctrl.id = V4L2_CID_CAM_JPEG_POSTVIEW_SIZE; + + err = _camerasrc_ioctl(handle, VIDIOC_G_CTRL, &ctrl); + if (err != CAMERASRC_SUCCESS) { + *((int*)value) = 0; + goto ERROR; + } + + *((int*)value) = ctrl.value; + camsrc_info("[_CAMERASRC_CMD_JPEG_SCRNL_LENGTH] cmd get : %x", *((int*)value)); + break; + } + case _CAMERASRC_CMD_JPEG_SCRNL_OFFSET: + { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control ctrl; + ctrl.id = V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET; + + err = _camerasrc_ioctl( handle, VIDIOC_G_CTRL, &ctrl ); + if (err != CAMERASRC_SUCCESS) { + *((int*)value) = 0; + goto ERROR; + } + + *((int*)value) = ctrl.value; + camsrc_info("[_CAMERASRC_CMD_JPEG_SCRNL_OFFSET] cmd get : %x", *((int*)value)); + break; + } + case _CAMERASRC_CMD_EXPOSURE_VALUE: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_EXPOSURE_VALUE] cmd get"); + break; + case _CAMERASRC_CMD_ESD_CHECK: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_ESD_CHECK] cmd get"); + break; + case _CAMERASRC_CMD_CTRL: + camsrc_info("[_CAMERASRC_CMD_CTRL] cmd get"); + GET_CTRL_VAL(_CAMERASRC_GET_CID(((_camerasrc_ctrl_t *) value)->cid, handle->cur_dev_id), ((_camerasrc_ctrl_t *) value)->value); + break; + case _CAMERASRC_CMD_AF_CONTROL: + /* WRITEME */ + camsrc_info("[_CAMERASRC_CMD_AF_CONTROL] cmd get"); + break; + case _CAMERASRC_CMD_AF_AREA: + { + camerasrc_rect_t* rect = (camerasrc_rect_t*)value; + + GET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_LEFT, rect->x); + GET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_TOP, rect->y); + GET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_WIDTH, rect->width); + GET_CTRL_VAL(V4L2_CID_FOCUS_AUTO_RECTANGLE_HEIGHT, rect->height); + + camsrc_info("[_CAMERASRC_CMD_AF_AREA] cmd get (%d,%d,%dx%d)", + rect->x, rect->y, rect->width, rect->height); + break; + } + case _CAMERASRC_CMD_FRAME_DATA: + /* WRITEME */ + /*camsrc_info("[_CAMERASRC_CMD_FRAME_DATA] cmd get");*/ + err = _camerasrc_get_frame_data(handle, (camerasrc_frame_data_t*)value); + if (err != CAMERASRC_SUCCESS) { + goto ERROR; + } + break; + case _CAMERASRC_CMD_EXIF_INFO: + camsrc_info("[_CAMERASRC_CMD_EXIF_INFO] cmd get"); + err = _camerasrc_get_exif_info (handle, (camerasrc_exif_t*)value); + if (err != CAMERASRC_SUCCESS) { + goto ERROR; + } + break; + case _CAMERASRC_CMD_CHECK_ESD: + camsrc_info("[_CAMERASRC_CMD_CHECK_ESD] cmd get"); + GET_CTRL_VAL(V4L2_CID_ESD_INT, *((int *) value)); + break; + case _CAMERASRC_CMD_JPEG_COMPRESS_RATIO: + camsrc_info("[_CAMERASRC_CMD_JPEG_COMPRESS_RATIO] cmd get"); + err = _camerasrc_ioctl(handle, VIDIOC_G_JPEGCOMP, &comp_arg); + if (err != CAMERASRC_SUCCESS) { + goto ERROR; + } + *((unsigned int*)value) = (int)comp_arg.quality; + break; + case _CAMERASRC_CMD_ROTATION: + camsrc_info("[_CAMERASRC_CMD_ROTATION] cmd get"); + GET_CTRL_VAL(V4L2_CID_ROTATION, *(int*)value); + break; + case _CAMERASRC_CMD_SENSOR_MODE: + camsrc_info("[_CAMERASRC_CMD_SENSOR_MODE] cmd get"); + GET_CTRL_VAL(V4L2_CID_CAMERA_SENSOR_MODE, *(int*)value); + break; + case _CAMERASRC_CMD_VFLIP: + camsrc_info("[_CAMERASRC_CMD_VFLIP] cmd get"); + GET_CTRL_VAL(V4L2_CID_VFLIP, *(int*)value); + break; + case _CAMERASRC_CMD_HFLIP: + camsrc_info("[_CAMERASRC_CMD_HFLIP] cmd get"); + GET_CTRL_VAL(V4L2_CID_HFLIP, *(int*)value); + break; + default: + camsrc_error("[_CAMERASRC_CMD_UNKNOWN] cmd get"); + err = CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + goto ERROR; + } + + return CAMERASRC_SUCCESS; + +ERROR: + camsrc_error("cmd execution error occured"); + + return err; +} + +static const CAMERASRC_DEV_DEPENDENT_MISC_FUNC dev_misc_functions = { + ._ioctl = _camerasrc_ioctl, + ._ioctl_once = _camerasrc_ioctl_once, + ._run_autofocusing = _camerasrc_run_autofocusing, + ._skip_frame = _camerasrc_skip_frame, + ._copy_frame = _camerasrc_copy_frame, + ._set_cmd = _camerasrc_set_cmd, + ._get_cmd = _camerasrc_get_cmd, +}; + +const CAMERASRC_DEV_DEPENDENT_MISC_FUNC *dev_misc_func = &dev_misc_functions; diff --git a/camerasrc/src/camerasrc.c b/camerasrc/src/camerasrc.c new file mode 100644 index 0000000..00d5de9 --- /dev/null +++ b/camerasrc/src/camerasrc.c @@ -0,0 +1,4870 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "camerasrc-common.h" +#include "camerasrc-internal.h" +#include <semaphore.h> + +#define BUF_LEN 64 +#define ITLV_DATA_INFO_OFFSET 0x1000 +#define EMBEDDED_OFFSET (2040*2+4) + +/* extended V4L2 API */ +#ifndef V4L2_PIX_FMT_INTERLEAVED +#define V4L2_PIX_FMT_INTERLEAVED v4l2_fourcc('I', 'T', 'L', 'V') +#endif /* V4L2_PIX_FMT_INTERLEAVED */ + +#ifndef V4L2_CID_IS_S_SCENARIO_MODE +#define V4L2_CID_IS_S_SCENARIO_MODE (V4L2_CID_FIMC_IS_BASE + 15) +#define V4L2_CID_IS_S_FORMAT_SCENARIO (V4L2_CID_FIMC_IS_BASE + 16) +enum scenario_mode { + IS_MODE_PREVIEW_STILL, + IS_MODE_PREVIEW_VIDEO, + IS_MODE_CAPTURE_STILL, + IS_MODE_CAPTURE_VIDEO, + IS_MODE_MAX +}; +#endif /* V4L2_CID_IS_S_SCENARIO_MODE */ + +#ifndef V4L2_CID_EMBEDDEDDATA_ENABLE +#define V4L2_CID_EMBEDDEDDATA_ENABLE (V4L2_CID_PRIVATE_BASE + 130) +#endif /* V4L2_CID_EMBEDDEDDATA_ENABLE */ + +/* + * LOCAL DEFINITIONS + */ +#ifndef EXPORT_API +#define EXPORT_API __attribute__((__visibility__("default"))) +#endif + +#define LOCK(p) {\ + if(0 != pthread_mutex_lock(&(p->mutex))) {\ + camsrc_error("Mutex locking error");\ + camsrc_assert(0);\ + }\ +} + +#define UNLOCK(p) {\ + if(0 != pthread_mutex_unlock(&(p->mutex))) {\ + camsrc_error("Mutex unlocking error");\ + camsrc_assert(0);\ + }\ +} + +extern const CAMERASRC_DEV_DEPENDENT_MISC_FUNC *dev_misc_func; + +/** proto type of internal function **/ +int _camerasrc_get_JPG_length(camerasrc_handle_t *handle); +int _camerasrc_get_thumbnail_JPG_length(camerasrc_handle_t *handle); +int _camerasrc_get_thumbnail_JPG_offset(camerasrc_handle_t *handle); +int _camerasrc_get_screennail_JPG_length(camerasrc_handle_t *handle); +int _camerasrc_get_screennail_JPG_offset(camerasrc_handle_t *handle); +int _camerasrc_set_thumbnail_size(camerasrc_handle_t *handle); +int _camerasrc_check_emp_shock(camerasrc_handle_t *handle, int *check_val); +int _camerasrc_set_jpeg_compress_ratio(camerasrc_handle_t *handle, unsigned int quality); +int _camerasrc_ioctl(camerasrc_handle_t *handle, int request, void *arg); +int _camerasrc_ioctl_once(camerasrc_handle_t *handle, int request, void *arg); +void *_camerasrc_run_autofocusing(camerasrc_handle_t *handle); +int _camerasrc_skip_frame(camerasrc_handle_t *handle, long int timeout, int skip_frame); + +/**** A U T O F O C U S I N G F U N C T I O N S ****/ +int _camerasrc_set_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect); +int _camerasrc_get_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect); +int _camerasrc_start_autofocusing(camerasrc_handle_t *handle); +int _camerasrc_stop_autofocusing(camerasrc_handle_t *handle); +int _camerasrc_release_autofocusing(camerasrc_handle_t *handle); +int _camerasrc_destroy_autofocusing(camerasrc_handle_t *handle); +int _camerasrc_init_autofocusing_mode(camerasrc_handle_t *handle); + +int _camerasrc_get_frame_data(camerasrc_handle_t *handle, camerasrc_frame_data_t *data); +int _camerasrc_get_exif_info(camerasrc_handle_t *handle, camerasrc_buffer_t *exif_string); +int _camerasrc_copy_frame(camerasrc_handle_t *handle, camerasrc_buffer_t *src_buffer, camerasrc_buffer_t *dst_buffer, int isThumbnail); +int _camerasrc_query_ctrl_menu(camerasrc_handle_t *handle, struct v4l2_queryctrl queryctrl, camerasrc_ctrl_info_t *ctrl_info); + + +#if 1 +typedef struct { + char *key_path; + int key_prefix; +} camerasrc_sync_param_t; + +int camsrc_create_sync(const camerasrc_sync_param_t *param) +{ + sem_t *sem = NULL; + + sem = sem_open(param->key_path, O_CREAT, 0666, 1); + if (sem == SEM_FAILED) { + switch (errno) { + case EACCES: + camsrc_error("The semaphore already exist, but caller does not have permission %s", param->key_path); + break; + case ENOMEM: + camsrc_error("Insufficient memory"); + break; + case ENFILE: + camsrc_error("Too many open files in system"); + break; + default: + camsrc_critical("Semaphore create fail! (name:%s, errno %d)", param->key_path, errno); + } + + return CAMERASRC_ERR_INTERNAL; + } + + return CAMERASRC_SUCCESS; +} + +int camsrc_remove_sync(const camerasrc_sync_param_t *param) +{ + int err = 0; + + err = sem_unlink(param->key_path); + if (err == -1) { + camsrc_critical("Semaphore destroy Fail! (name:%s, errno %d)", param->key_path, errno); + return CAMERASRC_ERR_INTERNAL; + } + + return CAMERASRC_SUCCESS; +} + +int camsrc_lock_sync(const camerasrc_sync_param_t *param) +{ + sem_t *sem = NULL; + int ret; + int err = CAMERASRC_SUCCESS; + int sem_value = -1; + struct timespec wait_time; + + sem = sem_open(param->key_path, O_CREAT, 0666, 1); + if (sem == SEM_FAILED) + { + camsrc_critical("Semaphore open Fail! (name:%s, errno %d)", param->key_path, errno); + return CAMERASRC_ERR_INTERNAL; + } + +retry_lock: + wait_time.tv_sec = (long int)(time(NULL)) + 6; + wait_time.tv_nsec = 0; + + ret = sem_timedwait(sem, &wait_time); + if (ret == -1) { + switch (errno) { + case EINTR: + camsrc_critical("Lock RETRY LOCK"); + goto retry_lock; + break; + case EINVAL: + camsrc_critical("Invalid semaphore"); + err = CAMERASRC_ERR_INTERNAL; + break; + case EAGAIN: + camsrc_critical("EAGAIN"); + err = CAMERASRC_ERR_INTERNAL; + break; + case ETIMEDOUT: + camsrc_critical("sem_wait leached %d seconds timeout.", 6); + /* Recovery of sem_wait lock....in abnormal condition */ + if (0 == sem_getvalue(sem, &sem_value)) { + camsrc_critical("%s sem value is %d",param->key_path, sem_value); + if (sem_value == 0) { + ret = sem_post(sem); + if (ret == -1) { + camsrc_critical("sem_post error %s : %d", param->key_path, sem_value); + } else { + camsrc_critical("lock recovery success...try lock again"); + goto retry_lock; + } + } else { + camsrc_critical("sem value is not 0. but failed sem_timedwait so retry.. : %s",param->key_path); + usleep(5); + goto retry_lock; + } + } else { + camsrc_critical("sem_getvalue failed : %s",param->key_path); + } + err = CAMERASRC_ERR_INTERNAL; + break; + } + } + sem_close(sem); + return err; +} + +int camsrc_unlock_sync(const camerasrc_sync_param_t *param) +{ + sem_t *sem = NULL; + int ret; + int err = CAMERASRC_SUCCESS; + + sem = sem_open(param->key_path, O_CREAT, 0666, 1); + if (sem == SEM_FAILED) { + camsrc_critical("Semaphore open Fail! (name:%s, errno %d)", param->key_path, errno); + return CAMERASRC_ERR_INTERNAL; + } + + ret = sem_post(sem); + if (ret == -1) { + camsrc_critical("UNLOCK FAIL"); + err = CAMERASRC_ERR_INTERNAL; + } + + sem_close(sem); + return err; +} +#endif + + +#if defined(USE_CAMERASRC_FRAME_DUMP) +#define WRITE_UNIT 4096 +static int seq_no = 0; + +static void write_buffer_into_path(camerasrc_buffer_t *buffer, char *path, char *name) +{ + int fd = -1; + int write_len = 0; + char temp_fn[255]; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + sprintf(temp_fn, "%s/%s", path, name); + + fd = open(temp_fn, O_CREAT | O_WRONLY | O_SYNC); + + if(fd == -1) { + strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("OPEN ERR!!!! : %s", err_msg); + camsrc_assert(0); + } else { + camsrc_info("Open success, FD = %d, seq = %d", fd, seq_no); + } + + int write_remain = buffer->length; + int offset = 0; + + while (write_remain > 0) { + write_len = write(fd, buffer->start + offset, write_remain<WRITE_UNIT?write_remain:WRITE_UNIT); + if (write_len < 0) { + strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("WRITE ERR!!!! : %s", err_msg); + camsrc_assert(0); + } else { + write_remain -= write_len; + offset+= write_len; + camsrc_info("%d written, %d left", write_len, write_remain); + } + } + + close(fd); +} +#endif + +#define CAMERASRC_SET_CMD(cmd, value) _camerasrc_set_cmd(handle, cmd, (void*)value); +#define CAMERASRC_GET_CMD(cmd, value) _camerasrc_get_cmd(handle, cmd, (void*)value); + + +static int _camerasrc_set_cmd(camsrc_handle_t handle, _camsrc_cmd_t cmd, void *value) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (dev_misc_func->_set_cmd == NULL) { + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + err = dev_misc_func->_set_cmd(p, cmd, value); + + return err; +} + +static int _camerasrc_get_cmd(camsrc_handle_t handle, _camsrc_cmd_t cmd, void *value) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if(dev_misc_func->_get_cmd == NULL) + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + + err = dev_misc_func->_get_cmd(p, cmd, value); + + return err; +} + + +int camerasrc_support_embed_exif(camsrc_handle_t handle, int* support_exif) +{ + int err = CAMERASRC_ERR_UNKNOWN; + + err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_SUPPORT_EMBED_EXIF, support_exif); + if(err != CAMERASRC_SUCCESS) *support_exif = -1; + + return err; +} + + +int camerasrc_support_jpeg_encoding(camsrc_handle_t handle, int *support_jpeg_encoding) +{ + int err = CAMERASRC_ERR_UNKNOWN; + + err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_SUPPORT_JPEG_ENCODING, support_jpeg_encoding); + if (err != CAMERASRC_SUCCESS) { + *support_jpeg_encoding = 0; + } + + return err; +} + + +int camerasrc_get_screennail_buffer(camsrc_handle_t handle, camerasrc_buffer_t *scrnl_buf) +{ + camerasrc_handle_t *p = NULL; + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + if (scrnl_buf == NULL) { + camsrc_error("scrnl_buf is null"); + return CAMERASRC_ERR_INVALID_PARAMETER; + } + + p = CAMERASRC_HANDLE(handle); + + scrnl_buf->start = p->scrnl_buf.start; + scrnl_buf->length = p->scrnl_buf.length; + + camsrc_info("screennail ptr[%p],length[%d]", scrnl_buf->start, scrnl_buf->length); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_start_facedetection(camsrc_handle_t handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_FACEDETECTION, _CAMERASRC_FACEDETECTION_START); +} + + +int camerasrc_stop_facedetection(camsrc_handle_t handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_FACEDETECTION, _CAMERASRC_FACEDETECTION_STOP); +} + + +int camerasrc_get_facedetection(camsrc_handle_t handle, int *is_detecting) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_FACEDETECTION, is_detecting); +} + + +int camerasrc_set_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t frac) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_SHUTTER_SPEED, &frac); +} + + +int camerasrc_get_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t *frac) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_SHUTTER_SPEED, frac); +} + + +int camerasrc_set_exposure_value(camsrc_handle_t handle, camerasrc_frac_t frac) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_EXPOSURE_VALUE, &frac); +} + + +int camerasrc_get_exposure_value(camsrc_handle_t handle, camerasrc_frac_t *frac) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_EXPOSURE_VALUE, frac); +} + + +int camerasrc_set_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t mode) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_STROBE_MODE, &mode); +} + + +int camerasrc_get_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t *mode) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_STROBE_MODE, mode); +} + + +int camerasrc_set_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int value) +{ + _camerasrc_ctrl_t ctrl; + + CLEAR(ctrl); + + ctrl.cid = ctrl_id; + ctrl.value = value; + + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_CTRL, &ctrl); +} + + +int camerasrc_get_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int *value) +{ + int err = CAMERASRC_ERR_UNKNOWN; + _camerasrc_ctrl_t ctrl; + + CLEAR(ctrl); + + ctrl.cid = ctrl_id; + + err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_CTRL, &ctrl); + if (err != CAMERASRC_SUCCESS) { + return err; + } + + *value = ctrl.value; + + return err; +} + + +int camerasrc_query_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t *ctrl_info) +{ + struct v4l2_queryctrl queryctrl; + + if (ctrl_id < CAMERASRC_CTRL_BRIGHTNESS || ctrl_id >= CAMERASRC_CTRL_NUM) { + camsrc_warning("invalid ctrl_id [%d]", ctrl_id); + return CAMERASRC_ERR_INVALID_PARAMETER; + } + + CLEAR(queryctrl); + + queryctrl.id = _CAMERASRC_GET_CID(ctrl_id, CAMERASRC_HANDLE(handle)->cur_dev_id); + if (queryctrl.id == -1 ) { + camsrc_warning("not supported ctrl_id [%d]", ctrl_id); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + if (0 == _camerasrc_ioctl( handle, VIDIOC_QUERYCTRL, &queryctrl)) { + if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) { + camsrc_info("ID [%8x] disabled", queryctrl.id); + } + + ctrl_info->v4l2_ctrl_id = queryctrl.id; + ctrl_info->camsrc_ctrl_id = ctrl_id; + + switch (queryctrl.type) { + case V4L2_CTRL_TYPE_INTEGER: + ctrl_info->ctrl_type = CTRL_TYPE_RANGE; + break; + case V4L2_CTRL_TYPE_BOOLEAN: + ctrl_info->ctrl_type = CTRL_TYPE_BOOL; + break; + case V4L2_CTRL_TYPE_MENU: + ctrl_info->ctrl_type = CTRL_TYPE_ARRAY; + _camerasrc_query_ctrl_menu (handle, queryctrl, ctrl_info); + break; + default: + ctrl_info->ctrl_type = CTRL_TYPE_UNKNOWN; + break; + } + + memcpy(ctrl_info->ctrl_name, queryctrl.name, MAX_SZ_CTRL_NAME_STRING); + ctrl_info->min = queryctrl.minimum; + ctrl_info->max = queryctrl.maximum; + ctrl_info->step = queryctrl.step; + ctrl_info->default_val = queryctrl.default_value; + + camsrc_info("Control name : %s, type %d, min %d, max %d, step %d, default %d", + queryctrl.name, queryctrl.type, + queryctrl.minimum, queryctrl.maximum, + queryctrl.step, queryctrl.default_value); + } else { + camsrc_error("VIDIOC_QUERYCTRL error"); + + return CAMERASRC_ERR_IO_CONTROL; + } + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_support_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id) +{ + return CAMERASRC_SUCCESS; +} + + +int _camerasrc_get_JPG_length(camerasrc_handle_t *handle) +{ + int jpg_length; + + CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_LENGTH, &jpg_length); + + return jpg_length; +} + + +int _camerasrc_get_thumbnail_JPG_length(camerasrc_handle_t *handle) +{ + int jpg_length; + + CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_LENGTH, &jpg_length); + + return jpg_length; +} + + +int _camerasrc_get_thumbnail_JPG_offset(camerasrc_handle_t *handle) +{ + int thumb_offset; + + CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_OFFSET, &thumb_offset); + + return thumb_offset; +} + + +int _camerasrc_get_screennail_JPG_length(camerasrc_handle_t *handle) +{ + int length; + + CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_SCRNL_LENGTH, &length); + + return length; +} + + +int _camerasrc_get_screennail_JPG_offset(camerasrc_handle_t *handle) +{ + int offset; + + CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_SCRNL_OFFSET, &offset); + + return offset; +} + + +int _camerasrc_set_thumbnail_size(camerasrc_handle_t *handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_LENGTH, NULL); +} + + +int _camerasrc_check_emp_shock(camerasrc_handle_t *handle, int *check_val) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_ESD_CHECK, check_val); +} + + +int _camerasrc_set_jpeg_compress_ratio(camerasrc_handle_t *handle, unsigned int quality) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_JPEG_COMPRESS_RATIO, &quality); +} + + +int _camerasrc_ioctl(camerasrc_handle_t *handle, int request, void *arg) +{ + if (dev_misc_func->_ioctl == NULL) { +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + return dev_misc_func->_ioctl(handle, request, arg); +} + + +int _camerasrc_ioctl_once(camerasrc_handle_t *handle, int request, void *arg) +{ + if (dev_misc_func->_ioctl_once == NULL) { +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + return dev_misc_func->_ioctl_once(handle, request, arg); +} + + +void *_camerasrc_run_autofocusing(camerasrc_handle_t *handle) +{ + if (dev_misc_func->_run_autofocusing != NULL) { + dev_misc_func->_run_autofocusing(handle); + } + + return NULL; +} + + +int _camerasrc_skip_frame(camerasrc_handle_t *handle, long int timeout, int skip_frame) +{ + if (dev_misc_func->_skip_frame == NULL) { +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + return dev_misc_func->_skip_frame(handle, timeout, skip_frame); +} + +/**** A U T O F O C U S I N G F U N C T I O N S ****/ +int _camerasrc_set_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_AREA, rect); +} + +int _camerasrc_get_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_AF_AREA, rect); +} + +int _camerasrc_start_autofocusing(camerasrc_handle_t *handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_START); +} + +int _camerasrc_stop_autofocusing(camerasrc_handle_t *handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_STOP); +} + +int _camerasrc_release_autofocusing(camerasrc_handle_t *handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_RELEASE); +} + +int _camerasrc_destroy_autofocusing(camerasrc_handle_t *handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_DESTROY); +} + +int _camerasrc_init_autofocusing_mode(camerasrc_handle_t *handle) +{ + return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_INIT); +} + + +int _camerasrc_get_frame_data(camerasrc_handle_t *handle, camerasrc_frame_data_t *data) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_FRAME_DATA, data); +} + +int _camerasrc_get_exif_info(camerasrc_handle_t *handle, camerasrc_buffer_t *exif_string) +{ + return CAMERASRC_GET_CMD(_CAMERASRC_CMD_EXIF_INFO, exif_string); +} + + +int _camerasrc_copy_frame(camerasrc_handle_t *handle, camerasrc_buffer_t *src_buffer, camerasrc_buffer_t *dst_buffer, int isThumbnail) +{ + if (dev_misc_func->_copy_frame == NULL) { +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + return dev_misc_func->_copy_frame(handle, src_buffer, dst_buffer, isThumbnail); +} + + + +static int _camerasrc_chk_opened(char *conf_filename) +{ + camsrc_info("enter"); + + char buf[CAMERASRC_MAX_FILENAME_LEN] = {'\0',}; + char proc_buf[CAMERASRC_MAX_FILENAME_LEN] = {'\0',}; + int fd = -1; + int len = 0; + int buf_len = 0; + int pid = 0; + char access[9]; + int err_fd = -1; + int err = CAMERASRC_SUCCESS; + + fd = open(conf_filename, O_RDONLY); + if (fd == -1 && errno == ENOENT) { + camsrc_info("File not exist!!, first open from this boot. open..."); + return CAMERASRC_SUCCESS; + } else if (fd == -1 && errno != ENOENT) { + camsrc_info("File open error. log file open error!"); + return CAMERASRC_ERR_INTERNAL; + } else { + camsrc_info("Dev has been opened. start check..."); + } + + len = read(fd, buf, CAMERASRC_MAX_FILENAME_LEN); + sscanf(buf, "%2d:%5d:%64s", &buf_len, &pid, access); + + camsrc_info("%d : %d : %s", buf_len, pid, access); + if (buf_len == 0) { + camsrc_info("Wrong written check file!"); + close(fd); + + return CAMERASRC_ERR_INTERNAL; + } + + if (!strcmp(access, CAMERASRC_DEV_RELEASED_STR)) { + camsrc_info("Has opened but closed properly!"); + close(fd); + + return CAMERASRC_SUCCESS; + } + + if (pid == getpid()) { + camsrc_info("Double open!! You can't go. Investigate the PID's FD list"); + close(fd); + + return CAMERASRC_ERR_DEVICE_BUSY; + } + + snprintf(proc_buf, CAMERASRC_MAX_FILENAME_LEN, "/proc/%d", pid); + err_fd = open(proc_buf, O_RDONLY | O_NONBLOCK, 0); + if (err_fd == -1) { + camsrc_info("The proc node [%s] are not exist it's fake node", proc_buf); + err = CAMERASRC_SUCCESS; + } else { + camsrc_info("The proc node [%s] are loaded. almost opened...", proc_buf); + close(err_fd); + + err = CAMERASRC_ERR_DEVICE_BUSY; + } + + close(fd); + + return err; +} + + +static int __camerasrc_open_device(camerasrc_handle_t *p) +{ + #define MAX_DEVICE_COUNT 4 + + int i = 0; + int ret = CAMERASRC_ERR_DEVICE_NOT_FOUND; + char device_name[MAX_SZ_DEV_NAME_STRING] = {'\0',}; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + struct v4l2_capability capability; + + for (i = 0 ; i < MAX_DEVICE_COUNT ; i++) { + snprintf(device_name, MAX_SZ_DEV_NAME_STRING, "%s%d", CAMERASRC_DEV_NODE_PREFIX, i); + camsrc_info("try to open %s", device_name); + + p->dev_fd = open(device_name, O_RDWR | O_NONBLOCK, 0); + if (p->dev_fd < 0) { + /* open failed */ + strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("Device open fail [%d][%s]", errno, err_msg); + + switch (errno) { + case EBUSY: + ret = CAMERASRC_ERR_DEVICE_BUSY; + break; + case ENOENT: + case ENODEV: + ret = CAMERASRC_ERR_DEVICE_NOT_FOUND; + break; + default: + ret = CAMERASRC_ERR_DEVICE_OPEN; + break; + } + + break; + } else { + int ioctl_ret = 0; + + camsrc_info("opened device fd %d", p->dev_fd); + + /* open success and check capabilities */ + ioctl_ret = _camerasrc_ioctl((camerasrc_handle_t *)p, VIDIOC_QUERYCAP, &capability); + if (ioctl_ret == CAMERASRC_SUCCESS) { + /* succeeded : VIDIOC_QUERYCAP */ + camsrc_info("capabilities %x", capability.capabilities); + if (capability.capabilities & V4L2_CAP_VIDEO_CAPTURE) { + camsrc_info("found capture device %s", device_name); + return CAMERASRC_SUCCESS; + } + } else { + camsrc_warning("VIDIOC_QUERYCAP error %x", ioctl_ret); + } + + close(p->dev_fd); + p->dev_fd = -1; + } + } + + camsrc_error("failed to find capture device %x", ret); + + return ret; +} + +static int _camerasrc_seamless_record_onaccess_open(char *conf_filename, camerasrc_handle_t *p) +{ + camsrc_info("enter"); + + int fd = -1; + int len = 0; + int ret = CAMERASRC_SUCCESS; + char buf[BUF_LEN]; + char tot_buf[BUF_LEN]; + camerasrc_sync_param_t syncparam = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX}; + + camsrc_lock_sync(&syncparam); + + if (p->dev_fd == -1) { + ret = __camerasrc_open_device(p); + if (ret != CAMERASRC_SUCCESS) { + camsrc_error("open failed %x", ret); + camsrc_unlock_sync(&syncparam); + return ret; + } + + p->is_async_open = 0; + } else { + p->is_async_open = 1; + } + + /* Write open status */ + fd = open(conf_filename, O_RDWR | O_NONBLOCK | O_CREAT, 0666); + if (fd == -1) { + camsrc_info("failed to open ", conf_filename); + /* Release camera device */ + close(p->dev_fd); + p->dev_fd = -1; + return CAMERASRC_ERR_INTERNAL; + } + + /** + * record like below format + * A : (integer) length of this info without this number and semicolon + * B : (integer) Process ID of process that open the device + * C : (string) Status of camera device. ONACCESS / RELEASED (9 words) + * format : "%d:%d:%s", A, B, C + */ + len = snprintf(buf, BUF_LEN, "%d:%s", getpid(), CAMERASRC_DEV_ON_ACCESS_STR); + len = snprintf(tot_buf, BUF_LEN, "%d:%s", len, buf); + tot_buf[len] = '\0'; + len = write(fd, tot_buf, len+1); + + close(fd); + fd = -1; + + camsrc_unlock_sync(&syncparam); + + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_seamless_delete_onaccess(char *conf_filename, camerasrc_handle_t *p) +{ + camsrc_info("enter"); + + int fd = p->dev_fd; + int chk_fd = 0; + int len = 0; + int err = CAMERASRC_ERR_UNKNOWN; + char buf[BUF_LEN]; + char tot_buf[BUF_LEN]; + camerasrc_sync_param_t param = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX}; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + camsrc_info("Start delete..."); + + /* TODO : Semaphore lock */ + camsrc_lock_sync(¶m); + + if (!(p->is_async_open)) { + close(fd); + } + + chk_fd = open(conf_filename, O_WRONLY | O_NONBLOCK); + if (chk_fd == -1) { + camsrc_info("FD = %d", fd); + return CAMERASRC_ERR_INTERNAL; + } + + len = snprintf(buf, BUF_LEN, "%d:%s", getpid(), CAMERASRC_DEV_RELEASED_STR); + camsrc_info("using string : %s", buf); + + len = snprintf(tot_buf, BUF_LEN, "%d:%s", len, buf); + camsrc_info("write string final : %s", tot_buf); + + len = write(chk_fd, tot_buf, len); + if (len == -1) { + strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("WRITE ERROR!!!!, error = %s, fd = %d", err_msg, chk_fd); + } + + close(chk_fd); + + camsrc_unlock_sync(¶m); + /* TODO : Semaphore unlock */ + err = CAMERASRC_SUCCESS; + camsrc_info("End delete..."); + + return err; +} + + +static int _camerasrc_initialize_handle(camerasrc_handle_t *handle) +{ + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + /* Initialize handle variables */ + handle->buffer = NULL; + handle->is_async_open = 0; + handle->dev_fd = -1; + handle->cur_dev_id = CAMERASRC_DEV_ID_UNKNOWN; + handle->check_esd = 0; + handle->is_preset = 0; + handle->resolution = 0; + handle->buffer_idx = 0; + handle->num_buffers = 0; + handle->buffer = NULL; + handle->present_buf = NULL; + handle->io_method = CAMERASRC_IO_METHOD_MMAP; + handle->af_status = CAMERASRC_AUTO_FOCUS_STATUS_RELEASED; + handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_NULL; + handle->cur_af_mode = CAMERASRC_AF_MODE_AUTO; + handle->cur_af_range = CAMERASRC_AF_RANGE_NORMAL; + handle->af_usr_data = NULL; + handle->skip_frame_func = NULL; + handle->isAutoexposure = 1; + handle->af_cb = NULL; + handle->first_frame = 1; + handle->af_init_called = 0; + handle->hold_af_after_capturing = 0; + + if (gettimeofday(&handle->set_af_area_time, NULL) != 0) { + handle->set_af_area_time.tv_sec = 0; + handle->set_af_area_time.tv_usec = 0; + camsrc_warning("[init handle] gettimeofday Failed"); + } + + CLEAR(handle->queued_buf_list); + CLEAR(handle->format); + + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_wait_frame_available(camerasrc_handle_t *handle, long int timeout) +{ + camerasrc_handle_t *p = handle; + fd_set fds; + struct timeval tv; + int r; + +#if defined (USE_SKIP_FRAME) + int skip_frame = CAMERASRC_JPG_STILL_SKIP_FRAME; +#endif + + if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) { + /* Wait time FPS time */ + if (p->timeperframe.denominator == 0 && p->timeperframe.numerator == 0) { + usleep((int)1000000/30); /* supposed to 1/30 sec */ + } else { + usleep((int)(1000000 * p->timeperframe.numerator / p->timeperframe.denominator)); + } + + camsrc_info("Device emergency closed. wait will return proper time"); + + return CAMERASRC_SUCCESS; + } + + /** + * @note In preview or video mode, skip_frame_func, signaling_func will be NULL + * If unnecessary, just input them to NULL in start_still/preview/video_stream() + */ + + FD_ZERO(&fds); + FD_SET(p->dev_fd, &fds); + + /* skip frame */ +#if defined (USE_SKIP_FRAME) + if(p->skip_frame_func != NULL) { + camsrc_info("Skip frame function enabled!"); + err = p->skip_frame_func(p, timeout, skip_frame); + } +#endif + + /* set timeout */ + tv.tv_sec = (long int)timeout/1000; + tv.tv_usec = timeout * 1000 - tv.tv_sec * 1000000; + + /* select waiting */ + r = select(p->dev_fd + 1, &fds, NULL, NULL, &tv); + if (-1 == r) { + if (EINTR == errno) { + return CAMERASRC_SUCCESS; + } + camsrc_error("select() failed."); + + return CAMERASRC_ERR_INTERNAL; + } + + if (0 == r) { + return CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT; + } + + return CAMERASRC_SUCCESS; +} + + +struct v4l2_buffer *_camerasrc_get_correct_buf(camerasrc_handle_t *handle, struct v4l2_buffer *queued_buf_list, camerasrc_buffer_t *buffer) +{ + unsigned int num_buffers = 0; + int cnt = 0; + camerasrc_get_num_buffer(handle, &num_buffers); + + for (cnt = 0 ; cnt < num_buffers ; cnt++) { + if (queued_buf_list[cnt].m.userptr == (unsigned long)buffer->start) { + return &(queued_buf_list[cnt]); + } + } + + return NULL; +} + + +static int _camerasrc_queue_buffer(camerasrc_handle_t *handle, int buf_index, camerasrc_buffer_t *buffer) +{ + camerasrc_handle_t *p = handle; + struct v4l2_buffer vbuf; + struct v4l2_buffer *pvbuf; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) { + camsrc_info("Device emergency closed. Q will return successfully"); + return CAMERASRC_SUCCESS; + } + + if (buf_index >= p->num_buffers) { + camsrc_info("Late buffer won't be queued, buf_index = %d, p->num_buffers = %d", buf_index, p->num_buffers); + return CAMERASRC_SUCCESS; + } + + CLEAR(vbuf); + + switch (p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + if (p->buffer[buf_index].queued_status == CAMERASRC_BUFFER_QUEUED) { + camsrc_info("buffer[index:%d] is already queued. return success.", buf_index); + return CAMERASRC_SUCCESS; + } + + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + vbuf.index = buf_index; + pvbuf = &vbuf; + break; + case CAMERASRC_IO_METHOD_USRPTR: + if (&(p->queued_buf_list[buf_index])) { + pvbuf = _camerasrc_get_correct_buf(handle, p->queued_buf_list, buffer); + } + + if (pvbuf == NULL) { + camsrc_error("Wrong address tried to queueing!, It'll be queued as input index.."); + pvbuf = &(p->queued_buf_list[buf_index]); + } + break; + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + if (CAMERASRC_STATE(handle) == CAMERASRC_STATE_READY) { + camsrc_warning("Q after ready state will success"); + return CAMERASRC_SUCCESS; + } + + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, pvbuf)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("VIDIOC_QBUF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + + LOCK(p); + if (p->io_method == CAMERASRC_IO_METHOD_MMAP) { + p->buffer[buf_index].queued_status = CAMERASRC_BUFFER_QUEUED; + p->queued_buffer_count++; + } + UNLOCK(p); + + return CAMERASRC_SUCCESS; +} + + +static int _camerasrc_get_proper_index(camerasrc_handle_t *handle, void *data) +{ + int i = 0; + + for (i = 0; i < handle->num_buffers; i++) { + if (handle->buffer[i].start == data) { + return i; + } + } + + camsrc_info("Index NOT found. new buffer... go to error"); + + return -1; +} + + +static int _camerasrc_dequeue_buffer(camerasrc_handle_t *handle, int *buf_index, camerasrc_buffer_t *buffer, camerasrc_buffer_t *thm_buffer) +{ + camerasrc_handle_t *p = handle; + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_buffer vbuf; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) { + buf_index = 0; + buffer = &p->alter_frame; + buffer = NULL; + camsrc_info("Device emergency closed. DQ return fake frame"); + return CAMERASRC_SUCCESS; + } + + switch(p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + CLEAR(vbuf); + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + break; + case CAMERASRC_IO_METHOD_USRPTR: + CLEAR(vbuf); + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_USERPTR; + break; + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_DQBUF, &vbuf)) { + switch (p->errnum) { + case EAGAIN: + camsrc_info("VIDIOC_DQBUF [EAGAIN]"); + return CAMERASRC_SUCCESS; + case EIO: + /* Could ignore EIO, see spec. */ + /* fall through */ + camsrc_info("VIDIOC_DQBUF [EIO]"); + break; + case EINVAL: + camsrc_info("VIDIOC_DQBUF [EINVAL]"); + printf("VIDIOC_DQBUF [EINVAL]"); + return CAMERASRC_ERR_INVALID_VALUE; + default: + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("VIDIOC_DQBUF [%s]", err_msg); + break; + } + } + + /* A F I N I T */ + if (CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW && + p->first_frame && _CAMERASRC_SUPPORT_AF(p->cur_dev_id)) { + camsrc_info("AF init at first frame, hold_Af %d", p->hold_af_after_capturing); + if (!(p->af_init_called) || !(p->hold_af_after_capturing)) { + err = _camerasrc_init_autofocusing_mode(p); + if (err != CAMERASRC_SUCCESS) { + camsrc_warning("AF init failed"); + } else { + p->af_init_called = 1; + } + } else { + camsrc_info("AF init SKIP!"); + } + + p->first_frame = 0; + } + + if (CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW || CAMERASRC_STATE(p) == CAMERASRC_STATE_VIDEO || + (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL && p->format.colorspace == CAMERASRC_COL_RAW) || + (CAMERASRC_STATE(p) == CAMERASRC_STATE_AF_IN_PROGRESS && p->format.colorspace == CAMERASRC_COL_RAW)) { + switch(p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + *buf_index = vbuf.index; + buffer->start = p->buffer[vbuf.index].start; + LOCK(p); + p->buffer[vbuf.index].queued_status = CAMERASRC_BUFFER_DEQUEUED; + p->queued_buffer_count--; + UNLOCK(p); +#if 1 + switch (p->format.pix_format ) { + case CAMERASRC_PIX_YUV422P: + case CAMERASRC_PIX_YUY2: + case CAMERASRC_PIX_UYVY: + case CAMERASRC_PIX_RGB565: + buffer->length = YUV422_SIZE(p); + break; + case CAMERASRC_PIX_YUV420P: + case CAMERASRC_PIX_SN12: + case CAMERASRC_PIX_ST12: + case CAMERASRC_PIX_NV12: + buffer->length = YUV420_SIZE(p); + break; + case CAMERASRC_PIX_INTERLEAVED: + { + unsigned char *p_size_info = NULL; +#if 0 + if (vbuf.index == 2) { + FILE *fp = fopen("./test2.dump", "w+"); + fwrite(buffer->start, p->buffer[vbuf.index].length, 1, fp); + fflush(fp); + fclose(fp); + } +#endif + p_size_info = (unsigned char *)(buffer->start + (p->buffer[vbuf.index].length - ITLV_DATA_INFO_OFFSET)); + buffer->length = (unsigned int)(p_size_info[EMBEDDED_OFFSET]<<24) + (p_size_info[EMBEDDED_OFFSET+1]<<16) + (p_size_info[EMBEDDED_OFFSET+2]<<8) + p_size_info[EMBEDDED_OFFSET+3]; + camsrc_info("total %d, addr %x, data size %d", + (int)(p->buffer[vbuf.index].length), buffer->start, buffer->length); + break; + } + case CAMERASRC_PIX_RGGB10: + case CAMERASRC_PIX_RGGB8: + default: + buffer->length = -1; + break; + } +#else + buffer->length = vbuf.bytesused; +#endif + break; + case CAMERASRC_IO_METHOD_USRPTR: + { + int i = 0; + int dequeued = 0; + + for (i = 0; i < p->present_buf->num_buffer; ++i) { +#if defined (USE_USERPTR_DEBUG) + camsrc_info("buffers[%d].start: %p", i, p->buffer[i].start); + camsrc_info("buffers[%d].length: %d", i, p->buffer[i].length); + camsrc_info("buf.m.userptr: %p", vbuf.m.userptr); + camsrc_info("buf.length: %d", vbuf.length); +#endif + if (vbuf.m.userptr == (unsigned long) p->buffer[i].start) { + dequeued = 1; + break; + } + } + + if (!dequeued) { + camsrc_error("Dequeued buffer not matched to user ptr!"); + return CAMERASRC_ERR_IO_CONTROL; + } + + *buf_index = _camerasrc_get_proper_index(p, (void*)vbuf.m.userptr); + buffer->start = (unsigned char*)vbuf.m.userptr; + buffer->length = vbuf.length; + + break; + } + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + break; + } + } else if (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL && p->format.colorspace == CAMERASRC_COL_JPEG) { + /* JPEG Capture */ + switch (p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + camsrc_info("JPEG frame dequeueing.."); + *buf_index = vbuf.index; + buffer->start = p->buffer[vbuf.index].start; + buffer->length = _camerasrc_get_JPG_length(p); + LOCK(p); + p->buffer[vbuf.index].queued_status = CAMERASRC_BUFFER_DEQUEUED; + p->queued_buffer_count--; + UNLOCK(p); + camsrc_info("JPEG frame length = %d", buffer->length); + /* If splitted thumbnail jpeg, it should know about both sizes */ + if (thm_buffer != NULL) { + if(p->format.pix_format == CAMERASRC_PIX_RGGB10) { + thm_buffer->start = p->buffer[vbuf.index].start + CAMERASRC_RAW_STILL_THUMBNAIL_OFFSET; + thm_buffer->length = CAMERASRC_YUV_THMBNL_SIZE; + camsrc_info("Thumbnail JPEG frame length = %d", thm_buffer->length); + } + else if(p->format.pix_format == CAMERASRC_PIX_RGGB8) { + unsigned int thumb_offset = 0, thumb_length = 0; + + thumb_offset = _camerasrc_get_thumbnail_JPG_offset(p); + thumb_length = _camerasrc_get_thumbnail_JPG_length(p); + + if( thumb_offset == 0 || thumb_length == 0 ) + { + thm_buffer->start = NULL; + thm_buffer->length = 0; + camsrc_info("Get Thumbnail JPEG frame failed.(offset:0x%x,length:%d)", thumb_offset, thumb_length); + } + else + { + thm_buffer->start = p->buffer[vbuf.index].start + thumb_offset; + thm_buffer->length = thumb_length; + camsrc_info("Thumbnail JPEG frame %p (offset 0x%x, length %d)", thm_buffer->start, thumb_offset, thumb_length); + } + } + else { + camsrc_error("Unknown image format... "); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + } + + /* Get screennail buffer */ + p->scrnl_buf.start = p->buffer[vbuf.index].start + _camerasrc_get_screennail_JPG_offset(p); + p->scrnl_buf.length = _camerasrc_get_screennail_JPG_length(p); + + /** + * In some module(or along firmware), it doesn't support jpg image + * splitted with thumbnail And its size always reported as bytesused field. + * "buffer->length == 0" means it won't support splitted jpg output + */ + camsrc_info("buffer->length = %d, vbuf.bytesused=%d", buffer->length, vbuf.bytesused); + if (buffer->length == 0) { + camsrc_info("it'll be copied as size = %d", vbuf.bytesused); + buffer->length = vbuf.bytesused; + } + + break; + case CAMERASRC_IO_METHOD_USRPTR: + { + int i = 0; + int dequeued = 0; + + for (i = 0; i < p->present_buf->num_buffer; ++i) { +#if defined (USE_USERPTR_DEBUG) + camsrc_info("buffers[%d].start: %d", i, p->buffer[i].start); + camsrc_info("buffers[%d].length: %d", i, p->buffer[i].length); + camsrc_info("buf.m.userptr: %d", vbuf.m.userptr); + camsrc_info("buf.length: %d", vbuf.length); +#endif + if (vbuf.m.userptr == (unsigned long) p->buffer[i].start) { + dequeued = 1; + break; + } + } + + if (!dequeued) { + camsrc_error("Dequeued buffer not matched to user ptr!"); + return CAMERASRC_ERR_IO_CONTROL; + } + + camsrc_info("JPEG frame dequeueing.."); + *buf_index = vbuf.index; + buffer->start = (unsigned char*)vbuf.m.userptr; + buffer->length = _camerasrc_get_JPG_length(p); + if (buffer->length == 0) { + return CAMERASRC_ERR_INVALID_PARAMETER; + } + camsrc_info("JPEG frame length = %d", buffer->length); + + if (thm_buffer != NULL) { + if (p->format.pix_format == CAMERASRC_PIX_RGGB10) { + /* JPEG + YUV thumbnail */ + thm_buffer->start = p->buffer[i].start + CAMERASRC_RAW_STILL_THUMBNAIL_OFFSET; + thm_buffer->length = CAMERASRC_YUV_THMBNL_SIZE; + camsrc_info("Thumbnail JPEG frame length = %d", thm_buffer->length); + } else if(p->format.pix_format == CAMERASRC_PIX_RGGB8) { + /* JPEG + JPEG thumbnail */ + thm_buffer->start = p->buffer[i].start + CAMERASRC_JPG_STILL_THUMBNAIL_OFFSET; + thm_buffer->length = _camerasrc_get_thumbnail_JPG_length(p); + if (buffer->length == 0) { + return CAMERASRC_ERR_INVALID_PARAMETER; + } + camsrc_info("Thumbnail JPEG frame length = %d", thm_buffer->length); + } else { + camsrc_error("Unknown image format... "); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + } + break; + } + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + break; + } + } else { + camsrc_error("Invalid state transition"); + return CAMERASRC_ERR_INVALID_STATE; + } + + return CAMERASRC_SUCCESS; +} + +static int _camerasrc_dump_format(camsrc_handle_t handle); + +/**** M A I N O P E R A T I O N ****/ +int camerasrc_create(camsrc_handle_t *phandle) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + camsrc_info("enter"); + + if (phandle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = (camerasrc_handle_t *)malloc(sizeof(camerasrc_handle_t)); + if(p == NULL) { + camsrc_error("malloc fail"); + return CAMERASRC_ERR_ALLOCATION; + } + + memset(p, '\0', sizeof(camerasrc_handle_t)); + + /* STATE TO MEANINGFUL STATE */ + p->cur_state = CAMERASRC_STATE_NONE; + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_CREATED); + CAMERASRC_SET_PHASE(p, CAMERASRC_PHASE_NON_RUNNING); + camsrc_info("Transit to non-running phase"); + + /* INIT VARIABLES */ + err = _camerasrc_initialize_handle(p); + if(err != CAMERASRC_SUCCESS) { + camsrc_error("Invalid handle"); + return CAMERASRC_ERR_INVALID_HANDLE; + } + + err = pthread_mutex_init(&(p->mutex), NULL); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("Mutex creating status : %s", err_msg); + } + + err = pthread_mutex_init(&(p->af_mutex), NULL); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF Mutex creating status : %s", err_msg); + } + + err = pthread_cond_init(&(p->af_wait_cond), NULL); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF Condition creating status : %s", err_msg); + } + + camsrc_info("Thread creation start.."); + err = pthread_create(&p->focusing_thread, NULL, (void*)_camerasrc_run_autofocusing, p); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF Thread creating status : %s", err_msg); + } + + camsrc_info("Thread creation end.."); + + *phandle = (camsrc_handle_t)p; + err = CAMERASRC_SUCCESS; + return err; +} + + +int camerasrc_destroy(camsrc_handle_t handle) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if(CAMERASRC_STATE(p) != CAMERASRC_STATE_UNREALIZED) { + camsrc_warning("Invalid state transition"); + } + + /* Remove AF thread */ + _camerasrc_destroy_autofocusing(p); + + camsrc_info("Thread join wait start.."); + err = pthread_join(p->focusing_thread, NULL); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF Thread join status : %s", err_msg); + } + + camsrc_info("Thread join wait end.."); + + err = pthread_cond_destroy(&p->af_wait_cond); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF Condition destroying error : %s", err_msg); + } + + err = pthread_mutex_destroy(&(p->af_mutex)); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("AF Mutex destroying error : %s", err_msg); + } + + err = pthread_mutex_destroy(&(p->mutex)); + if(err) { + strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_info("Mutex destroying error : %s", err_msg); + } + + free((void*)p); + handle = NULL; + err = CAMERASRC_SUCCESS; + return err; +} + + +int camerasrc_close_device(camsrc_handle_t handle) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + p->is_async_open = 0; + +#if defined(USE_OPEN_CHK) + if(!CAMERASRC_IS_DEV_CLOSED(p)) { + err = _camerasrc_seamless_delete_onaccess(CAMERASRC_OPENED_CHK_FILENAME, p); + if(err != CAMERASRC_SUCCESS) { + return CAMERASRC_ERR_INTERNAL; + } + p->dev_fd = CAMERASRC_DEV_FD_EMERGENCY_CLOSED; + } +#else + if(!CAMERASRC_IS_DEV_CLOSED(p)) { + + if( !(p->is_async_open) ) { + close(p->dev_fd); + } + + p->dev_fd = CAMERASRC_DEV_FD_EMERGENCY_CLOSED; + } + /* prepare "Kagemusha" frame data */ + LOCK(p); + memcpy(p->alter_frame.start, p->buffer[0].start, p->alter_frame.length); + UNLOCK(p); +#endif + return CAMERASRC_SUCCESS; +} + + +int camerasrc_get_state(camsrc_handle_t handle, camerasrc_state_t* state) +{ + camerasrc_handle_t* p = NULL; + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + *state = CAMERASRC_STATE(p); + return CAMERASRC_SUCCESS; +} + + +int camerasrc_realize(camsrc_handle_t handle) +{ + camerasrc_handle_t* p = NULL; + int ret = CAMERASRC_SUCCESS; + + camerasrc_sync_param_t param = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX}; + mode_t mask = 0; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + /* STATE OR PHASE CHECKING */ + if(CAMERASRC_STATE(p) == CAMERASRC_STATE_REALIZED) { + return CAMERASRC_SUCCESS; + } + if(CAMERASRC_STATE(p) != CAMERASRC_STATE_CREATED && + CAMERASRC_STATE(p) != CAMERASRC_STATE_UNREALIZED) { + camsrc_warning("Invalid state transition"); + } + + mask = umask(0); + + /* CREATE SEMAPHORE */ + camsrc_create_sync(¶m); + + /* O P E N D E V I C E */ +#if defined(USE_OPEN_CHK) + ret = _camerasrc_chk_opened(CAMERASRC_OPENED_CHK_FILENAME); + if (ret == CAMERASRC_SUCCESS) { + ret = _camerasrc_seamless_record_onaccess_open(CAMERASRC_OPENED_CHK_FILENAME, p); + if (ret != CAMERASRC_SUCCESS) { + camsrc_error("_camerasrc_seamless_record_onaccess_open failed %x", ret); + } + } +#else /* USE_OPEN_CHK */ + if (!CAMERASRC_IS_DEV_CLOSED(p)) { + ret = __camerasrc_open_device(p); + if (ret != CAMERASRC_SUCCESS) { + camsrc_error("camera open failed %x", ret); + } else { + p->is_async_open = 0; + } + } else { + p->is_async_open = 1; + } +#endif /* USE_OPEN_CHK */ + + umask(mask); + + if (ret == CAMERASRC_SUCCESS) { + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_REALIZED); + } + + return ret; +} + + +int camerasrc_unrealize(camsrc_handle_t handle) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if(CAMERASRC_STATE(p) == CAMERASRC_STATE_UNREALIZED || + CAMERASRC_STATE(p) == CAMERASRC_STATE_DESTROYED) { + return CAMERASRC_SUCCESS; + } + if(CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_warning("Invalid state transition"); + } + +#if defined(USE_OPEN_CHK) + if(!CAMERASRC_IS_DEV_CLOSED(p)) { + err = _camerasrc_seamless_delete_onaccess(CAMERASRC_OPENED_CHK_FILENAME, p); + if(err != CAMERASRC_SUCCESS) { + return CAMERASRC_ERR_INTERNAL; + } + } +#else /* USE_OPEN_CHK */ + if(!CAMERASRC_IS_DEV_CLOSED(p)) { + + if( !(p->is_async_open) ) { + close(p->dev_fd); + } + } +#endif /* USE_OPEN_CHK */ + + p->dev_fd = -1; + p->check_esd = 0; + + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_UNREALIZED); + CAMERASRC_SET_PHASE(p, CAMERASRC_PHASE_NON_RUNNING); + camsrc_info("Transit to non-running phase"); + err = CAMERASRC_SUCCESS; + return err; +} + + +int camerasrc_start(camsrc_handle_t handle) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + /* STATE OR PHASE CHECKING */ + if(CAMERASRC_STATE(p) == CAMERASRC_STATE_READY) { + return CAMERASRC_SUCCESS; + } + if(CAMERASRC_STATE(p) != CAMERASRC_STATE_REALIZED) { + camsrc_warning("Invalid state transition"); + } + + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_READY); + CAMERASRC_SET_PHASE(p, CAMERASRC_PHASE_RUNNING); + + camsrc_info("Transit to running phase"); + err = CAMERASRC_SUCCESS; + return err; +} + + +int camerasrc_present_usr_buffer(camsrc_handle_t handle, camerasrc_usr_buf_t *present_buf, camerasrc_io_method_t io_method) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_warning("Invalid state transition"); + } + + switch(io_method) { + case CAMERASRC_IO_METHOD_MMAP: + camsrc_info("MMAP mode"); + if (present_buf != NULL) { + camsrc_error("present_buf should be NULL in MMAP Mode"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + p->io_method = CAMERASRC_IO_METHOD_MMAP; + break; + case CAMERASRC_IO_METHOD_USRPTR: + camsrc_info("USRPTR mode"); + if (present_buf == NULL) { + camsrc_error("present_buf should NOT be NULL in USRPTR Mode"); + return CAMERASRC_ERR_ALLOCATION; + } + + if (present_buf->num_buffer > CAMERASRC_USRPTR_MAX_BUFFER_NUM) { + camsrc_warning("Use up tp MAX %d buffer only", CAMERASRC_USRPTR_MAX_BUFFER_NUM); + present_buf->num_buffer = CAMERASRC_USRPTR_MAX_BUFFER_NUM; + } + p->present_buf = present_buf; + p->io_method = CAMERASRC_IO_METHOD_USRPTR; + break; + case CAMERASRC_IO_METHOD_READ: + default: +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + break; + } + + err = CAMERASRC_SUCCESS; + return err; +} + + +int camerasrc_get_num_buffer(camsrc_handle_t handle, unsigned int *num_buffer) +{ + camerasrc_handle_t *p = NULL; + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + camerasrc_state_t state = CAMERASRC_STATE_NONE; + camerasrc_get_state(handle, &state); + + switch(state) { + case CAMERASRC_STATE_NONE: + case CAMERASRC_STATE_CREATED: + case CAMERASRC_STATE_REALIZED: + case CAMERASRC_STATE_READY: + case CAMERASRC_STATE_UNREALIZED: + case CAMERASRC_STATE_DESTROYED: + camsrc_warning("Current buffer number not initialized."); + *num_buffer = 0; + break; + case CAMERASRC_STATE_PREVIEW: + case CAMERASRC_STATE_STILL: + case CAMERASRC_STATE_VIDEO: + case CAMERASRC_STATE_AF_IN_PROGRESS: + *num_buffer = p->num_buffers; + break; + default: + camsrc_error("Unknown state"); + *num_buffer = -1; + return CAMERASRC_ERR_INVALID_STATE; + } + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_get_io_method(camsrc_handle_t handle, camerasrc_io_method_t* io_method) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + *io_method = p->io_method; + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_start_still_stream(camsrc_handle_t handle) +{ + camerasrc_handle_t* p = NULL; + struct v4l2_streamparm vstreamparm; + struct v4l2_format vformat; + struct v4l2_requestbuffers vreq_bufs; + enum v4l2_buf_type vtype; + int cnt = 0; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL) { + return CAMERASRC_SUCCESS; + } + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_warning("Invalid state transition"); + } + + /* S T I L L M O D E S E T T I N G */ + /* + * If driver can control thmbnl size, we do that here, if not support, it's OK + * Driver should change jpeg compress ration before start stream + */ + CLEAR(vstreamparm); + vstreamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + __ta__( " Stillshot VIDIOC_G_PARM", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_G_PARM, &vstreamparm)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_G_PARAM failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + if (p->format.is_highquality_mode == 1) { + camsrc_info("High quality frame will be captured"); + vstreamparm.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY; + } else if(p->format.is_highquality_mode == 0) { + camsrc_info("Normal quality frame will be captured"); + vstreamparm.parm.capture.capturemode = 0; + } else { + camsrc_info("Quality not initialized, or incorrect value. set high quality..."); + vstreamparm.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY; + } + + vstreamparm.parm.capture.timeperframe.numerator = p->timeperframe.numerator; + vstreamparm.parm.capture.timeperframe.denominator = p->timeperframe.denominator; + camsrc_info("[FPS] timeperframe.numerator = %d", p->timeperframe.numerator); + camsrc_info("[FPS] timeperframe.denominator = %d", p->timeperframe.denominator); + camsrc_info("[QUA] vstreamparm.parm.capture.capturemode = %d", vstreamparm.parm.capture.capturemode); + __ta__( " Stillshot VIDIOC_S_PARM", + if(CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_PARM, &vstreamparm)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_S_PARAM failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + /* S T I L L F O R M A T S E T T I N G */ + CLEAR(vformat); + _camerasrc_dump_format(p); + vformat.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + switch (p->format.pix_format) { + case CAMERASRC_PIX_YUV420P: + camsrc_info("420P capture activated.."); + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420; + break; + case CAMERASRC_PIX_YUV422P: + camsrc_info("422P capture activated.."); + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P; + break; + case CAMERASRC_PIX_SN12: + case CAMERASRC_PIX_NV12: + camsrc_info("NV12(SN12) capture activated.."); + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12; + break; + case CAMERASRC_PIX_ST12: + camsrc_info("NV12T capture activated.."); + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12T; + break; + case CAMERASRC_PIX_YUY2: + camsrc_info("YUY2 capture activated.."); + vformat.fmt.pix.pixelformat = CAMERASRC_V4L2_PREVIEW_PIX_FMT_DEFAULT; + break; + /* Kessler capture path */ + case CAMERASRC_PIX_RGGB8: + camsrc_info("JPEG+JPEG capture activated.."); + vformat.fmt.pix.pixelformat = CAMERASRC_V4L2_JPEG_CAPTURE_PIX_FMT_DEFAULT; + break; + case CAMERASRC_PIX_RGGB10: + camsrc_info("JPEG+YUV capture activated.."); + vformat.fmt.pix.pixelformat = CAMERASRC_V4L2_JPG_YUV_CAPTURE_PIX_FMT_DEFAULT; + break; + default: + camsrc_error("Not supported format!"); + break; + } + + camsrc_info("JPG unified size capture avtivated!"); + vformat.fmt.pix.width = p->format.img_size.dim.width; /*capture width*/ + vformat.fmt.pix.height = p->format.img_size.dim.height; /*capture height*/ + vformat.fmt.pix_mp.field = V4L2_FIELD_NONE; + __ta__( " Stillshot VIDIOC_S_FMT", + if(CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_FMT, &vformat)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_S_FMT failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + camsrc_info("Stillshot VIDIOC_S_FMT done"); + + CLEAR(vreq_bufs); + + /* M E M O R Y M A P P I N G */ + switch (p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + camsrc_info("MMAP mode"); + + if (vformat.fmt.pix.pixelformat == CAMERASRC_V4L2_JPEG_CAPTURE_PIX_FMT_DEFAULT ) { + vreq_bufs.count = CAMERASRC_STILL_BUFFER_NUM; + } else { + vreq_bufs.count = CAMERASRC_PREVIEW_BUFFER_NUM; + } + vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vreq_bufs.memory = V4L2_MEMORY_MMAP; + + camsrc_info("VIDIOC_REQBUFS count:%d, type:%d, memory:%d", + vreq_bufs.count, vreq_bufs.type, vreq_bufs.memory); + + __ta__( " Stillshot VIDIOC_REQBUFS", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + camsrc_info("Stillshot VIDIOC_REQBUFS done"); + camsrc_assert(vreq_bufs.count >= 1); + + p->num_buffers = vreq_bufs.count; + p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t)); + + if (!p->buffer) { + camsrc_error("calloc() failed"); + return CAMERASRC_ERR_ALLOCATION; + } + + __ta__( " Stillshot VIDIOC_QUERYBUF,mmap", + for (p->buffer_idx = 0 ; p->buffer_idx < vreq_bufs.count ; ++(p->buffer_idx)) { + struct v4l2_buffer vbuf; + CLEAR(vbuf); + + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + vbuf.index = p->buffer_idx; + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QUERYBUF, &vbuf)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_QUERYBUF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + + p->buffer[p->buffer_idx].length = vbuf.length; + p->buffer[p->buffer_idx].start = mmap(NULL /* start anywhere */, + vbuf.length, + PROT_READ | PROT_WRITE, + MAP_SHARED, + p->dev_fd, vbuf.m.offset); + if (MAP_FAILED == p->buffer[p->buffer_idx].start) { + camsrc_error("mmap failed."); + return CAMERASRC_ERR_ALLOCATION; + } + + camsrc_info("MMAP BUF: addr[%p] size[%d]", + p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length); + } + ); + + camsrc_info("Stillshot VIDIOC_QUERYBUF and mmap done"); + break; + + case CAMERASRC_IO_METHOD_USRPTR: + camsrc_info("USRPTR mode"); + + vreq_bufs.count = p->present_buf->num_buffer; + vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vreq_bufs.memory = V4L2_MEMORY_USERPTR; + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + + camsrc_assert(vreq_bufs.count >= 1); + + p->num_buffers = vreq_bufs.count; + p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t)); + + if (!p->buffer) { + camsrc_error("calloc() failed"); + return CAMERASRC_ERR_ALLOCATION; + } + + if (!p->present_buf->present_buffer) { + camsrc_error("No Usrptr buffer presented!"); + return CAMERASRC_ERR_ALLOCATION; + } + + for (p->buffer_idx = 0; p->buffer_idx < vreq_bufs.count; ++(p->buffer_idx)) { + p->buffer[p->buffer_idx].length = p->present_buf->present_buffer[p->buffer_idx].length; + p->buffer[p->buffer_idx].start = p->present_buf->present_buffer[p->buffer_idx].start; + + if (!p->buffer[p->buffer_idx].start) { + camsrc_error("presented usrptr buffer is NULL"); + return CAMERASRC_ERR_ALLOCATION; + } + + camsrc_info("USERPTR BUF: addr[%p] size[%d]", + p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length); + } + break; + + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + break; + } + + /* calibrate rotation - kernel of c210 could not support V4L2_CID_PHYSICAL_ROTATION */ + if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) { + p->format.rotation += 180; + p->format.rotation = p->format.rotation % 360; + camsrc_info("Calibrate rotate : secondary camera +180 degree"); + } + + /* Rotation set */ + __ta__( " _CAMERASRC_CMD_ROTATION", + CAMERASRC_SET_CMD(_CAMERASRC_CMD_ROTATION, &(p->format.rotation)); + ); + + /* Sensor flip */ + __ta__( " _CAMERASRC_CMD_VFLIP", + CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip)); + ); + + __ta__( " _CAMERASRC_CMD_HFLIP", + CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip)); + ); + + /* set JPEG quality */ + if (p->format.pix_format == CAMERASRC_PIX_RGGB8) { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control control; + + control.id = V4L2_CID_CAM_JPEG_QUALITY; + control.value = p->format.quality; + camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_CAM_JPEG_QUALITY -> %d", control.value); + __ta__( " Stillshot V4L2_CID_CAM_JPEG_QUALITY", + err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control); + ); + if (err != CAMERASRC_SUCCESS) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("V4L2_CID_CAMERA_CAPTURE failed : %s", err_msg); + return err; + } + } + + /* A C T U A L S T A R T S T R E A M */ + switch(p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + camsrc_info("MMAP mode"); + + p->queued_buffer_count = 0; + for (cnt = 0; cnt < p->num_buffers; cnt++) { + struct v4l2_buffer lvbuf; + CLEAR(lvbuf); + + lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + lvbuf.memory = V4L2_MEMORY_MMAP; + lvbuf.index = cnt; + __ta__( " Stillshot VIDIOC_QBUF", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_QBUF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + LOCK(p); + p->buffer[lvbuf.index].queued_status = CAMERASRC_BUFFER_QUEUED; + p->queued_buffer_count++; + UNLOCK(p); + } + + camsrc_info("Stillshot VIDIOC_QBUF done"); + + vtype = V4L2_BUF_TYPE_VIDEO_CAPTURE; + __ta__( " Stillshot VIDIOC_STREAMON", + if( CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMON, &vtype)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_STREAMON failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + camsrc_info("Stillshot VIDIOC_STREAMON done"); + break; + + case CAMERASRC_IO_METHOD_USRPTR: + camsrc_info("USRPTR mode"); + for (cnt = 0; cnt < p->present_buf->num_buffer; cnt++) { + struct v4l2_buffer lvbuf; + CLEAR(lvbuf); + + lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + lvbuf.memory = V4L2_MEMORY_USERPTR; + lvbuf.index = cnt; + lvbuf.m.userptr = (unsigned long)p->buffer[cnt].start; + lvbuf.length = p->buffer[cnt].length; + + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_QBUF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + } + + camsrc_info("Stillshot VIDIOC_QBUF done"); + + vtype = V4L2_BUF_TYPE_VIDEO_CAPTURE; + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMON, &vtype)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_STREAMON failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + camsrc_info("Stillshot VIDIOC_STREAMON done"); + break; + + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + break; + } + + /* C210 Legacy V4L2 API for capture */ + if (p->format.pix_format == CAMERASRC_PIX_RGGB8) { + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_control control; + + control.id = V4L2_CID_CAMERA_CAPTURE; + control.value = 0; + camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_CAMERA_CAPTURE -> 0"); + __ta__( " Stillshot V4L2_CID_CAMERA_CAPTURE", + err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control); + ); + if (err != CAMERASRC_SUCCESS) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("V4L2_CID_CAMERA_CAPTURE failed : %s", err_msg); + return err; + } + } + + + LOCK(p); + __ta__( " Stillshot skip_frame_func", + if (_CAMERASRC_NEED_MISC_FUNCTION(p->cur_dev_id, CAMERASRC_OP_CAPTURE, p->format.colorspace, CAMERASRC_MISC_SKIP_FRAME)) { + p->skip_frame_func = (camerasrc_skip_frame_func_t)_camerasrc_skip_frame; + } else { + p->skip_frame_func = NULL; + } + ); + UNLOCK(p); + +#if defined(USE_SKIP_FRAME_AT_RAW_FRAME) + /*< If YUV capture, */ + if (!p->format.is_highquality_mode) { + if (p->skip_frame_func != NULL) { + p->skip_frame_func(p, 5000, 3); + } + } +#endif + + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_STILL); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_start_preview_stream(camsrc_handle_t handle) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + struct v4l2_streamparm vstreamparm; + struct v4l2_format vformat; + struct v4l2_requestbuffers vreq_bufs; + struct v4l2_control control; + enum v4l2_buf_type vtype; + int cnt = 0; + int preview_width = 0; + int preview_height = 0; +/* + int capture_width = 0; + int capture_height = 0; +*/ + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + /* STATE OR PHASE CHECKING */ + if(CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW) { + return CAMERASRC_SUCCESS; + } + if(CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_warning("Invalid state transition"); + } + + /* P R E V I E W M O D E S E T T I N G */ + CLEAR(vstreamparm); + vstreamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + __ta__( " VIDIOC_G_PARM", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_G_PARM, &vstreamparm)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_G_PARAM failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + vstreamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + + if ((vstreamparm.parm.capture.timeperframe.numerator != p->timeperframe.numerator) || + (vstreamparm.parm.capture.timeperframe.denominator != p->timeperframe.denominator) || + ((p->format.is_highquality_mode == 1) &&(vstreamparm.parm.capture.capturemode != V4L2_MODE_HIGHQUALITY)) || + ((p->format.is_highquality_mode == 0) &&(vstreamparm.parm.capture.capturemode != 0))) { + if (p->format.is_highquality_mode == 1) { + camsrc_info("High quality frame will be captured"); + vstreamparm.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY; + } else if (p->format.is_highquality_mode == 0) { + camsrc_info("Normal quality frame will be captured"); + vstreamparm.parm.capture.capturemode = 0; + } else { + camsrc_info("Quality not initialized, or incorrect value. set normal quality..."); + vstreamparm.parm.capture.capturemode = 0; + } + + vstreamparm.parm.capture.timeperframe.numerator = p->timeperframe.numerator; + vstreamparm.parm.capture.timeperframe.denominator = p->timeperframe.denominator; + + camsrc_info("[FPS] timeperframe.numerator = %d", p->timeperframe.numerator); + camsrc_info("[FPS] timeperframe.denominator = %d", p->timeperframe.denominator); + camsrc_info("[QUA] vstreamparm.parm.capture.capturemode = %d", vstreamparm.parm.capture.capturemode); + + __ta__( " VIDIOC_S_PARM", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_PARM, &vstreamparm)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_S_PARAM failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + } + + /* P R E V I E W F O R M A T S E T T I N G */ + if (!(p->format.pix_format == CAMERASRC_PIX_YUV422P || p->format.pix_format == CAMERASRC_PIX_YUV420P || + p->format.pix_format == CAMERASRC_PIX_SN12 || p->format.pix_format == CAMERASRC_PIX_ST12 || + p->format.pix_format == CAMERASRC_PIX_NV12 || p->format.pix_format == CAMERASRC_PIX_YUY2 || + p->format.pix_format == CAMERASRC_PIX_UYVY || p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) ) { + camsrc_error("Invalid output format."); + return CAMERASRC_ERR_INVALID_FORMAT; + } + + if (p->format.colorspace != CAMERASRC_COL_RAW) { + camsrc_error("Invalid store method."); + return CAMERASRC_ERR_INVALID_PARAMETER; + } + + err = _camerasrc_dump_format(handle); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Format dump error"); + return err; + } + + preview_width = p->format.img_size.dim.width; + preview_height = p->format.img_size.dim.height; + + CLEAR(vformat); + vformat.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vformat.fmt.pix.width = preview_width; + vformat.fmt.pix.height = preview_height; + vformat.fmt.pix.field = V4L2_FIELD_NONE; + + switch (p->format.pix_format) { + case CAMERASRC_PIX_YUV422P: + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P; + vformat.fmt.pix.bytesperline = preview_width << 1; + vformat.fmt.pix.sizeimage = (preview_width * preview_height) << 1; + break; + case CAMERASRC_PIX_YUY2: + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; + vformat.fmt.pix.bytesperline = preview_width << 1; + vformat.fmt.pix.sizeimage = (preview_width * preview_height) << 1; + break; + case CAMERASRC_PIX_UYVY: + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY; + vformat.fmt.pix.bytesperline = preview_width << 1; + vformat.fmt.pix.sizeimage = (preview_width * preview_height) << 1; + break; + case CAMERASRC_PIX_YUV420P: + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420; + vformat.fmt.pix.bytesperline = (preview_width * 3) >> 1; + vformat.fmt.pix.sizeimage = (preview_width * preview_height * 3) >> 1; + break; + case CAMERASRC_PIX_NV12: + case CAMERASRC_PIX_SN12: + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12; + vformat.fmt.pix.bytesperline = (preview_width * 3) >> 1; + vformat.fmt.pix.sizeimage = (preview_width * preview_height * 3) >> 1; + break; + case CAMERASRC_PIX_ST12: + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12T; + vformat.fmt.pix.bytesperline = (preview_width * 3) >> 1; + vformat.fmt.pix.sizeimage = (preview_width * preview_height * 3) >> 1; + break; + case CAMERASRC_PIX_INTERLEAVED: /* JPEG + YUYV */ + vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_INTERLEAVED; + vformat.fmt.pix.priv = V4L2_PIX_FMT_MODE_PREVIEW; + vformat.fmt.pix.field = IS_MODE_PREVIEW_STILL; + /* TODO: Set JPEG size */ + /* ... */ + break; + default: + camsrc_error("Invalid output format."); + break; + } + + camsrc_info("==========================================="); + camsrc_info("| Request output width = %d", vformat.fmt.pix.width); + camsrc_info("| Request output height = %d", vformat.fmt.pix.height); + camsrc_info("| Request output field = %d", vformat.fmt.pix.field); + camsrc_info("| Request output pixel format = %d", vformat.fmt.pix.pixelformat); + camsrc_info("| Request output bytesperline = %d", vformat.fmt.pix.bytesperline); + camsrc_info("| Request output image size = %d", vformat.fmt.pix.sizeimage); + camsrc_info("==========================================="); + + __ta__( " VIDIOC_S_FMT", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_FMT, &vformat)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_S_FMT failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + control.id = V4L2_CID_CACHEABLE; + if (p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) { + control.value = 1; + } else { + control.value = 0; + } + camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_CACHEABLE -> %d", control.value); + __ta__( " VIDIOC_S_CTRL: V4L2_CID_CACHEABLE", + err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control); + ); + if (err != CAMERASRC_SUCCESS) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("V4L2_CID_CACHEABLE failed : %s", err_msg); + return err; + } + + control.id = V4L2_CID_EMBEDDEDDATA_ENABLE; + if (p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) { + control.value = 1; + } else { + control.value = 0; + } + camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_EMBEDDEDDATA_ENABLE -> %d", control.value); + __ta__( " VIDIOC_S_CTRL: V4L2_CID_EMBEDDEDDATA_ENABLE", + err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control); + ); + if (err != CAMERASRC_SUCCESS) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("V4L2_CID_EMBEDDEDDATA_ENABLE failed : %s", err_msg); + return err; + } + + /* Prepare alter format frame */ + __ta__( " camerasrc_query_img_buf_size", + camerasrc_query_img_buf_size(p, &(p->alter_frame.length), NULL); + ); + p->alter_frame.start = (unsigned char*) malloc(p->alter_frame.length); + if (p->alter_frame.start == NULL) { + camsrc_error("alter_frame alloc failed."); + return CAMERASRC_ERR_ALLOCATION; + } + + /* M E M O R Y M A P P I N G */ + CLEAR(vreq_bufs); + switch(p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + camsrc_info("MMAP mode"); + vreq_bufs.count = CAMERASRC_PREVIEW_BUFFER_NUM; + vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vreq_bufs.memory = V4L2_MEMORY_MMAP; + camsrc_info("MMAP mode (bufs.count:%d)", vreq_bufs.count); + __ta__( " VIDIOC_REQBUFS", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + camsrc_assert(vreq_bufs.count >= 1); + + p->num_buffers = vreq_bufs.count; + p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t)); + if (!p->buffer) { + camsrc_error("calloc() failed"); + return CAMERASRC_ERR_ALLOCATION; + } + + for (p->buffer_idx = 0; p->buffer_idx < vreq_bufs.count; ++(p->buffer_idx)) { + struct v4l2_buffer vbuf; + CLEAR(vbuf); + vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vbuf.memory = V4L2_MEMORY_MMAP; + vbuf.index = p->buffer_idx; + + __ta__( " VIDIOC_QUERYBUF", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QUERYBUF, &vbuf)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_QUERYBUF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + __ta__( " mmap", + p->buffer[p->buffer_idx].length = vbuf.length; + p->buffer[p->buffer_idx].start = mmap(NULL /* start anywhere */, + vbuf.length, + PROT_READ | PROT_WRITE, + MAP_SHARED, + p->dev_fd, vbuf.m.offset); + ); + if (MAP_FAILED == p->buffer[p->buffer_idx].start) { + camsrc_error("mmap failed."); + return CAMERASRC_ERR_ALLOCATION; + } + + GST_INFO("buffer index %d, addr %x, length %d", + p->buffer_idx, p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length); + + switch (p->format.pix_format) { + case CAMERASRC_PIX_YUV422P: + case CAMERASRC_PIX_YUY2: + case CAMERASRC_PIX_UYVY: + if (p->buffer[p->buffer_idx].length < p->format.img_size.dim.width * p->format.img_size.dim.height * 2) { + camsrc_error("format[%d] device insufficient memory.", p->format.pix_format); + } + break; + case CAMERASRC_PIX_YUV420P: + case CAMERASRC_PIX_NV12: + if (p->buffer[p->buffer_idx].length < (p->format.img_size.dim.width * p->format.img_size.dim.height * 3 / 2)) { + camsrc_error("format[%d] device insufficient memory.", p->format.pix_format); + } + break; + case CAMERASRC_PIX_SN12: + case CAMERASRC_PIX_ST12: + if (p->buffer[p->buffer_idx].length < (p->format.img_size.dim.width * p->format.img_size.dim.height)) { + camsrc_error("SN12,ST12: device insufficient memory."); + } + break; + case CAMERASRC_PIX_INTERLEAVED: + if (p->buffer[p->buffer_idx].length < (p->format.img_size.dim.width * p->format.img_size.dim.height)) { + camsrc_error("INTERLEAVED: device insufficient memory."); + } + break; + default: + camsrc_error("Not supported format[%d]", p->format.pix_format); + break; + } + + camsrc_info("MMAP BUF: addr[%p] size[%d]", + p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length); + } + break; + case CAMERASRC_IO_METHOD_USRPTR: + camsrc_info("USRPTR mode"); + + vreq_bufs.count = p->present_buf->num_buffer; + vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vreq_bufs.memory = V4L2_MEMORY_USERPTR; + __ta__( " VIDIOC_REQBUFS", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + camsrc_assert(vreq_bufs.count >= 1); + + p->num_buffers = vreq_bufs.count; + p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t)); + + if(!p->buffer) { + camsrc_error("calloc() failed"); + return CAMERASRC_ERR_ALLOCATION; + } + + if(!p->present_buf->present_buffer) { + camsrc_error("No Usrptr buffer presented!"); + return CAMERASRC_ERR_ALLOCATION; + } + + for (p->buffer_idx = 0; p->buffer_idx < vreq_bufs.count; ++(p->buffer_idx)) { + p->buffer[p->buffer_idx].length = p->present_buf->present_buffer[p->buffer_idx].length; + p->buffer[p->buffer_idx].start = p->present_buf->present_buffer[p->buffer_idx].start; + + if (!p->buffer[p->buffer_idx].start) { + camsrc_error("presented usrptr buffer is NULL"); + return CAMERASRC_ERR_ALLOCATION; + } + + camsrc_info("USERPTR BUF: addr[%p] size[%d]", + p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length); + } + break; + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + break; + } + + /* A C T U A L S T A R T S T R E A M */ + switch(p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + camsrc_info("MMAP mode"); + + p->queued_buffer_count = 0; + for (cnt = 0; cnt < p->num_buffers; cnt++) { + struct v4l2_buffer lvbuf; + CLEAR(lvbuf); + + lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + lvbuf.memory = V4L2_MEMORY_MMAP; + lvbuf.index = cnt; + __ta__( " VIDIOC_QBUF", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_QBUF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + LOCK(p); + p->buffer[lvbuf.index].queued_status = CAMERASRC_BUFFER_QUEUED; + p->queued_buffer_count++; + UNLOCK(p); + } + break; + case CAMERASRC_IO_METHOD_USRPTR: + camsrc_info("USRPTR mode"); + + for (cnt = 0; cnt < p->present_buf->num_buffer; cnt++) { + struct v4l2_buffer lvbuf; + CLEAR(lvbuf); + + lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + lvbuf.memory = V4L2_MEMORY_USERPTR; + lvbuf.index = cnt; + lvbuf.m.userptr = (unsigned long)p->buffer[cnt].start; + lvbuf.length = p->buffer[cnt].length; + __ta__( " VIDIOC_QBUF", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_QBUF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + camsrc_info("QBUF Address [%d] %p", lvbuf.index, (void*)lvbuf.m.userptr); + + memcpy(&(p->queued_buf_list[cnt]), &lvbuf, sizeof(struct v4l2_buffer)); + } + break; + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + break; + } + + /* calibrate rotation - kernel of c210 could not support V4L2_CID_PHYSICAL_ROTATION */ + if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) { + p->format.rotation += 180; + p->format.rotation = p->format.rotation % 360; + camsrc_info("Calibrate rotate : secondary camera +180 degree"); + } + + /* Rotation set */ + __ta__( " _CAMERASRC_CMD_ROTATION", + CAMERASRC_SET_CMD(_CAMERASRC_CMD_ROTATION, &(p->format.rotation)); + ); +#if USE_SENSOR_MODE + /* Sensor mode Set */ + __ta__( " _CAMERASRC_CMD_SENSOR_MODE", + CAMERASRC_SET_CMD(_CAMERASRC_CMD_SENSOR_MODE, &(p->sensor_mode)); + ); +#endif + /* Sensor flip */ + __ta__( " _CAMERASRC_CMD_VFLIP", + CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip)); + ); + __ta__( " _CAMERASRC_CMD_HFLIP", + CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip)); + ); + + vtype = V4L2_BUF_TYPE_VIDEO_CAPTURE; + __ta__( " VIDIOC_STREAMON", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMON, &vtype)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_STREAMON failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + /* For noti that it is first frame DQ */ + p->first_frame = 1; + + LOCK(p); + if (_CAMERASRC_NEED_MISC_FUNCTION(p->cur_dev_id, CAMERASRC_OP_PREVIEW, p->format.colorspace, CAMERASRC_MISC_SKIP_FRAME)) { + p->skip_frame_func = (camerasrc_skip_frame_func_t)_camerasrc_skip_frame; + } else { + p->skip_frame_func = NULL; + } + UNLOCK(p); + +#if defined(USE_SKIP_FRAME_AT_RAW_FRAME) + if(p->skip_frame_func != NULL) + p->skip_frame_func(p, 5000, 3); +#endif + + for (cnt = 0; cnt < p->num_buffers; cnt++) { + camsrc_info("MMAP/USRPTR BUF: addr[%p] size[%d]", p->buffer[cnt].start, p->buffer[cnt].length); + } + + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_query_img_buf_size(camsrc_handle_t handle, unsigned int* main_img_size, unsigned int* thm_img_size) +{ + camerasrc_handle_t* p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL && + CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW && + CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO) { + camsrc_warning("Invalid state transition"); + } + + camsrc_info("Start to set format"); + + if (p->format.colorspace == CAMERASRC_COL_RAW && + (p->format.pix_format == CAMERASRC_PIX_YUV422P || + p->format.pix_format == CAMERASRC_PIX_YUY2 || + p->format.pix_format == CAMERASRC_PIX_UYVY || + p->format.pix_format == CAMERASRC_PIX_INTERLEAVED)) { + *main_img_size = p->format.img_size.dim.width * p->format.img_size.dim.height * 2; + if (thm_img_size != NULL) { + *thm_img_size = 0; + } + camsrc_info("422 RAW!! WIDTH = %d, HEIGHT=%d, SIZE = %d", + p->format.img_size.dim.width, p->format.img_size.dim.height, *main_img_size); + } else if (p->format.colorspace == CAMERASRC_COL_RAW && + (p->format.pix_format == CAMERASRC_PIX_YUV420P || + p->format.pix_format == CAMERASRC_PIX_SN12 || + p->format.pix_format == CAMERASRC_PIX_ST12 || + p->format.pix_format == CAMERASRC_PIX_NV12)) { + /*Kessler preview path*/ + *main_img_size = p->format.img_size.dim.width * p->format.img_size.dim.height * 3 / 2; + if (thm_img_size != NULL) { + *thm_img_size = 0; + } + camsrc_info("420 RAW!! WIDTH = %d, HEIGHT=%d, SIZE = %d", + p->format.img_size.dim.width, p->format.img_size.dim.height, *main_img_size); + } else if (p->format.colorspace == CAMERASRC_COL_JPEG) { + if (p->format.pix_format == CAMERASRC_PIX_RGGB10) { + camsrc_info("JPG + YUV Mode enabled."); + *main_img_size = CAMERASRC_JPG_STILL_H_SYNC * CAMERASRC_JPG_STILL_V_SYNC; + if (thm_img_size != NULL) { + *thm_img_size = 320 * 240 * 2; + } + } else if (p->format.pix_format == CAMERASRC_PIX_RGGB8) { + /*Kessler capture path*/ + camsrc_info("JPG + JPG Mode enabled."); + *main_img_size = CAMERASRC_JPG_STILL_H_SYNC * CAMERASRC_JPG_STILL_V_SYNC; + if (thm_img_size != NULL) { + *thm_img_size = CAMERASRC_JPG_STILL_H_SYNC * CAMERASRC_JPG_STILL_V_SYNC - CAMERASRC_JPG_STILL_THUMBNAIL_OFFSET; + } + } else { + camsrc_error("Unknown image format..."); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + camsrc_info("JPEG!! WIDTH = %d, HEIGHT=%d, SIZE = %d", + p->format.img_size.dim.width, p->format.img_size.dim.height, *main_img_size); + } else { + camsrc_error("Unknown format set. can't go any more"); + camsrc_assert(0); + } + + camsrc_info("leave.."); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_stop_stream(camsrc_handle_t handle) +{ + camerasrc_handle_t *p = NULL; + enum v4l2_buf_type type; + int cnt = 0; + int try_count = 0; + camerasrc_auto_focus_status_t af_status = 0; + struct v4l2_requestbuffers vreq_bufs; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) == CAMERASRC_STATE_READY) { + return CAMERASRC_SUCCESS; + } + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL && + CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW && + CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO && + CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) { + camsrc_warning("Stop stream called [STREAM-NOT-STARTED STATE]"); + } + + camsrc_info("Change to READY state first for preventing to check Q/DQ after stop"); + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_READY); + + LOCK(p); + p->timeperframe.denominator = 0; + p->timeperframe.numerator = 0; + p->first_frame = 1; + UNLOCK(p); + +#ifdef STOP_AF_BEFORE_STREAMOFF + _camerasrc_stop_autofocusing(p); + + /* Wait for AF stop done */ + try_count = 0; + __ta__( " camerasrc_stop_stream:Wait for AF release", + while (try_count++ < CAMERASRC_AF_TOTALTIME/CAMERASRC_AF_STOP_INTERVAL) { + usleep( CAMERASRC_AF_STOP_INTERVAL ); + camerasrc_get_autofocusing_status(p, &af_status); + if (af_status == CAMERASRC_AUTO_FOCUS_STATUS_RELEASED) { + camsrc_info("AF Stop done"); + break; + } + } + ); +#endif /* STOP_AF_BEFORE_STREAMOFF */ + + /* S T O P S T R E A M */ + type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + __ta__( " camerasrc_stop_stream:VIDIOC_STREAMOFF", + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMOFF, &type)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_STREAMOFF failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + ); + + /* M E M O R Y U N M A P P I N G & F R E E */ + switch(p->io_method) { + case CAMERASRC_IO_METHOD_MMAP: + camsrc_info("Init io method to MMAP mode"); + for (cnt = 0; cnt < p->num_buffers; ++cnt) { + if (-1 == munmap (p->buffer[cnt].start,p->buffer[cnt].length)) { + camsrc_error("MUNMAP failed."); + return CAMERASRC_ERR_INTERNAL; + } + + p->buffer[cnt].start = NULL; + p->buffer[cnt].length = 0; + } + break; + case CAMERASRC_IO_METHOD_USRPTR: + camsrc_info("User ptr mode don't need munmap"); + break; + case CAMERASRC_IO_METHOD_READ: + default: + camsrc_error("Device not support that io-method"); +#if USE_NOT_SUPPORT_ERR + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; +#else + return CAMERASRC_SUCCESS; +#endif + } + + /* release buffer */ + CLEAR(vreq_bufs); + vreq_bufs.count = 0; + vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + vreq_bufs.memory = V4L2_MEMORY_MMAP; + if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) { + strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + + /* RETURN BUFFER MANAGE MODE TO DEFAULT */ + p->io_method = CAMERASRC_IO_METHOD_MMAP; + p->present_buf = NULL; + + if (p->buffer != NULL) { + free(p->buffer); + } + + if (p->alter_frame.start != NULL) { + free(p->alter_frame.start); + } + + p->buffer = NULL; + p->alter_frame.start = NULL; + + p->buffer_idx = 0; + p->num_buffers = 0; + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_wait_frame_available(camsrc_handle_t handle, long int timeout) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL && + CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW && + CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO && + CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) { + camsrc_warning("Invalid state transition" ); + } + + if ( p->queued_buffer_count > 0 ) { + /*camsrc_info( CAMERASRC, "Current queue count : %d", p->queued_buffer_count );*/ + err = _camerasrc_wait_frame_available(p, timeout); + } else { + camsrc_warning("queued_buffer_count[%d] is unavailable. sleep 100 ms and try again...", p->queued_buffer_count ); + usleep( 100000 ); + err = CAMERASRC_ERR_INVALID_STATE; + } + + return err; +} + + +int camerasrc_check_esd_shock(camsrc_handle_t *handle, int *check_val) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + printf("start _camerasrc_check_emp_shock"); + *check_val = 0; + err = _camerasrc_check_emp_shock(p, check_val); + printf("check_val = %d", *check_val); + printf("end _camerasrc_check_emp_shock"); + + return err; +} + + +int camerasrc_queue_buffer(camsrc_handle_t handle, int buf_index, camerasrc_buffer_t *buffer) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL && + CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW && + CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO && + CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS ) { + camsrc_warning("Invalid state transition"); + } + + err = _camerasrc_queue_buffer(p, buf_index, buffer); + + return err; +} + + +int camerasrc_dequeue_buffer(camsrc_handle_t handle, int *buf_index, camerasrc_buffer_t *buffer, camerasrc_buffer_t *thm_buffer) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL && + CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW && + CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO && + CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) { + camsrc_warning("Invalid state transition"); + } + + err = _camerasrc_dequeue_buffer(p, buf_index, buffer, thm_buffer); + + return err; +} + + +int camerasrc_read_frame(camsrc_handle_t handle, camerasrc_buffer_t *main_img_buffer, camerasrc_buffer_t *thm_img_buffer, int *buffer_index) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("ENTER"); + + if (!handle || !main_img_buffer || !thm_img_buffer || !buffer_index) { + camsrc_error("handle(%p)main(%p)thm(%p)index(%p) is null", + handle, main_img_buffer, thm_img_buffer, buffer_index); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL && + CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW && + CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO && + CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) { + camsrc_warning("Invalid state transition"); + } + +#ifndef DUMMY_OUTPUT + __ta__( " Stillshot select()", + err = _camerasrc_wait_frame_available(p, CAMERASRC_TIMEOUT_CRITICAL_VALUE); + ); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Frame waiting error, [%x]", err); + return err; + } + + /* Buffer DQ */ + __ta__( " Stillshot VIDIOC_DQBUF", + err = _camerasrc_dequeue_buffer(p, buffer_index, main_img_buffer, thm_img_buffer); + ); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Dequeue frame error, [%x]", err); + return err; + } +#endif + + camsrc_info("DEQUEUED Index : %d", *buffer_index); + +#if defined(USE_CAMERASRC_FRAME_DUMP) + printf("******************in buf len = %d", inner_main_buffer.length); + write_buffer_into_path(&inner_main_buffer, CAMERASRC_FRAME_DUMP_PATH, "main.jpg"); +#endif + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_set_focused_callback(camsrc_handle_t handle, camerasrc_callback_t cb, void *usr_data) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_REALIZED && + CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_warning("Invalid state transition"); + } + + LOCK(p); + p->af_cb = cb; + if (usr_data != NULL) { + p->af_usr_data = usr_data; + } + UNLOCK(p); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_set_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t *rect) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) { + camsrc_warning("Invalid state transition"); + } + + err = _camerasrc_set_autofocusing_area(p, rect); + + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Set autofocusing area error"); + return err; + } + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_get_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t *rect) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) { + camsrc_warning("Invalid state transition"); + } + + err = _camerasrc_get_autofocusing_area(p, rect); + + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Get autofocusing area error"); + return err; + } + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_start_autofocusing(camsrc_handle_t handle) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (!(CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW || + CAMERASRC_STATE(p) == CAMERASRC_STATE_VIDEO || + CAMERASRC_STATE(p) == CAMERASRC_STATE_AF_IN_PROGRESS)) { + camsrc_error("Invalid state [%d]", CAMERASRC_STATE(p)); + return CAMERASRC_ERR_INVALID_STATE; + } + + /* START AF */ + err = _camerasrc_start_autofocusing(p); + + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Create autofocusing thread error"); + return err; + } + + camsrc_info("Set state to [AF-IN-PROGRESS]!!"); + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_AF_IN_PROGRESS); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_stop_autofocusing(camsrc_handle_t handle) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (!(CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW || + CAMERASRC_STATE(p) == CAMERASRC_STATE_VIDEO || + CAMERASRC_STATE(p) == CAMERASRC_STATE_AF_IN_PROGRESS)) { + camsrc_error("Invalid state [%d]", CAMERASRC_STATE(p)); + return CAMERASRC_ERR_INVALID_STATE; + } + + /* STOP AF */ + camsrc_info("AF_STOP called!!"); + err = _camerasrc_stop_autofocusing(p); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Stop autofocusing error"); + return err; + } + + if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) { + camsrc_info("Set state to [PREVIEW] again!!"); + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW); + } else { + camsrc_info("Do not change state"); + } + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_release_autofocusing(camsrc_handle_t handle) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW && + CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO && + CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) { + return CAMERASRC_SUCCESS; + } + + /* STOP AF */ + camsrc_info("AF_RELEASE called!!"); + err = _camerasrc_release_autofocusing(p); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Stop autofocusing error"); + return err; + } + + camsrc_info("Set state to [PREVIEW] again!!"); + CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_init_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t af_mode, camerasrc_af_scan_range_t af_range) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW) { + camsrc_warning("Invalid state transition"); + } + + p->cur_af_mode = af_mode; + p->cur_af_range = af_range; + + err = _camerasrc_init_autofocusing_mode(p); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Init autofocusing mode error"); + return err; + } + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_get_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t *af_mode, camerasrc_af_scan_range_t *af_range) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (af_mode) { + *af_mode = p->cur_af_mode; + } + + if (af_range) { + *af_range = p->cur_af_range; + } + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_get_autofocusing_status(camsrc_handle_t handle, camerasrc_auto_focus_status_t *af_status) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + if (af_status == NULL) { + camsrc_error("*af_status is NULL"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + *af_status = p->af_status; + + camsrc_info("[camerasrc_get_autofocusing_status] %d", *af_status); + + return CAMERASRC_SUCCESS; +} + +/**** M I S C E L L A N E O U S O P E R A T I O N ****/ + +/**** I N P U T ( C A M D E V I C E ) O P E R A T I O N ****/ + +int camerasrc_get_input(camsrc_handle_t handle, camerasrc_dev_id_t *id) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) { + camsrc_warning("Invalid phase"); + } + + *id = p->cur_dev_id; + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_set_input(camsrc_handle_t handle, camerasrc_dev_id_t camera_id) +{ + camerasrc_handle_t *p = NULL; + struct v4l2_control control; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_error("Invalid state"); + return CAMERASRC_ERR_INVALID_STATE; + } + + if (p->cur_dev_id == camera_id) { + return CAMERASRC_SUCCESS; + } + + camsrc_info("Set Index to %d", _CAMERASRC_GET_DEV_INDEX(camera_id)); + + err = _camerasrc_ioctl(p, VIDIOC_S_INPUT, &(_CAMERASRC_GET_DEV_INDEX(camera_id))); + if (CAMERASRC_SUCCESS != err) { + camsrc_error("[***DEBUG] ERROR SET INPUT to %dth DEVICE", _CAMERASRC_GET_DEV_INDEX(camera_id)); + return CAMERASRC_ERR_IO_CONTROL; + } else { + camsrc_info("[***DEBUG] SET INPUT OK!!! to %dth DEVICE", _CAMERASRC_GET_DEV_INDEX(camera_id)); + camsrc_info("return value of ioctl VIDIOC_S_INPUT = %d", err); + } + + p->cur_dev_id = camera_id; + + /* check physical rotation of camera lens */ + #ifndef V4L2_CID_PHYSICAL_ROTATION + #define V4L2_CID_PHYSICAL_ROTATION (V4L2_CID_PRIVATE_BASE + 300) + #endif /* V4L2_CID_PHYSICAL_ROTATION */ + + control.id = V4L2_CID_PHYSICAL_ROTATION; + _camerasrc_ioctl(handle, VIDIOC_G_CTRL, &control); + if(CAMERASRC_SUCCESS != _camerasrc_ioctl(handle, VIDIOC_G_CTRL, &control)) { + camsrc_warning("failed to get rotation of lens"); + p->lens_rotation = -1; + } else { + p->lens_rotation = control.value; + camsrc_info("lens rotation %d", p->lens_rotation); + } + + return err; +} + +/**** O U T P U T C O N T R O L O P E R A T I O N ****/ + +int camerasrc_set_timeperframe(camsrc_handle_t handle, camerasrc_frac_t *frac) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) { + camsrc_warning("Invalid phase, but can go"); + } + + camsrc_info("Numerator = %d, Denominator = %d", frac->numerator, frac->denominator); + + LOCK(p); + p->timeperframe.numerator = frac->numerator; + p->timeperframe.denominator = frac->denominator; + UNLOCK(p); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_set_format(camsrc_handle_t handle, camerasrc_format_t *fmt) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_error("Invalid state"); + } + + err = _camerasrc_dump_format(handle); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Format dump error"); + return err; + } + + CLEAR(p->format); + + p->format.colorspace = fmt->colorspace; + p->format.bytesperline = fmt->bytesperline; + p->format.img_size.dim.width = fmt->img_size.dim.width; + p->format.img_size.dim.height = fmt->img_size.dim.height; + p->format.thumb_size.dim.width = fmt->thumb_size.dim.width; + p->format.thumb_size.dim.height= fmt->thumb_size.dim.height; + p->format.is_highquality_mode = fmt->is_highquality_mode; + p->format.pix_format = fmt->pix_format; + p->format.quality = fmt->quality; + p->format.sizeimage = fmt->sizeimage; + p->format.rotation = fmt->rotation; + p->is_preset = 0; + + switch (fmt->pix_format) { + case CAMERASRC_PIX_YUV422P: + p->format.num_planes = 3; + break; + case CAMERASRC_PIX_YUV420P: + p->format.num_planes = 3; + break; + case CAMERASRC_PIX_YUV420: + p->format.num_planes = 2; + break; + case CAMERASRC_PIX_SN12: + p->format.num_planes = 2; + break; + case CAMERASRC_PIX_ST12: + p->format.num_planes = 2; + break; + case CAMERASRC_PIX_NV12: + p->format.num_planes = 2; + break; + case CAMERASRC_PIX_YUY2: + p->format.num_planes = 1; + break; + case CAMERASRC_PIX_UYVY: + p->format.num_planes = 1; + break; + case CAMERASRC_PIX_RGGB8: + p->format.num_planes = 1; + break; + case CAMERASRC_PIX_RGGB10: + p->format.num_planes = 1; + break; + case CAMERASRC_PIX_RGB565: + p->format.num_planes = 1; + break; + default: + p->format.num_planes = 3; + camsrc_error("Invalid output format."); + break; + } + + err = _camerasrc_dump_format(handle); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Format dump error"); + return err; + } + + camsrc_info("leave"); + + return err; +} + + +int camerasrc_get_format(camsrc_handle_t handle, camerasrc_format_t *fmt) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) { + camsrc_warning("Invalid phase"); + } + + memcpy(fmt, &(p->format), sizeof(camerasrc_format_t)); + + camsrc_info("leave"); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_try_format(camsrc_handle_t handle, camerasrc_format_t *fmt) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) { + camsrc_error("Invalid state"); + return CAMERASRC_ERR_INVALID_STATE; + } + + /* size limitaion check */ + if (fmt->img_size.dim.width < 0 || fmt->img_size.dim.width > CAMERASRC_MAX_WIDTH) { + camsrc_info("Invalid width"); + return CAMERASRC_ERR_INVALID_PARAMETER; + } + if (fmt->img_size.dim.height < 0 || fmt->img_size.dim.height > CAMERASRC_MAX_HEIGHT) { + camsrc_info("Invalid height"); + return CAMERASRC_ERR_INVALID_PARAMETER; + } + + /* check pixel number & colorspace are in bound */ + if (fmt->pix_format < 0 || fmt->pix_format >= CAMERASRC_PIX_NUM) { + camsrc_info("Invalid pixel format"); + return CAMERASRC_ERR_INVALID_PARAMETER; + } + if (fmt->colorspace < 0 || fmt->colorspace >= CAMERASRC_COL_NUM) { + camsrc_info("Invalid colorspace"); + return CAMERASRC_ERR_INVALID_PARAMETER; + } + + /* colorspace & pixel format combinability check */ + if (_CAMERASRC_MATCH_COL_TO_PIX(p->cur_dev_id, fmt->colorspace, fmt->pix_format, CAMERASRC_QUALITY_HIGH) || + _CAMERASRC_MATCH_COL_TO_PIX(p->cur_dev_id, fmt->colorspace, fmt->pix_format, CAMERASRC_QUALITY_NORMAL)) { + err = CAMERASRC_SUCCESS; + } else { + camsrc_info("UNAVAILABLE SETTING"); + err = CAMERASRC_ERR_INVALID_PARAMETER; + } + + camsrc_info("leave"); + + return err; +} + + +int camerasrc_get_frame_data(camsrc_handle_t handle, camerasrc_frame_data_t *data) +{ + camerasrc_handle_t *p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) { + camsrc_warning("Invalid state transition"); + } + + err = _camerasrc_get_frame_data(p, data); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("toggle auto exposure failed"); + return err; + } + + return err; +} + + +static int _camerasrc_dump_format(camsrc_handle_t handle) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + camsrc_info("---------FORMAT SETTING DUMP--------"); + camsrc_info("- Image size : %d x %d", p->format.img_size.dim.width, p->format.img_size.dim.height); + camsrc_info("- Thumbnail size : %d x %d", p->format.thumb_size.dim.width, p->format.thumb_size.dim.height); + camsrc_info("- Pixel format : %d", p->format.pix_format); + camsrc_info("- Bytes per line : %d", p->format.bytesperline); + camsrc_info("- Image size in bytes : %d", p->format.sizeimage); + camsrc_info("- Colorspace : %d", p->format.colorspace); + camsrc_info("- Rotation : %d", p->format.rotation); + camsrc_info("------------------------------------"); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_get_exif_info(camsrc_handle_t handle, camerasrc_exif_t *exif_struct) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) { + camsrc_warning("Invalid state transition"); + } + + err = _camerasrc_get_exif_info(p, (camerasrc_buffer_t*)exif_struct); + if (err != CAMERASRC_SUCCESS) { + camsrc_error("Get exif information string failed"); + } + + return err; +} + + +int camerasrc_device_is_open(camsrc_handle_t handle) +{ + camerasrc_handle_t *p = handle; + + if (p) { + if (p->dev_fd > 0) { + return TRUE; + } + } + + return FALSE; +} + + +int camerasrc_set_videofd(camsrc_handle_t handle, int videofd) +{ + camerasrc_handle_t *p = handle; + + if (p) { + p->dev_fd = videofd; + return CAMERASRC_SUCCESS; + } else { + return CAMERASRC_ERR_INVALID_HANDLE; + } +} + + +int camerasrc_set_af_hold_after_capture(camsrc_handle_t handle, int hold_af) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + p->hold_af_after_capturing = hold_af; + + camsrc_info("leave"); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_set_sensor_mode(camsrc_handle_t handle, int mode) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + p->sensor_mode = mode; + + camsrc_info("leave"); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_set_vflip(camsrc_handle_t handle, int vflip) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + p->vflip = vflip; + + if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) { + CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip)); + } + + camsrc_info("leave"); + + return CAMERASRC_SUCCESS; +} + + +int camerasrc_set_hflip(camsrc_handle_t handle, int hflip) +{ + camerasrc_handle_t *p = NULL; + + camsrc_info("enter"); + + if (handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + p->hflip = hflip; + if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) { + CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip)); + } + + camsrc_info("leave"); + + return CAMERASRC_SUCCESS; +} + + +/* For Query functionalities */ +int camerasrc_read_basic_dev_info(camerasrc_dev_id_t dev_id, camerasrc_caps_info_t* caps_info) +{ + int err = CAMERASRC_ERR_UNKNOWN; + int nread = 0; + char* store_path = NULL; + FILE *fp = NULL; + + camsrc_info("enter"); + + if(dev_id == CAMERASRC_DEV_ID_PRIMARY) + store_path = CAMERASRC_PRIMARY_BASIC_INFO_PATH; + else if (dev_id == CAMERASRC_DEV_ID_SECONDARY) + store_path = CAMERASRC_SECONDARY_BASIC_INFO_PATH; + else + { + camsrc_error("Unsupported device ID"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + fp = fopen(store_path, "rb"); + if(fp) + { + fseek(fp, 0, SEEK_SET); + nread = fread(caps_info, 1, sizeof(camerasrc_caps_info_t), fp); + camsrc_info("Need to be read : %d / Actual read : %d", sizeof(camerasrc_caps_info_t), nread); + fclose(fp); + } + else + return CAMERASRC_ERR_ALLOCATION; + + err = CAMERASRC_SUCCESS; + camsrc_info("leave"); + return err; +} + + +int camerasrc_read_misc_dev_info(camerasrc_dev_id_t dev_id, camerasrc_ctrl_list_info_t* ctrl_info) +{ + int err = CAMERASRC_ERR_UNKNOWN; + camsrc_info("enter"); + + int nread = 0; + FILE *fp = NULL; + char* store_path = NULL; + + if(dev_id == CAMERASRC_DEV_ID_PRIMARY) + store_path = CAMERASRC_PRIMARY_MISC_INFO_PATH; + else if (dev_id == CAMERASRC_DEV_ID_SECONDARY) + store_path = CAMERASRC_SECONDARY_MISC_INFO_PATH; + else + { + camsrc_error("Unsupported device ID"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + fp = fopen(store_path, "rb"); + if(fp) + { + fseek(fp, 0, SEEK_SET); + nread = fread(ctrl_info, 1, sizeof(camerasrc_ctrl_list_info_t), fp); + camsrc_info("Need to be read : %d / Actual read : %d", sizeof(camerasrc_ctrl_list_info_t), nread); + fclose(fp); + } + else + return CAMERASRC_ERR_ALLOCATION; + + err = CAMERASRC_SUCCESS; + camsrc_info("leave"); + return err; +} + + +int camerasrc_read_extra_dev_info(camerasrc_dev_id_t dev_id, camerasrc_extra_info_t* extra_info) +{ + int err = CAMERASRC_ERR_UNKNOWN; + camsrc_info("enter"); + + int nread = 0; + FILE *fp = NULL; + char* store_path = NULL; + + if(dev_id == CAMERASRC_DEV_ID_PRIMARY) + store_path = CAMERASRC_PRIMARY_EXTRA_INFO_PATH; + else if (dev_id == CAMERASRC_DEV_ID_SECONDARY) + store_path = CAMERASRC_SECONDARY_EXTRA_INFO_PATH; + else + { + camsrc_error("Unsupported device ID"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + fp = fopen(store_path, "rb"); + if(fp) + { + fseek(fp, 0, SEEK_SET); + nread = fread(extra_info, 1, sizeof(camerasrc_extra_info_t), fp); + camsrc_info("Need to be read : %d / Actual read : %d", sizeof(camerasrc_extra_info_t), nread); + fclose(fp); + } + else + return CAMERASRC_ERR_ALLOCATION; + + err = CAMERASRC_SUCCESS; + camsrc_info("leave"); + return err; +} + + +int camerasrc_write_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info) +{ + camerasrc_handle_t* p = NULL; + char* store_path = NULL; + FILE *fp = NULL; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + int nwrite = 0; + + if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY) + { + camsrc_info("Primary(Mega) camera capabilities info will be written.."); + store_path = CAMERASRC_PRIMARY_BASIC_INFO_PATH; + } + else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) + { + camsrc_info("Secondary(VGA) camera capabilities info will be written.."); + store_path = CAMERASRC_SECONDARY_BASIC_INFO_PATH; + } + else + { + camsrc_error("Unsupported device ID"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + camsrc_info("PATH = %s", store_path); + + fp = fopen(store_path, "wb"); + if(fp) + { + fseek(fp, 0, SEEK_SET); + nwrite = fwrite(caps_info, 1, sizeof(camerasrc_caps_info_t), fp); + camsrc_info("Need to be written : %d / Actual written : %d", sizeof(camerasrc_caps_info_t), nwrite); + fclose(fp); + } + else + return CAMERASRC_ERR_ALLOCATION; + + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + + +int camerasrc_write_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_info) +{ + camerasrc_handle_t* p = NULL; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + int nwrite = 0; + FILE *fp = NULL; + + char* store_path = NULL; + + if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY) + { + camsrc_info("Primary(Mega) camera controls info will be written.."); + store_path = CAMERASRC_PRIMARY_MISC_INFO_PATH; + } + else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) + { + camsrc_info("Secondary(VGA) camera controls info will be written.."); + store_path = CAMERASRC_SECONDARY_MISC_INFO_PATH; + } + else + { + camsrc_error("Unsupported device ID"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + fp = fopen(store_path, "wb"); + if(fp) + { + fseek(fp, 0, SEEK_SET); + nwrite = fwrite(ctrl_info, 1, sizeof(camerasrc_ctrl_list_info_t), fp); + camsrc_info("Need to be written : %d / Actual written : %d", sizeof(camerasrc_ctrl_list_info_t), nwrite); + fclose(fp); + } + else + return CAMERASRC_ERR_ALLOCATION; + + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + + +int camerasrc_write_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info) +{ + camerasrc_handle_t* p = NULL; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + int nwrite = 0; + FILE *fp = NULL; + + char* store_path = NULL; + + if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY) + { + camsrc_info("Primary(Mega) extra controls info will be written.."); + store_path = CAMERASRC_PRIMARY_EXTRA_INFO_PATH; + } + else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) + { + camsrc_info("Secondary(VGA) extra controls info will be written.."); + store_path = CAMERASRC_SECONDARY_EXTRA_INFO_PATH; + } + else + { + camsrc_error("Unsupported device ID"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + fp = fopen(store_path, "wb"); + if(fp) + { + fseek(fp, 0, SEEK_SET); + nwrite = fwrite(extra_info, 1, sizeof(camerasrc_extra_info_t), fp); + camsrc_info("Need to be written : %d / Actual written : %d", sizeof(camerasrc_extra_info_t), nwrite); + fclose(fp); + } + else + return CAMERASRC_ERR_ALLOCATION; + + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + +void _camerasrc_add_total_resolution_info( camerasrc_caps_info_t* caps_info, int fcc_use, int width, int height ) +{ + int i = 0; + + if( 1 || fcc_use == CAMERASRC_FCC_USE_REC_PREVIEW + || fcc_use == CAMERASRC_FCC_USE_CAP_PREVIEW ) + { + for( i = 0 ; i < caps_info->num_preview_resolution ; i++ ) + { + if( caps_info->preview_resolution_width[i] == width + && caps_info->preview_resolution_height[i] == height ) + { + camsrc_info("preview resolution[%dx%d] is already existed.", width, height); + return; + } + } + + caps_info->preview_resolution_width[i] = width; + caps_info->preview_resolution_height[i] = height; + caps_info->num_preview_resolution++; + + camsrc_info("preview resolution[%dx%d] is added.", width, height); + } + else if( fcc_use == CAMERASRC_FCC_USE_NORMAL_CAPTURE + || fcc_use == CAMERASRC_FCC_USE_CONT_CAPTURE ) + { + for( i = 0 ; i < caps_info->num_capture_resolution ; i++ ) + { + if( caps_info->capture_resolution_width[i] == width + && caps_info->capture_resolution_height[i] == height ) + { + camsrc_info("capture resolution[%dx%d] is already existed.", width, height); + return; + } + } + + caps_info->capture_resolution_width[i] = width; + caps_info->capture_resolution_height[i] = height; + caps_info->num_capture_resolution++; + + camsrc_info("capture resolution[%dx%d] is added.", width, height); + } + + return; +} + +void _camerasrc_add_total_fps( camerasrc_caps_info_t* caps_info, int numerator, int denominator ) +{ + int i = 0; + + for( i = 0 ; i < caps_info->num_fps ; i++ ) + { + if( caps_info->fps[i].numerator == numerator + && caps_info->fps[i].denominator == denominator ) + { + camsrc_info("fps[%d/%d] is already existed.", numerator, denominator); + return; + } + } + + caps_info->fps[caps_info->num_fps].numerator = numerator; + caps_info->fps[caps_info->num_fps].denominator = denominator; + caps_info->num_fps++; + + camsrc_info("fps[%d/%d] is added.", numerator, denominator); + + return; +} + +int _camerasrc_query_pixfmt_timeperframe(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info, int fmt_index, int resolution_index ) +{ + int tpf_cnt = 0; + struct v4l2_frmivalenum vfrmivalenum; + unsigned int fcc = 0; + camerasrc_resolution_t* resolutions = NULL; + + if( !handle || !caps_info ) + { + camsrc_info("handle[%p] or caps_info[%p] is NULL.", handle, caps_info); + return CAMERASRC_ERR_NULL_POINTER; + } + + if( 0 > fmt_index || 0 > resolution_index ) + { + camsrc_info("some index is too small. fmt_index[%d], resolution_index[%d]", + fmt_index, resolution_index); + return CAMERASRC_ERR_RANGE_UNDER; + } + + fcc = caps_info->fmt_desc[fmt_index].fcc; + resolutions = &(caps_info->fmt_desc[fmt_index].resolutions[resolution_index]); + + /* + *How many resolutions are supported in this format + */ + CLEAR(vfrmivalenum); + vfrmivalenum.index = tpf_cnt; + vfrmivalenum.pixel_format = fcc; + vfrmivalenum.width = resolutions->w; + vfrmivalenum.height = resolutions->h; + + while(0 == _camerasrc_ioctl(handle, VIDIOC_ENUM_FRAMEINTERVALS, &vfrmivalenum)) + { + resolutions->tpf[tpf_cnt].num = vfrmivalenum.discrete.numerator; + resolutions->tpf[tpf_cnt].den = vfrmivalenum.discrete.denominator; + tpf_cnt++; + + _camerasrc_add_total_fps( caps_info, vfrmivalenum.discrete.denominator, vfrmivalenum.discrete.numerator ); + } + + if(tpf_cnt == 0) + { + camsrc_info("No timeperframe supported. driver may not support to query"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + resolutions->num_avail_tpf = tpf_cnt; + + return CAMERASRC_SUCCESS; +} + +int _camerasrc_query_pixfmt_resolution(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info, int fmt_index ) +{ + int res_cnt = 0; + int err = CAMERASRC_ERR_UNKNOWN; + struct v4l2_frmsizeenum vfrmszenum; + camerasrc_fmt_desc_t* fmt_desc = NULL; + + if( !handle || !caps_info ) + { + camsrc_info("handle[%p] or caps_info[%p] is NULL.", handle, caps_info); + return CAMERASRC_ERR_NULL_POINTER; + } + + if( 0 > fmt_index ) + { + camsrc_info("fmt_index[%d] is too small.", fmt_index); + return CAMERASRC_ERR_RANGE_UNDER; + } + + fmt_desc = &caps_info->fmt_desc[fmt_index]; + + /* + *How many resolutions are supported in this format + */ + CLEAR(vfrmszenum); + vfrmszenum.index = res_cnt; + vfrmszenum.pixel_format = fmt_desc->fcc; + while(0 == _camerasrc_ioctl(handle, VIDIOC_ENUM_FRAMESIZES, &vfrmszenum)) + { + fmt_desc->resolutions[res_cnt].w = vfrmszenum.discrete.width; + fmt_desc->resolutions[res_cnt].h = vfrmszenum.discrete.height; + + _camerasrc_add_total_resolution_info( caps_info, caps_info->fmt_desc[fmt_index].fcc_use, + vfrmszenum.discrete.width, vfrmszenum.discrete.height ); + + err = _camerasrc_query_pixfmt_timeperframe(handle, caps_info, fmt_index, res_cnt); + if(err != CAMERASRC_SUCCESS) + { + camsrc_info("timeperframe querying error, err = %d", err); + return err; + } + + res_cnt++; + vfrmszenum.index = res_cnt; + } + + if(res_cnt == 0) + { + camsrc_info("No resolution supported in fcc[0x%8x]. driver may not support to query", fmt_desc->fcc); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + + fmt_desc->num_resolution = res_cnt; + + return CAMERASRC_SUCCESS; +} + +int _camerasrc_query_basic_dev_info(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info) { + struct v4l2_fmtdesc vfmtdesc; + struct v4l2_input vinput; + int err = CAMERASRC_ERR_UNKNOWN; + int fmt_cnt = 0; + char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',}; + + caps_info->num_preview_resolution = 0; + caps_info->num_capture_resolution = 0; + caps_info->num_preview_fmt = 0; + caps_info->num_capture_fmt = 0; + caps_info->num_fps = 0; + + /* + * Count how many formats are supported in this dev + */ + CLEAR(vfmtdesc); + CLEAR(vinput); + + /* + * What name of module is selected? + */ + if(CAMERASRC_SUCCESS != _camerasrc_ioctl(handle, VIDIOC_ENUMINPUT, &vinput)) { + strerror_r(handle->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN); + camsrc_error("VIDIOC_ENUMINPUT failed : %s", err_msg); + return CAMERASRC_ERR_IO_CONTROL; + } + memcpy(caps_info->dev_name, vinput.name, 32); + + vfmtdesc.index = 0; + vfmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + while(0 == _camerasrc_ioctl(handle, VIDIOC_ENUM_FMT, &vfmtdesc)) + { + camsrc_info("pixelformat \"%c%c%c%c\"(%8x) detected", + (char)(vfmtdesc.pixelformat >> 0), + (char)(vfmtdesc.pixelformat >> 8), + (char)(vfmtdesc.pixelformat >> 16), + (char)(vfmtdesc.pixelformat >> 24), + vfmtdesc.pixelformat); + caps_info->fmt_desc[fmt_cnt].fcc = vfmtdesc.pixelformat; + /* + * Along the description of the format, we seperate them into each usecase + */ + camsrc_info("description \"%s\"", vfmtdesc.description ); + if(!strcmp("rec_prev", (const char*)(vfmtdesc.description))) + { + caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_REC_PREVIEW; + caps_info->preview_fmt[caps_info->num_preview_fmt] = vfmtdesc.pixelformat; + caps_info->num_preview_fmt++; + } + else if(!strcmp("cap_prev", (const char*)(vfmtdesc.description))) + { + caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_CAP_PREVIEW; + caps_info->preview_fmt[caps_info->num_preview_fmt] = vfmtdesc.pixelformat; + caps_info->num_preview_fmt++; + } + else if(!strcmp("recording", (const char*)(vfmtdesc.description))) + { + caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_RECORDING; + } + else if(!strcmp("capture", (const char*)(vfmtdesc.description))) + { + caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_NORMAL_CAPTURE; + caps_info->capture_fmt[caps_info->num_capture_fmt] = vfmtdesc.pixelformat; + caps_info->num_capture_fmt++; + } + else if(!strcmp("cont_cap", (const char*)(vfmtdesc.description))) + { + caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_CONT_CAPTURE; + caps_info->capture_fmt[caps_info->num_capture_fmt] = vfmtdesc.pixelformat; + caps_info->num_capture_fmt++; + } + else + { + caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_NONE; + } + err = _camerasrc_query_pixfmt_resolution(handle, caps_info, fmt_cnt); + if(err != CAMERASRC_SUCCESS) + { + camsrc_info("pixel format querying error, err = %x", err); + } + fmt_cnt++; + vfmtdesc.index = fmt_cnt; + vfmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; + } + + + /* + * memory allocation as counted num + */ + camsrc_info("Total supported format = %d", fmt_cnt); + caps_info->num_fmt_desc = fmt_cnt; + + /* + * If no formats supported + */ + if(fmt_cnt == 0) + { + camsrc_info("no format supported"); + return CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + } + return CAMERASRC_SUCCESS; +} + + +int camerasrc_query_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info) { + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + err = _camerasrc_query_basic_dev_info(p, caps_info); + + err = CAMERASRC_SUCCESS; + camsrc_info("leave"); + + return err; +} + +int _camerasrc_query_ctrl_menu (camerasrc_handle_t* handle, struct v4l2_queryctrl queryctrl, camerasrc_ctrl_info_t* ctrl_info) +{ + struct v4l2_querymenu querymenu; + + camsrc_info(" Menu items:"); + + memset (&querymenu, 0, sizeof (querymenu)); + querymenu.id = queryctrl.id; + + for (querymenu.index = queryctrl.minimum; + querymenu.index <= queryctrl.maximum; + querymenu.index++) { + if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYMENU, &querymenu)) { + camsrc_info(" menu name : %s", querymenu.name); + ctrl_info->ctrl_menu[querymenu.index].menu_index = querymenu.index; + memcpy(&(ctrl_info->ctrl_menu[querymenu.index].menu_name), querymenu.name, 32); + } else { + camsrc_error("VIDIOC_QUERYMENU error"); + return CAMERASRC_ERR_IO_CONTROL; + } + } + return CAMERASRC_SUCCESS; +} + +static int _find_camsrc_ctrl_id(camerasrc_handle_t* handle, int v4l2_cid) +{ + int i = 0; + int tmp_id = 0; + for(i=0; i<CAMERASRC_CTRL_NUM; i++) + { + tmp_id = _CAMERASRC_GET_CID(i, handle->cur_dev_id); + if(tmp_id == v4l2_cid) + return i; + } + + return -1; +} + +int _camerasrc_query_misc_dev_info(camerasrc_handle_t* handle, camerasrc_ctrl_list_info_t* ctrl_list_info) +{ + struct v4l2_queryctrl queryctrl; + + int i = 0; + int ctrl_cnt = 0; + + + camsrc_info("QUERY_BASE "); + for (i = CAMERASRC_CTRL_BRIGHTNESS; i < CAMERASRC_CTRL_NUM; i++) { + queryctrl.id = _CAMERASRC_GET_CID(i, handle->cur_dev_id); + if(queryctrl.id == -1) + { + continue; + } + if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYCTRL, &queryctrl)) { + if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) + { + camsrc_info("ID [%8x] disabled", queryctrl.id); + /*continue;*/ + } + camsrc_info("Control %s", queryctrl.name); + ctrl_list_info->ctrl_info[ctrl_cnt].v4l2_ctrl_id = queryctrl.id; + ctrl_list_info->ctrl_info[ctrl_cnt].camsrc_ctrl_id = i; + if(ctrl_list_info->ctrl_info[ctrl_cnt].camsrc_ctrl_id == -1) + { + camsrc_warning("This control is not included in camsrc ctrl ID error"); + } + switch(queryctrl.type) + { + case V4L2_CTRL_TYPE_INTEGER: + ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_RANGE; + break; + case V4L2_CTRL_TYPE_BOOLEAN: + ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_BOOL; + break; + case V4L2_CTRL_TYPE_MENU: + ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_ARRAY; + _camerasrc_query_ctrl_menu (handle, queryctrl, &(ctrl_list_info->ctrl_info[ctrl_cnt])); + break; + default: + ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_UNKNOWN; + break; + } + memcpy(ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_name,queryctrl.name, 32); + ctrl_list_info->ctrl_info[ctrl_cnt].min = queryctrl.minimum; + ctrl_list_info->ctrl_info[ctrl_cnt].max = queryctrl.maximum; + ctrl_list_info->ctrl_info[ctrl_cnt].step = queryctrl.step; + ctrl_list_info->ctrl_info[ctrl_cnt].default_val = queryctrl.default_value; + camsrc_info("Control %s", queryctrl.name); + } else { + if (errno == EINVAL) + continue; + camsrc_error("VIDIOC_QUERYCTRL error"); + return CAMERASRC_ERR_IO_CONTROL; + } + ctrl_cnt++; + } + ctrl_list_info->num_ctrl_list_info = ctrl_cnt; + return CAMERASRC_SUCCESS; +} + + +int camerasrc_query_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + err = _camerasrc_query_misc_dev_info(p, ctrl_list_info); + + err = CAMERASRC_SUCCESS; + + camsrc_info("leave"); + + return err; +} + + +int camerasrc_query_misc_dev_ctrl_info(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t* ctrl_info) +{ + struct v4l2_queryctrl queryctrl; + + CLEAR(queryctrl); + + queryctrl.id = _CAMERASRC_GET_CID(ctrl_id, CAMERASRC_HANDLE(handle)->cur_dev_id); + if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYCTRL, &queryctrl)) { + if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) + { + camsrc_info("ID [%8x] disabled", queryctrl.id); + } + camsrc_info("Control %s", queryctrl.name); + ctrl_info->v4l2_ctrl_id = queryctrl.id; + ctrl_info->camsrc_ctrl_id = ctrl_id; + if(ctrl_info->camsrc_ctrl_id == -1) + { + camsrc_warning("This control is not included in camsrc ctrl ID error"); + } + switch(queryctrl.type) + { + case V4L2_CTRL_TYPE_INTEGER: + ctrl_info->ctrl_type = CTRL_TYPE_RANGE; + break; + case V4L2_CTRL_TYPE_BOOLEAN: + ctrl_info->ctrl_type = CTRL_TYPE_BOOL; + break; + case V4L2_CTRL_TYPE_MENU: + ctrl_info->ctrl_type = CTRL_TYPE_ARRAY; + _camerasrc_query_ctrl_menu (handle, queryctrl, ctrl_info); + break; + default: + ctrl_info->ctrl_type = CTRL_TYPE_UNKNOWN; + break; + } + memcpy(ctrl_info->ctrl_name,queryctrl.name, MAX_SZ_CTRL_NAME_STRING); + ctrl_info->min = queryctrl.minimum; + ctrl_info->max = queryctrl.maximum; + ctrl_info->step = queryctrl.step; + ctrl_info->default_val = queryctrl.default_value; + camsrc_info("Control %s", queryctrl.name); + } else { + camsrc_error("VIDIOC_QUERYCTRL error"); + return CAMERASRC_ERR_IO_CONTROL; + } + return CAMERASRC_SUCCESS; +} + + +int camerasrc_dump_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info) +{ + camsrc_info("enter"); + int i=0; + int j=0; + + camsrc_info("============================================================"); + for(i = 0; i < ctrl_list_info->num_ctrl_list_info; i++) + { + camsrc_info("[camsrc ID : %d] [v4l2 ID : 0x%08x] Control name = %s", ctrl_list_info->ctrl_info[i].camsrc_ctrl_id, ctrl_list_info->ctrl_info[i].v4l2_ctrl_id, ctrl_list_info->ctrl_info[i].ctrl_name); + camsrc_info(" Control type = %d", ctrl_list_info->ctrl_info[i].ctrl_type); + camsrc_info(" Min = %d / Max = %d / Step = %d / default = %d", ctrl_list_info->ctrl_info[i].min, ctrl_list_info->ctrl_info[i].max, ctrl_list_info->ctrl_info[i].step, ctrl_list_info->ctrl_info[i].default_val); + if(ctrl_list_info->ctrl_info[i].ctrl_type == CTRL_TYPE_ARRAY) + { + camsrc_info("\t\t - Menu list"); + for(j = ctrl_list_info->ctrl_info[i].min; j <= ctrl_list_info->ctrl_info[i].max; j++) + { + camsrc_info("\t\t * %s", ctrl_list_info->ctrl_info[i].ctrl_menu[j].menu_name); + } + } + } + camsrc_info("============================================================"); + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + + +int camerasrc_dump_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info) { + camsrc_info("enter"); + int i,j,k; + + camsrc_info("==============================================================="); + for(i = 0; i< caps_info->num_fmt_desc; i++) + { + camsrc_info("Supported fourcc = \"%c%c%c%c\" (0x%08x) num of resolution = %d", + (char)(caps_info->fmt_desc[i].fcc >> 0), + (char)(caps_info->fmt_desc[i].fcc >> 8), + (char)(caps_info->fmt_desc[i].fcc >> 16), + (char)(caps_info->fmt_desc[i].fcc >> 24), + caps_info->fmt_desc[i].fcc, + caps_info->fmt_desc[i].num_resolution); + for(j=0; j<caps_info->fmt_desc[i].num_resolution; j++) + { + camsrc_info("\tresolution = %d x %d, num of tpf = %d", + caps_info->fmt_desc[i].resolutions[j].w, caps_info->fmt_desc[i].resolutions[j].h, + caps_info->fmt_desc[i].resolutions[j].num_avail_tpf); + for(k=0; k<caps_info->fmt_desc[i].resolutions[j].num_avail_tpf; k++) + { + camsrc_info("\t\ttimeperframe = %d / %d", caps_info->fmt_desc[i].resolutions[j].tpf[k].num, caps_info->fmt_desc[i].resolutions[j].tpf[k].den); + } + } + } + camsrc_info("==============================================================="); + camsrc_info("total supported preview resolution"); + for( i = 0 ; i < caps_info->num_preview_resolution ; i++ ) + { + camsrc_info("%5dx%5d", caps_info->preview_resolution_width[i], caps_info->preview_resolution_height[i]); + + } + camsrc_info("==============================================================="); + camsrc_info("total supported capture resolution"); + for( i = 0 ; i < caps_info->num_capture_resolution ; i++ ) + { + camsrc_info("%5dx%5d", caps_info->capture_resolution_width[i], caps_info->capture_resolution_height[i]); + + } + camsrc_info("==============================================================="); + camsrc_info("total supported preview fourcc"); + for( i = 0 ; i < caps_info->num_preview_fmt ; i++ ) + { + camsrc_info("\"%c%c%c%c\" (0x%08x)", + (char)(caps_info->preview_fmt[i]), + (char)(caps_info->preview_fmt[i]>>8), + (char)(caps_info->preview_fmt[i]>>16), + (char)(caps_info->preview_fmt[i]>>24), + caps_info->preview_fmt[i]); + } + camsrc_info("==============================================================="); + camsrc_info("total supported capture fourcc"); + for( i = 0 ; i < caps_info->num_capture_fmt ; i++ ) + { + camsrc_info("\"%c%c%c%c\" (0x%08x)", + (char)(caps_info->capture_fmt[i]), + (char)(caps_info->capture_fmt[i]>>8), + (char)(caps_info->capture_fmt[i]>>16), + (char)(caps_info->capture_fmt[i]>>24), + caps_info->capture_fmt[i]); + } + camsrc_info("==============================================================="); + camsrc_info("total supported fps"); + for( i = 0 ; i < caps_info->num_fps ; i++ ) + { + camsrc_info("%3d/%3d", caps_info->fps[i].numerator, caps_info->fps[i].denominator); + } + camsrc_info("==============================================================="); + camsrc_info("leave"); + return CAMERASRC_SUCCESS; +} + + +int camerasrc_dump_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info) +{ + camsrc_info("enter"); + camsrc_info("==============================================================="); + camsrc_info(" Strobe can support below"); + if (extra_info->strobe_caps == CAMERASRC_STROBE_CAP_NONE) { + camsrc_info(" - Strobe Support Nothing"); + } else { + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_OFF) + camsrc_info(" - Always off mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_ON) + camsrc_info(" - Always on mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_AUTO) + camsrc_info(" - Auto mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_REDEYE) + camsrc_info(" - Redeye reduction mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_SLOWSYNC) + camsrc_info(" - Slow sync mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_FRONT_CURTAIN) + camsrc_info(" - Front curtain mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_REAR_CURTAIN) + camsrc_info(" - Rear curtain mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_PERMANENT) + camsrc_info(" - Permanent mode"); + if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_EXTERNAL) + camsrc_info(" - External strobe mode"); + } + + if (extra_info->detection_caps) { + camsrc_info(" Facedetection can be supported"); + } else { + camsrc_info(" Facedetection can't be supported"); + } + + camsrc_info("==============================================================="); + camsrc_info("leave"); + + return CAMERASRC_SUCCESS; +} + +static int _camerasrc_query_extra_dev_info(camerasrc_handle_t* handle, camerasrc_extra_info_t* extra_info) +{ + struct v4l2_capability capability; + + if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYCAP, &capability)) { + camsrc_info("VIDIOC_QUERYCAP result [0x%08x]", capability.capabilities); + if((capability.capabilities & V4L2_CAP_STROBE) != 0) + { + /* Strobe supported */ + struct v4l2_strobe strobecaps; + if (0 == _camerasrc_ioctl (handle, VIDIOC_G_STROBE, &strobecaps)) + { + extra_info->strobe_caps = strobecaps.capabilities; + } + else + { + camsrc_error("VIDIOC_G_STROBE error"); + return CAMERASRC_ERR_IO_CONTROL; + } + } + else + { + /* Strobe NOT supported */ + camsrc_error("STROBE not supported"); + extra_info->strobe_caps = 0; + } + + if((capability.capabilities & V4L2_CAP_OBJ_RECOGNITION) != 0) + { + /* Recognition supported */ + extra_info->detection_caps = 1; + } + else + { + camsrc_error("FACEDETECTION not supported"); + extra_info->detection_caps = 0; + /* Recognition NOT supported */ + } + + return CAMERASRC_SUCCESS; + } else { + camsrc_error("VIDIOC_QUERYCAP error"); + + return CAMERASRC_ERR_IO_CONTROL; + } +} + + +int camerasrc_query_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info) +{ + camerasrc_handle_t* p = NULL; + int err = CAMERASRC_ERR_UNKNOWN; + + camsrc_info("enter"); + + if(handle == NULL) { + camsrc_error("handle is null"); + return CAMERASRC_ERR_NULL_POINTER; + } + + p = CAMERASRC_HANDLE(handle); + + err = _camerasrc_query_extra_dev_info(p, extra_info); + + err = CAMERASRC_SUCCESS; + camsrc_info("leave"); + + return err; +} + +/* END For Query functionalities */ diff --git a/camerasrc/src/gstcamerasrc.c b/camerasrc/src/gstcamerasrc.c new file mode 100644 index 0000000..9871741 --- /dev/null +++ b/camerasrc/src/gstcamerasrc.c @@ -0,0 +1,3894 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <gst/gst.h> +#include <gst/gstutils.h> +#include <glib-object.h> +#include <unistd.h> +#include <sys/time.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <sched.h> /* sched_yield() */ + +#include "gstcamerasrc.h" +#include "gstcamerasrccontrol.h" +#include "gstcamerasrccolorbalance.h" + + +/****************************************************************************** + * Definitions + *******************************************************************************/ +GST_DEBUG_CATEGORY (camerasrc_debug); +#define GST_CAT_DEFAULT camerasrc_debug + +#define USE_FRAME_SAFETY_MARGIN + +#if defined (USE_FRAME_SAFETY_MARGIN) +#define FRAME_SAFETY_MARGIN 4096 +#else +#define FRAME_SAFETY_MARGIN 0 +#endif + +#ifndef YUV422_SIZE +#define YUV422_SIZE(width,height) ( ((width)*(height)) << 1 ) +#endif + +#ifndef YUV420_SIZE +#define YUV420_SIZE(width,height) ( ((width)*(height)*3) >> 1 ) +#endif + +#define SCMN_CS_YUV420 1 /* Y:U:V 4:2:0 */ +#define SCMN_CS_I420 SCMN_CS_YUV420 /* Y:U:V */ +#define SCMN_CS_NV12 6 +#define SCMN_CS_NV12_T64X32 11 /* 64x32 Tiled NV12 type */ +#define SCMN_CS_UYVY 100 +#define SCMN_CS_YUYV 101 +#define SCMN_CS_YUY2 SCMN_CS_YUYV + +/* max channel count *********************************************************/ +#define SCMN_IMGB_MAX_PLANE (4) + +/* image buffer definition *************************************************** + + +------------------------------------------+ --- + | | ^ + | a[], p[] | | + | +---------------------------+ --- | | + | | | ^ | | + | |<---------- w[] ---------->| | | | + | | | | | | + | | | | + | | | h[] | e[] + | | | | + | | | | | | + | | | | | | + | | | v | | + | +---------------------------+ --- | | + | | v + +------------------------------------------+ --- + + |<----------------- s[] ------------------>| +*/ + +typedef struct +{ + /* width of each image plane */ + int w[SCMN_IMGB_MAX_PLANE]; + /* height of each image plane */ + int h[SCMN_IMGB_MAX_PLANE]; + /* stride of each image plane */ + int s[SCMN_IMGB_MAX_PLANE]; + /* elevation of each image plane */ + int e[SCMN_IMGB_MAX_PLANE]; + /* user space address of each image plane */ + void *a[SCMN_IMGB_MAX_PLANE]; + /* physical address of each image plane, if needs */ + void *p[SCMN_IMGB_MAX_PLANE]; + /* color space type of image */ + int cs; + /* left postion, if needs */ + int x; + /* top position, if needs */ + int y; + /* to align memory */ + int __dummy2; + /* arbitrary data */ + int data[16]; +} SCMN_IMGB; + +#if !defined (PAGE_SHIFT) + #define PAGE_SHIFT sysconf(_SC_PAGESIZE) +#endif +#if !defined (PAGE_SIZE) + #define PAGE_SIZE (1UL << PAGE_SHIFT) +#endif +#if !defined (PAGE_MASK) + #define PAGE_MASK (~(PAGE_SIZE-1)) +#endif +#if !defined (PAGE_ALIGN) + #define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK) +#endif + +#define ALIGN_SIZE_I420 (1024<<2) +#define ALIGN_SIZE_NV12 (1024<<6) +#define CAMERASRC_ALIGN(addr,size) (((addr)+((size)-1))&(~((size)-1))) + +#if !defined (CLEAR) + #define CLEAR(x) memset(&(x), 0, sizeof(x)) +#endif + + +/* Enables */ +#define _ENABLE_CAMERASRC_DEBUG 0 + +/* Local definitions */ +#define _DEFAULT_WIDTH 320 +#define _DEFAULT_HEIGHT 240 +#define _DEFAULT_FPS 30 +#define _DEFAULT_HIGH_SPEED_FPS 0 +#define _DEFAULT_FPS_AUTO FALSE +#define _DEFAULT_PIX_FORMAT CAMERASRC_PIX_UYVY +#define _DEFAULT_FOURCC GST_MAKE_FOURCC ('J', 'P', 'E', 'G') +#define _DEFAULT_COLORSPACE CAMERASRC_COL_RAW +#define _DEFAULT_CAMERA_ID CAMERASRC_DEV_ID_PRIMARY + +/* mmap/pad-alloc related definition */ +#define _DEFAULT_NUM_LIVE_BUFFER 0 +#define _DEFAULT_BUFFER_COUNT 0 +#define _ALLOWED_GAP_BTWN_BUF 5 /* Allowed gap between circulation count of each buffer and that of average buffer */ +#define _DEFAULT_BUFFER_RUNNING FALSE +#define _DEFAULT_DEQUE_WAITINGTIME 200 /* msec */ +#define _MINIMUM_REMAINING_V4L2_QBUF 1 /* minimum number of buffer that should remain in the v4l2 driver */ + +#define _FD_DEFAULT (-1) +#define _FD_MIN (-1) +#define _FD_MAX (1<<15) /* 2^15 == 32768 */ + +#define _DEFAULT_CAP_QUALITY GST_CAMERASRC_QUALITY_HIGH +#define _DEFAULT_CAP_JPG_QUALITY 95 +#define _DEFAULT_CAP_WIDTH 1600 +#define _DEFAULT_CAP_HEIGHT 1200 +#define _DEFAULT_CAP_COUNT 1 +#define _DEFAULT_CAP_INTERVAL 0 +#define _DEFAULT_CAP_PROVIDE_EXIF FALSE +#define _DEFAULT_ENABLE_ZSL_MODE FALSE +#define _DEFAULT_DO_FACE_DETECT FALSE +#define _DEFAULT_DO_AF FALSE +#define _DEFAULT_SIGNAL_AF FALSE +#define _DEFAULT_SIGNAL_STILL_CAPTURE FALSE +#define _DEFAULT_PREVIEW_WIDTH _DEFAULT_WIDTH +#define _DEFAULT_PREVIEW_HEIGHT _DEFAULT_HEIGHT +#define _DEFAULT_KEEPING_BUFFER 0 +#define _DEFAULT_USE_PAD_ALLOC FALSE +#define _DEFAULT_NUM_ALLOC_BUF 6 +#define _DEFAULT_SCRNL_FOURCC GST_MAKE_FOURCC('N','V','1','2') +#define _MAX_NUM_ALLOC_BUF 100 +#define _MAX_TRIAL_WAIT_FRAME 25 +#define _PAD_ALLOC_RETRY_PERIOD 25 +#define _MAX_PAD_ALLOC_RETRY_COUNT 300 +#define _CONTINUOUS_SHOT_MARGIN 50 /* msec */ +#define _PREVIEW_BUFFER_WAIT_TIMEOUT 2000000 /* usec */ + +/*FIXME*/ +#define _THUMBNAIL_WIDTH 320 +#define _THUMBNAIL_HEIGHT 240 + +#define GST_TYPE_CAMERASRC_BUFFER (gst_camerasrc_buffer_get_type()) +#define GST_IS_CAMERASRC_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GST_TYPE_CAMERASRC_BUFFER)) +#define GST_CAMERASRC_BUFFER(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GST_TYPE_CAMERASRC_BUFFER, GstCameraBuffer)) +#define GST_TYPE_CAMERASRC_QUALITY (gst_camerasrc_quality_get_type()) + + +/* Enumerations */ +enum { + /*signal*/ + SIGNAL_STILL_CAPTURE, + SIGNAL_NEGO_COMPLETE, + /*SIGNAL_REGISTER_TROUBLE,*/ + LAST_SIGNAL +}; + +enum { + ARG_0, + /* camera */ + ARG_CAMERA_HIGH_SPEED_FPS, + ARG_CAMERA_AUTO_FPS, + ARG_CAMERA_ID, + ARG_CAMERA_EXT_VIDEO_FD, + + /* capture */ + ARG_CAMERA_CAPTURE_FOURCC, + ARG_CAMERA_CAPTURE_QUALITY, + ARG_CAMERA_CAPTURE_WIDTH, + ARG_CAMERA_CAPTURE_HEIGHT, + ARG_CAMERA_CAPTURE_INTERVAL, + ARG_CAMERA_CAPTURE_COUNT, + ARG_CAMERA_CAPTURE_JPG_QUALITY, + ARG_CAMERA_CAPTURE_PROVIDE_EXIF, + + /* signal */ + ARG_SIGNAL_STILLCAPTURE, + ARG_REQ_NEGOTIATION, + + ARG_USE_PAD_ALLOC, + ARG_NUM_ALLOC_BUF, + ARG_OPERATION_STATUS, + ARG_HOLD_AF_AFTER_CAPTURE, + ARG_FAKE_ESD, + ARG_SENSOR_MODE, + ARG_VFLIP, + ARG_HFLIP, + ARG_NUM, +}; + +enum { + VIDEO_IN_MODE_UNKNOWN, + VIDEO_IN_MODE_PREVIEW, + VIDEO_IN_MODE_VIDEO, + VIDEO_IN_MODE_CAPTURE, +}; + +/* Structures */ +typedef struct { + gint index; + gint buffer_data_index; + GstCameraSrc *camerasrc; +} GST_CAMERASRC_BUFFER_DATA; + +static void gst_camerasrc_uri_handler_init (gpointer g_iface, gpointer iface_data); + +/* Local variables */ +static GstBufferClass *camera_buffer_parent_class = NULL; + +static guint gst_camerasrc_signals[LAST_SIGNAL] = { 0 }; + +/* For pad_alloc architecture */ +static camerasrc_usr_buf_t g_present_buf; + +#if _ENABLE_CAMERASRC_DEBUG +static unsigned int g_preview_frame_cnt; +#endif + +/* Element template variables */ +static GstStaticPadTemplate src_factory = + GST_STATIC_PAD_TEMPLATE("src", + GST_PAD_SRC, + GST_PAD_ALWAYS, + GST_STATIC_CAPS("video/x-raw-yuv," + "format = (fourcc) { UYVY }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { YU12 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { I420 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { NV12 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { SN12 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { ST12 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { YUY2 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { YUYV }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { SUYV }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { SUY2 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { SYVY }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-yuv," + "format = (fourcc) { S420 }, " + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]; " + "video/x-raw-rgb," + "width = (int) [ 1, 4096 ], " + "height = (int) [ 1, 4096 ]")); + +static GstElementDetails camerasrc_details = { + "Camera Source GStreamer Plug-in", + "Src/Video", + "camera src for videosrc based GStreamer Plug-in", + "" +}; + + + +/* Local static functions */ +static void gst_camerasrc_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); +static void gst_camerasrc_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec); + +static gboolean gst_camerasrc_src_start(GstBaseSrc *src); +static gboolean gst_camerasrc_src_stop(GstBaseSrc *src); +static gboolean gst_camerasrc_start(GstCameraSrc *camerasrc); + +static GstFlowReturn gst_camerasrc_src_create(GstPushSrc *src, GstBuffer **buffer); +static GstFlowReturn gst_camerasrc_read_capture(GstCameraSrc *camerasrc, GstBuffer **buffer, int command); +static GstFlowReturn gst_camerasrc_read_preview_mmap(GstCameraSrc *camerasrc, GstBuffer **buffer); +static GstFlowReturn gst_camerasrc_read_preview_pad_alloc(GstCameraSrc *camerasrc, GstBuffer **buffer); +static unsigned char *gst_camerasrc_make_metadata_for_nonlinear_buffer(GstCameraSrc *avsysvideosrc, guint32 index); + +static GstStateChangeReturn gst_camerasrc_change_state(GstElement *element, GstStateChange transition); +static GstCaps *gst_camerasrc_get_caps(GstBaseSrc *src); +static gboolean gst_camerasrc_set_caps(GstBaseSrc *src, GstCaps *caps); +static gboolean gst_camerasrc_get_caps_info(GstCameraSrc *camerasrc, GstCaps *caps, guint *size); +static gboolean gst_camerasrc_fill_ctrl_list(GstCameraSrc *camerasrc); +static gboolean gst_camerasrc_empty_ctrl_list(GstCameraSrc *camerasrc); +static void gst_camerasrc_finalize(GObject *object); + +static gboolean gst_camerasrc_device_is_open(GstCameraSrc *camerasrc); +static gboolean gst_camerasrc_get_timeinfo(GstCameraSrc *camerasrc, GstBuffer *buffer); +static int get_proper_index(GstCameraSrc *camerasrc, GstBuffer *pad_alloc_buffer); + +static gboolean gst_camerasrc_capture_start(GstCameraSrc *camerasrc); +static gboolean gst_camerasrc_capture_stop(GstCameraSrc *camerasrc); + +static GstCameraBuffer *gst_camerasrc_buffer_new(GstCameraSrc *camerasrc); +static GType gst_camerasrc_buffer_get_type(void); +static void gst_camerasrc_buffer_class_init(gpointer g_class, gpointer class_data); +static void gst_camerasrc_buffer_finalize(GstCameraBuffer *buffer); +static void gst_camerasrc_buffer_free(gpointer data); +static void gst_camerasrc_buffer_trace(GstCameraSrc *camerasrc); +static void gst_camerasrc_error_handler(GstCameraSrc *camerasrc, int ret); + +/* Util functions */ +static void GenerateYUV420BlackFrame(unsigned char *buf, int buf_size, int width, int height); +static void GenerateYUV422BlackFrame(unsigned char *buf, int buf_size, int width, int height); +static gboolean GenerateST12BlackFrame(GstCameraSrc *camerasrc, unsigned char *buf, int buf_size, int width, int height); +static unsigned long gst_get_current_time(void); +static gboolean _gst_camerasrc_get_frame_size(int fourcc, int width, int height, unsigned int *outsize); +static gboolean _gst_camerasrc_get_raw_pixel_info(int fourcc, int *pix_format, int *colorspace); +static gboolean _gst_camerasrc_get_normal_buffer(GstCameraSrc *camerasrc, int fourcc, + unsigned char *base_buf, int width, int height, + unsigned char **new_buf, unsigned int *length); +#if _ENABLE_CAMERASRC_DEBUG +static int __util_write_file(char *filename, void *data, int size); +#endif /* _ENABLE_CAMERASRC_DEBUG */ +static gboolean gst_camerasrc_negotiate (GstBaseSrc * basesrc); + +GST_IMPLEMENT_CAMERASRC_COLOR_BALANCE_METHODS(GstCameraSrc, gst_camera_src); +GST_IMPLEMENT_CAMERASRC_CONTROL_METHODS(GstCameraSrc, gst_camera_src); + + +/****************************************************************************** + * Implementations + *******************************************************************************/ +static void gst_camerasrc_error_handler(GstCameraSrc *camerasrc, int ret) +{ + switch (ret) { + case CAMERASRC_SUCCESS: + break; + case CAMERASRC_ERR_IO_CONTROL: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, FAILED, ("IO control error"), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_DEVICE_OPEN: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, OPEN_READ_WRITE, ("camera open failed"), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_DEVICE_BUSY: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, BUSY, ("camera device busy"), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_DEVICE_NOT_FOUND: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, NOT_FOUND, ("camera device not found"), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_DEVICE_UNAVAILABLE: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, OPEN_READ, ("camera device unavailable"), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT: + gst_camerasrc_buffer_trace(camerasrc); + GST_ELEMENT_ERROR(camerasrc, RESOURCE, TOO_LAZY, (("Timeout[live_buffers=%d]"), camerasrc->num_live_buffers), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_DEVICE_NOT_SUPPORT: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, SETTINGS, ("Not supported"), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_ALLOCATION: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, SETTINGS, ("memory allocation failed"), GST_ERROR_SYSTEM); + break; + case CAMERASRC_ERR_SECURITY_SERVICE: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, FAILED, ("Security service failed"), GST_ERROR_SYSTEM); + break; + default: + GST_ELEMENT_ERROR(camerasrc, RESOURCE, SEEK, (("General video device error[ret=%x]"), ret), GST_ERROR_SYSTEM); + break; + } + + return; +} + +static gboolean gst_camerasrc_iface_supported(GstImplementsInterface *iface, GType iface_type) +{ + g_assert(iface_type == GST_TYPE_CAMERA_CONTROL || + iface_type == GST_TYPE_COLOR_BALANCE); + + return TRUE; +} + + +static void gst_camerasrc_interface_init(GstImplementsInterfaceClass *klass) +{ + /* + * default virtual functions + */ + klass->supported = gst_camerasrc_iface_supported; +} + + +void gst_camerasrc_init_interfaces(GType type) +{ + static const GInterfaceInfo urihandler_info = { + gst_camerasrc_uri_handler_init, + NULL, + NULL + }; + + static const GInterfaceInfo cameraiface_info = { + (GInterfaceInitFunc)gst_camerasrc_interface_init, + NULL, + NULL, + }; + + static const GInterfaceInfo camerasrc_control_info = { + (GInterfaceInitFunc)gst_camera_src_control_interface_init, + NULL, + NULL, + }; + + static const GInterfaceInfo camerasrc_color_balance_info = { + (GInterfaceInitFunc)gst_camera_src_color_balance_interface_init, + NULL, + NULL, + }; + + g_type_add_interface_static (type, GST_TYPE_URI_HANDLER, &urihandler_info); + g_type_add_interface_static(type, GST_TYPE_IMPLEMENTS_INTERFACE, &cameraiface_info); + g_type_add_interface_static(type, GST_TYPE_CAMERA_CONTROL, &camerasrc_control_info); + g_type_add_interface_static(type, GST_TYPE_COLOR_BALANCE, &camerasrc_color_balance_info); +} + + +static GType gst_camerasrc_quality_get_type(void) +{ + static GType camerasrc_quality_type = 0; + static const GEnumValue quality_types[] = { + {GST_CAMERASRC_QUALITY_LOW, "Low quality", "low"}, + {GST_CAMERASRC_QUALITY_HIGH, "High quality", "high"}, + {0, NULL, NULL} + }; + + if (!camerasrc_quality_type) { + camerasrc_quality_type = g_enum_register_static ("GstCameraSrcQuality", quality_types); + } + return camerasrc_quality_type; +} + +/* VOID:OBJECT,OBJECT (generated by 'glib-genmarshal') */ +#define g_marshal_value_peek_object(v) (v)->data[0].v_pointer +void gst_camerasrc_VOID__OBJECT_OBJECT(GClosure *closure, + GValue *return_value, + guint n_param_values, + const GValue *param_values, + gpointer invocation_hint, + gpointer marshal_data) +{ + typedef void (*GMarshalFunc_VOID__OBJECT_OBJECT)(gpointer data1, + gpointer arg_1, + gpointer arg_2, + gpointer arg_3, + gpointer data2); + register GMarshalFunc_VOID__OBJECT_OBJECT callback; + register GCClosure *cc = (GCClosure*) closure; + register gpointer data1, data2; + + g_return_if_fail (n_param_values == 4); + + if (G_CCLOSURE_SWAP_DATA(closure)) { + data1 = closure->data; + data2 = g_value_peek_pointer(param_values + 0); + } else { + data1 = g_value_peek_pointer(param_values + 0); + data2 = closure->data; + } + + callback = (GMarshalFunc_VOID__OBJECT_OBJECT)(marshal_data ? marshal_data : cc->callback); + + callback(data1, + g_marshal_value_peek_object(param_values + 1), + g_marshal_value_peek_object(param_values + 2), + g_marshal_value_peek_object(param_values + 3), + data2); +} + + +/* use following BOILERPLATE MACRO as _get_type entry */ +GST_BOILERPLATE_FULL(GstCameraSrc, gst_camerasrc, GstPushSrc, GST_TYPE_PUSH_SRC, gst_camerasrc_init_interfaces); + + +static int gst_camerasrc_af_cb(camsrc_handle_t handle, int state, void *usr_param) +{ + GstCameraSrc *camerasrc = (GstCameraSrc *)usr_param; + GstMessage *m = NULL; + GstStructure *s = NULL; + + MMTA_ACUM_ITEM_END("AutoFocus operating time", FALSE); + + GST_INFO_OBJECT(camerasrc, "autofocus callback: state [%d]", state); + + s = gst_structure_new("camerasrc-AF", + "focus-state", G_TYPE_INT, state, + NULL); + m = gst_message_new_element(GST_OBJECT(camerasrc), s); + gst_element_post_message(GST_ELEMENT(camerasrc), m); + + return CAMERASRC_SUCCESS; +} + + +static gboolean gst_camerasrc_create(GstCameraSrc *camerasrc) +{ + int ret = 0; + + /*create handle*/ + __ta__(" camerasrc_create", + ret = camerasrc_create(&(camerasrc->v4l2_handle)); + ); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_create() failed. errcode = 0x%08X", ret); + goto _ERROR; + } + + GST_INFO_OBJECT (camerasrc, "camerasrc_create() done"); + + if (camerasrc->external_videofd != _FD_DEFAULT) { + __ta__(" camerasrc_set_videofd", + camerasrc_set_videofd(camerasrc->v4l2_handle,camerasrc->external_videofd); + ); + } + + /*CAMERASRC CAM: realize*/ + __ta__(" camerasrc_realize", + ret = camerasrc_realize(camerasrc->v4l2_handle); + ); + if (ret != CAMERASRC_SUCCESS) { + goto _ERROR; + } + + GST_INFO_OBJECT (camerasrc, "camerasrc_realize() done"); + + /*CAMERASRC CAM: start*/ + __ta__(" camerasrc_start", + ret = camerasrc_start(camerasrc->v4l2_handle); + ); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_start() failed. errcode = 0x%x", ret); + goto _ERROR; + } + + /*CAMERASRC CAM: set camera device id*/ + /**@note if realized, iput device can't change!*/ + __ta__(" camerasrc_set_input", + ret = camerasrc_set_input(camerasrc->v4l2_handle, camerasrc->camera_id); + ); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_set_input() failed. errcode = 0x%x", ret); + goto _ERROR; + } + + if (!gst_camerasrc_fill_ctrl_list(camerasrc)) { + GST_WARNING_OBJECT(camerasrc, "Can't fill v4l2 control list."); + } + + return TRUE; + + _ERROR: + gst_camerasrc_error_handler(camerasrc, ret); + + return FALSE; +} + + +static gboolean gst_camerasrc_destroy(GstCameraSrc *camerasrc) +{ + GST_INFO_OBJECT (camerasrc, "ENTERED"); + + if (camerasrc->v4l2_handle) { + /*Empty control list */ + gst_camerasrc_empty_ctrl_list(camerasrc); + + /*CAMERASRC CAM: stop stream*/ + /*CAMERASRC CAM: unrealize*/ + GST_INFO_OBJECT(camerasrc, "camerasrc_unrealize() calling..."); + camerasrc_unrealize(camerasrc->v4l2_handle); + + /*CAMERASRC CAM: destroy*/ + GST_INFO_OBJECT(camerasrc, "camerasrc_destroy() calling..."); + camerasrc_destroy(camerasrc->v4l2_handle); + camerasrc->v4l2_handle = NULL; + GST_INFO_OBJECT(camerasrc, "AV cam destroyed."); + camerasrc->mode = VIDEO_IN_MODE_UNKNOWN; + } + + GST_INFO_OBJECT(camerasrc, "LEAVED"); + + return TRUE; +} + + +static gboolean gst_camerasrc_fill_ctrl_list(GstCameraSrc *camerasrc) +{ + int n = 0; + camerasrc_ctrl_info_t ctrl_info; + + g_return_val_if_fail(camerasrc, FALSE); + g_return_val_if_fail(camerasrc->v4l2_handle, FALSE); + + GST_DEBUG_OBJECT(camerasrc, "ENTERED"); + + for (n = CAMERASRC_CTRL_BRIGHTNESS ; n < CAMERASRC_CTRL_NUM ; n++) { + GstCameraSrcColorBalanceChannel *camerasrc_color_channel = NULL; + GstColorBalanceChannel *color_channel = NULL; + + GstCamerasrcControlChannel *camerasrc_control_channel = NULL; + GstCameraControlChannel *control_channel = NULL; + + gint channel_type; + + memset(&ctrl_info, 0x0, sizeof(camerasrc_ctrl_info_t)); + + if (camerasrc_query_control(camerasrc->v4l2_handle, n, &ctrl_info) != CAMERASRC_SUCCESS) { + /* TODO: */ + } + + switch (n) { + case CAMERASRC_CTRL_BRIGHTNESS: + case CAMERASRC_CTRL_CONTRAST: + case CAMERASRC_CTRL_WHITE_BALANCE: + case CAMERASRC_CTRL_COLOR_TONE: + case CAMERASRC_CTRL_PARTCOLOR_SRC: + case CAMERASRC_CTRL_PARTCOLOR_DST: + case CAMERASRC_CTRL_PARTCOLOR_MODE: + case CAMERASRC_CTRL_SATURATION: + case CAMERASRC_CTRL_SHARPNESS: + channel_type = INTERFACE_COLOR_BALANCE; + break; + case CAMERASRC_CTRL_DIGITAL_ZOOM: + case CAMERASRC_CTRL_OPTICAL_ZOOM: + case CAMERASRC_CTRL_PROGRAM_MODE: + case CAMERASRC_CTRL_FLIP: + case CAMERASRC_CTRL_ANTI_HANDSHAKE: + case CAMERASRC_CTRL_WIDE_DYNAMIC_RANGE: + channel_type = INTERFACE_CAMERA_CONTROL; + break; + default: + channel_type = INTERFACE_NONE; + continue; + } + + if (channel_type == INTERFACE_COLOR_BALANCE) { + camerasrc_color_channel = g_object_new(GST_TYPE_CAMERASRC_COLOR_BALANCE_CHANNEL, NULL); + color_channel = GST_COLOR_BALANCE_CHANNEL(camerasrc_color_channel); + + color_channel->label = g_strdup((const gchar *)camerasrc_ctrl_label[n]); + camerasrc_color_channel->id = n; + color_channel->min_value = ctrl_info.min; + color_channel->max_value = ctrl_info.max; + + camerasrc->colors = g_list_append(camerasrc->colors, (gpointer)color_channel); + GST_INFO_OBJECT(camerasrc, "Adding Color Balance Channel %s (%x)", + color_channel->label, camerasrc_color_channel->id); + } else { /* if( channel_type == INTERFACE_CAMERA_CONTROL ) */ + camerasrc_control_channel = g_object_new(GST_TYPE_CAMERASRC_CONTROL_CHANNEL, NULL); + control_channel = GST_CAMERA_CONTROL_CHANNEL(camerasrc_control_channel); + + control_channel->label = g_strdup((const gchar *)camerasrc_ctrl_label[n]); + camerasrc_control_channel->id = n; + control_channel->min_value = ctrl_info.min; + control_channel->max_value = ctrl_info.max; + + camerasrc->camera_controls = g_list_append(camerasrc->camera_controls, (gpointer)control_channel); + GST_INFO_OBJECT(camerasrc, "Adding Camera Control Channel %s (%x)", + control_channel->label, camerasrc_control_channel->id); + } + } + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return TRUE; +} + + +static gboolean gst_camerasrc_empty_ctrl_list(GstCameraSrc *camerasrc) +{ + g_return_val_if_fail(camerasrc, FALSE); + + GST_DEBUG_OBJECT (camerasrc, "ENTERED"); + + g_list_foreach(camerasrc->colors, (GFunc)g_object_unref, NULL); + g_list_free(camerasrc->colors); + camerasrc->colors = NULL; + + g_list_foreach(camerasrc->camera_controls, (GFunc)g_object_unref, NULL); + g_list_free(camerasrc->camera_controls); + camerasrc->camera_controls = NULL; + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return TRUE; +} + + +static GstFlowReturn gst_camerasrc_prepare_preview(GstCameraSrc *camerasrc, int buf_num) +{ + int page_size = getpagesize(); + int buffer_size = 0; + int i = 0; + int ret = 0; + unsigned int main_buf_sz = 0; + unsigned int thumb_buf_sz = 0; + GstCaps *negotiated_caps = gst_pad_get_negotiated_caps(GST_BASE_SRC_PAD(camerasrc)); + + g_return_val_if_fail(buf_num <= MAX_USR_BUFFER_NUM, GST_FLOW_ERROR); + + camerasrc_query_img_buf_size(camerasrc->v4l2_handle, &main_buf_sz, &thumb_buf_sz); + + buffer_size = (main_buf_sz + page_size - 1) & ~(page_size - 1); + + g_present_buf.present_buffer = calloc(buf_num, sizeof(camerasrc_buffer_t)); + + for (i = 0 ; i < buf_num ; i++) { + GST_INFO_OBJECT (camerasrc,"pad_alloc called"); + ret = gst_pad_alloc_buffer(GST_BASE_SRC_PAD (camerasrc), + 0, + main_buf_sz, + negotiated_caps, + &(camerasrc->usr_buffer[i])); + + if (!GST_IS_BUFFER(camerasrc->usr_buffer[i])) { + GST_INFO_OBJECT (camerasrc, "[%d] NOT BUFFER!!?", i); + } + if (ret != GST_FLOW_OK) { + GST_ERROR_OBJECT (camerasrc, "gst_pad_alloc_buffer failed. [%d]", ret); + return ret; + } + + GST_INFO_OBJECT(camerasrc, "Alloced Size %d, Alloced address %p", + GST_BUFFER_SIZE(camerasrc->usr_buffer[i]), + GST_BUFFER_DATA(camerasrc->usr_buffer[i])); + + g_present_buf.present_buffer[i].start = GST_BUFFER_DATA(camerasrc->usr_buffer[i]); + g_present_buf.present_buffer[i].length = buffer_size; + } + + g_present_buf.num_buffer = buf_num; + + gst_caps_unref(negotiated_caps); + negotiated_caps = NULL; + + ret = camerasrc_present_usr_buffer(camerasrc->v4l2_handle, &g_present_buf, CAMERASRC_IO_METHOD_USRPTR); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_present_usr_buffer failed ret = %x", ret); + } else { + GST_INFO_OBJECT(camerasrc, "present_buffer success"); + } + + /*CAMERASRC CAM: start video preview*/ + ret = camerasrc_start_preview_stream(camerasrc->v4l2_handle); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT (camerasrc, "camerasrc_start_preview_stream() failed. errcode = 0x%08X", ret); + gst_camerasrc_error_handler(camerasrc, ret); + + return GST_FLOW_ERROR; + } + + GST_INFO_OBJECT(camerasrc, "camerasrc_start_preview_stream() done"); + + camerasrc->buffer_running = TRUE; + camerasrc->buffer_count = buf_num; + camerasrc->first_invokation = TRUE; + + return GST_FLOW_OK; +} + + +static gboolean gst_camerasrc_start(GstCameraSrc *camerasrc) +{ + int ret = 0; + + camerasrc_format_t fmt; + camerasrc_frac_t frac; + + GST_DEBUG_OBJECT(camerasrc, "ENTERED"); + +#ifdef _SPEED_UP_RAW_CAPTURE + /* check if from no stream change capture */ + if (camerasrc->mode == VIDEO_IN_MODE_CAPTURE && + camerasrc->cap_stream_diff == FALSE) { + camerasrc->buffer_running = TRUE; + goto _READY_DONE; + } + + camerasrc->cap_stream_diff = FALSE; +#endif + + /**@note do not setting at camer starting time*/ + /*CAMERASRC CAM: set FILTER (by default value)*/ + + /*CAMERASRC CAM: callback*/ + camerasrc_set_focused_callback(camerasrc->v4l2_handle, gst_camerasrc_af_cb, camerasrc); + + CLEAR(fmt); + CLEAR(frac); + + /*CAMERASRC CAM: format*/ + fmt.pix_format = camerasrc->pix_format; + fmt.colorspace = camerasrc->colorspace; + fmt.is_highquality_mode = 0; /*Fixed. if preview mode, set 0*/ + fmt.rotation = camerasrc->rotate; + + /*CAMERASRC CAM: set resolution - Do not care about rotation */ + CAMERASRC_SET_SIZE_BY_DIMENSION(fmt, camerasrc->width, camerasrc->height); + + /*CAMERASRC CAM: set format*/ + GST_INFO_OBJECT(camerasrc, "pix [%dx%d] fps %d, format %d, colorspace %d, rotation %d", + camerasrc->width, camerasrc->height, camerasrc->fps, + fmt.pix_format, fmt.colorspace, fmt.rotation); + ret = camerasrc_set_format(camerasrc->v4l2_handle, &fmt); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT (camerasrc, "camerasrc_set_format() failed. errcode = 0x%08X", ret); + goto _ERROR; + } + + /*CAMERASRC CAM: set fps*/ + if (camerasrc->fps_auto) { + /*if fps is zero, auto fps mode*/ + frac.numerator = 0; + frac.denominator = 1; + GST_INFO_OBJECT (camerasrc, "FPS auto(%d)", camerasrc->fps_auto); + } else if (camerasrc->high_speed_fps <= 0) { + if (camerasrc->fps <= 0) { + /*if fps is zero, auto fps mode*/ + frac.numerator = 0; + frac.denominator = 1; + } else { + frac.numerator = 1; + frac.denominator = camerasrc->fps; + } + } else { + GST_INFO_OBJECT(camerasrc, "high speed recording(%d)", camerasrc->high_speed_fps); + frac.numerator = 1; + frac.denominator = camerasrc->high_speed_fps; + } + + ret = camerasrc_set_timeperframe(camerasrc->v4l2_handle, &frac); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_set_timeperframe() failed. errcode = 0x%x", ret); + goto _ERROR; + } + GST_INFO_OBJECT (camerasrc, "camerasrc_set_timeperframe() done"); + + camerasrc->buffer_running = TRUE; + + if ((camerasrc->use_pad_alloc == FALSE)) { + /*CAMERASRC CAM: Set Sensor mode*/ + camerasrc_set_sensor_mode(camerasrc->v4l2_handle, camerasrc->sensor_mode); + + /*CAMERASRC CAM: Set flip*/ + camerasrc_set_vflip(camerasrc->v4l2_handle, camerasrc->vflip); + camerasrc_set_hflip(camerasrc->v4l2_handle, camerasrc->hflip); + + /*CAMERASRC CAM: start video preview*/ + __ta__(" camerasrc_start_preview_stream", + ret = camerasrc_start_preview_stream(camerasrc->v4l2_handle); + ); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_start_preview_stream() failed. errcode = 0x%x", ret); + camerasrc->buffer_running = FALSE; + goto _ERROR; + } + + GST_INFO_OBJECT(camerasrc, "camerasrc_start_preview_stream() done"); + + ret = camerasrc_get_num_buffer(camerasrc->v4l2_handle, &(camerasrc->buffer_count)); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_get_num_buffer() failed. errcode = 0x%x", ret); + goto _ERROR; + } + + GST_INFO_OBJECT(camerasrc, "buffer number %d", camerasrc->buffer_count); +#ifdef _SPEED_UP_RAW_CAPTURE + camerasrc->cap_stream_diff = FALSE; +#endif + } + +#ifdef _SPEED_UP_RAW_CAPTURE +_READY_DONE: +#endif + camerasrc->mode = VIDEO_IN_MODE_PREVIEW; + camerasrc->current_buffer_data_index = (camerasrc->current_buffer_data_index + 1)%10; + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return TRUE; + +_ERROR: + gst_camerasrc_error_handler(camerasrc, ret); + + /* Stop stream */ + camerasrc_stop_stream(camerasrc->v4l2_handle); + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return FALSE; +} + + +static gboolean gst_camerasrc_stop(GstCameraSrc *camerasrc) +{ + camerasrc_io_method_t io_method; + + GST_DEBUG_OBJECT (camerasrc, "ENTERED"); + + if (camerasrc->v4l2_handle) { + /* CAMERASRC CAM: stop stream */ + /* To guarantee buffers are valid before finishing */ + GMutex *lock_mutex = NULL; + + if (camerasrc->use_pad_alloc == FALSE) { + lock_mutex = camerasrc->buffer_lock; + } else { + lock_mutex = camerasrc->pad_alloc_mutex; + } + + g_mutex_lock(lock_mutex); + while (camerasrc->num_live_buffers > _DEFAULT_KEEPING_BUFFER) { + GTimeVal abstimeout; + GST_INFO_OBJECT(camerasrc, "Wait until all live buffers are relased. (Tot=%d, Live=%d)", + camerasrc->buffer_count, camerasrc->num_live_buffers); + + g_get_current_time(&abstimeout); + g_time_val_add(&abstimeout, _PREVIEW_BUFFER_WAIT_TIMEOUT); + + if (!g_cond_timed_wait(camerasrc->buffer_cond, lock_mutex, &abstimeout)) { + GST_ERROR_OBJECT(camerasrc, "Buffer wait timeout[%d usec].(Live=%d) Skip waiting...", + _PREVIEW_BUFFER_WAIT_TIMEOUT, camerasrc->num_live_buffers); + gst_camerasrc_buffer_trace(camerasrc); + break; + } else { + GST_INFO_OBJECT(camerasrc, "Signal received."); + } + } + g_mutex_unlock(lock_mutex); + GST_INFO_OBJECT(camerasrc, "Waiting free buffer finished. (Live=%d)", camerasrc->num_live_buffers); + + camerasrc_stop_stream(camerasrc->v4l2_handle); + + camerasrc->buffer_running = FALSE; + camerasrc->mode = VIDEO_IN_MODE_UNKNOWN; + + /* If I/O method is Usrptr, it uses usr_buffer that is member of camerasrc structure */ + /* It must be unreffed when it stops */ + + camerasrc_get_io_method(camerasrc->v4l2_handle, &io_method); + switch (io_method) { + case CAMERASRC_IO_METHOD_MMAP: + break; + case CAMERASRC_IO_METHOD_USRPTR: + if (g_present_buf.present_buffer) { + free(g_present_buf.present_buffer); + g_present_buf.present_buffer = NULL; + } + break; + case CAMERASRC_IO_METHOD_READ: + default: + break; + } + } + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return TRUE; +} + + +static gboolean gst_camerasrc_capture_start(GstCameraSrc *camerasrc) +{ + /*CAMERASRC CAM*/ + int ret = 0; + char *pfourcc = NULL; + camerasrc_format_t fmt; + camerasrc_frac_t frac; + + GST_INFO_OBJECT(camerasrc, "ENTERED"); + + if (camerasrc->mode == VIDEO_IN_MODE_PREVIEW) { + /* To guarantee buffers are valid before finishing. */ + __ta__( " wait for buffer in gst_camerasrc_capture_start", + if (camerasrc->use_pad_alloc == FALSE) { + g_mutex_lock(camerasrc->buffer_lock); + while (camerasrc->num_live_buffers > _DEFAULT_KEEPING_BUFFER) { + GTimeVal abstimeout; + GST_INFO_OBJECT(camerasrc, "Wait until all live buffers are relased. (Tot=%d, Live=%d)", + camerasrc->buffer_count, camerasrc->num_live_buffers); + + g_get_current_time(&abstimeout); + g_time_val_add(&abstimeout, _PREVIEW_BUFFER_WAIT_TIMEOUT); + + if (!g_cond_timed_wait(camerasrc->buffer_cond, camerasrc->buffer_lock, &abstimeout)) { + GST_ERROR_OBJECT(camerasrc, "Buffer wait timeout[%d usec].(Live=%d) Skip waiting...", + _PREVIEW_BUFFER_WAIT_TIMEOUT, camerasrc->num_live_buffers); + gst_camerasrc_buffer_trace(camerasrc); + break; + } else { + GST_INFO_OBJECT(camerasrc, "Signal received."); + } + } + g_mutex_unlock(camerasrc->buffer_lock); + GST_INFO_OBJECT(camerasrc, "Waiting free buffer is finished. (Live=%d)", camerasrc->num_live_buffers); + } + ); + +#ifdef _SPEED_UP_RAW_CAPTURE + /* Skip restart stream if format/width/height are all same */ + if (camerasrc->fourcc == camerasrc->cap_fourcc && + camerasrc->width == camerasrc->cap_width && + camerasrc->height == camerasrc->cap_height) { + GST_INFO_OBJECT(camerasrc, "fourcc, width and height is same. Skip restarting stream."); + goto _CAPTURE_READY_DONE; + } + + camerasrc->cap_stream_diff = TRUE; +#endif + + /*CAMERASRC CAM: stop stream*/ + __ta__( " camerasrc_stop_stream in gst_camerasrc_capture_start", + camerasrc_stop_stream(camerasrc->v4l2_handle); + ); + + GST_INFO_OBJECT (camerasrc, "camerasrc_stop_stream() done"); + camerasrc->buffer_running = FALSE; + + pfourcc = (char*)&camerasrc->cap_fourcc; + GST_INFO_OBJECT(camerasrc, "CAPTURE: Size[%dx%d], fourcc(%c%c%c%c) quality[%d] interval[%d] count[%d]", + camerasrc->cap_width, camerasrc->cap_height, + pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3], + camerasrc->cap_quality, camerasrc->cap_interval, camerasrc->cap_count); + + /*START STILL CAPTURE*/ + + /*set current video info*/ + + memset(&fmt, 0x00, sizeof (camerasrc_format_t)); + + /*CAMERASRC CAM: set format*/ + CAMERASRC_SET_SIZE_BY_DIMENSION(fmt, camerasrc->cap_width, camerasrc->cap_height); + + _gst_camerasrc_get_raw_pixel_info(camerasrc->cap_fourcc, &(fmt.pix_format), &(fmt.colorspace)); + fmt.rotation = 0; + + if (camerasrc->cap_fourcc == GST_MAKE_FOURCC('J', 'P', 'E', 'G') || + camerasrc->cap_fourcc == GST_MAKE_FOURCC('j', 'p', 'e', 'g')) { + fmt.quality = camerasrc->cap_jpg_quality; + fmt.is_highquality_mode = camerasrc->cap_quality; /*must be 1*/ + } else { + fmt.is_highquality_mode = camerasrc->cap_quality; /*0 or 1 (default: 0)*/ + } + + /*CAMERASRC CAM: format*/ + ret = camerasrc_set_format(camerasrc->v4l2_handle, &fmt); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_set_format() failed. errcode = 0x%x", ret); + goto _ERROR; + } + GST_INFO_OBJECT(camerasrc, "camerasrc_set_format() done"); + + if (camerasrc->fps_auto || camerasrc->fps <= 0) { + /*if fps is zero, auto fps mode*/ + frac.numerator = 0; + frac.denominator = 1; + GST_INFO_OBJECT (camerasrc, "FPS auto"); + } else { + frac.numerator = 1; + frac.denominator = camerasrc->fps; + GST_INFO_OBJECT (camerasrc, "FPS (%d)", camerasrc->fps); + } + + ret = camerasrc_set_timeperframe(camerasrc->v4l2_handle, &frac); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_set_timeperframe() failed. errcode = 0x%x", ret); + goto _ERROR; + } + GST_INFO_OBJECT (camerasrc, "camerasrc_set_timeperframe() done"); + + /*CAMERASRC CAM: start stream*/ + __ta__( " camerasrc_start_still_stream", + ret = camerasrc_start_still_stream(camerasrc->v4l2_handle); + ); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "camerasrc_start_still_stream() failed. errcode = 0x%x", ret); + goto _ERROR; + } + GST_INFO_OBJECT(camerasrc, "camerasrc_start_still_stream() done"); + + camerasrc->buffer_running = TRUE; + + /*CAMERASRC CAM: set fps*/ + /*TODO: maybe do not works!*/ + +#ifdef _SPEED_UP_RAW_CAPTURE +_CAPTURE_READY_DONE: +#endif + + g_mutex_lock(camerasrc->jpg_mutex); + camerasrc->cap_next_time = 0UL; + g_mutex_unlock(camerasrc->jpg_mutex); + camerasrc->cap_count_current = 0; + + /* end change to capture mode*/ + camerasrc->mode = VIDEO_IN_MODE_CAPTURE; + + GST_INFO_OBJECT(camerasrc, "CAPTURE STARTED!"); + } else { + GST_WARNING_OBJECT(camerasrc, "Wrong state[%d]!", camerasrc->mode); + } + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return TRUE; + +_ERROR: + gst_camerasrc_error_handler(camerasrc, ret); + + return FALSE; +} + + +static gboolean gst_camerasrc_capture_stop(GstCameraSrc *camerasrc) +{ + GST_DEBUG_OBJECT(camerasrc, "ENTERED"); + + if (camerasrc->mode == VIDEO_IN_MODE_CAPTURE) { +#ifdef _SPEED_UP_RAW_CAPTURE + if (camerasrc->cap_stream_diff) { + /*CAMERASRC CAM: stop stream*/ + camerasrc_stop_stream(camerasrc->v4l2_handle); + camerasrc->buffer_running = FALSE; + + GST_INFO_OBJECT(camerasrc, "camerasrc_stop_stream() done"); + } else { + GST_INFO_OBJECT(camerasrc, "no need to stop stream(capture format==preview format)"); + } +#else + /*CAMERASRC CAM: stop stream*/ + camerasrc_stop_stream(camerasrc->v4l2_handle); + camerasrc->buffer_running = FALSE; + + GST_INFO_OBJECT(camerasrc, "camerasrc_stop_stream() done"); +#endif + GST_INFO_OBJECT(camerasrc, "CAPTURE STOPPED!"); + } + + GST_DEBUG_OBJECT (camerasrc, "LEAVED"); + + return TRUE; +} + + +static GstFlowReturn gst_camerasrc_read_preview_mmap(GstCameraSrc *camerasrc, GstBuffer **buffer) +{ + int ret = 0; + int v4l2_buffer_index = 0; + guint i = 0; + unsigned int isize = 0; + unsigned char *pData = NULL; + void *buf = NULL; + camerasrc_buffer_t main_buf; + GstCameraBuffer *vid_buf = NULL; + + /*alloc main buffer*/ + vid_buf = gst_camerasrc_buffer_new(camerasrc); + buf = (GstCameraBuffer *)vid_buf; + + g_mutex_lock(camerasrc->buffer_lock); + GST_LOG_OBJECT(camerasrc, "After lock(buffer live %d, total %d)", + camerasrc->num_live_buffers, camerasrc->buffer_count); + + for (i = 0 ; i < _MAX_TRIAL_WAIT_FRAME ; i++) { + /* Wait frame */ + __ta__( " camerasrc_wait_frame_available", + ret = camerasrc_wait_frame_available(camerasrc->v4l2_handle, _DEFAULT_DEQUE_WAITINGTIME); + ); + if (ret != CAMERASRC_SUCCESS) { + if (ret == CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT && i < (_MAX_TRIAL_WAIT_FRAME - 1)) { + GST_ERROR_OBJECT(camerasrc, "SELECT TIMEOUT!!! Retry..(pad_alloc %d, live %d)", + camerasrc->use_pad_alloc, camerasrc->num_live_buffers); + continue; + } + + if (ret == CAMERASRC_ERR_DEVICE_UNAVAILABLE) { + GST_ERROR_OBJECT(camerasrc, "register trouble error!! [%x]", ret); + /*g_signal_emit (G_OBJECT (camerasrc), gst_camerasrc_signals[SIGNAL_REGISTER_TROUBLE], (GQuark)NULL);*/ + g_mutex_unlock(camerasrc->buffer_lock); + gst_camerasrc_error_handler(camerasrc, ret); + + return GST_FLOW_ERROR; + } else if (ret == CAMERASRC_ERR_INVALID_STATE && (i < _MAX_TRIAL_WAIT_FRAME - 1)) { + GST_WARNING_OBJECT(camerasrc, "try again..."); + } else { + GST_ERROR_OBJECT(camerasrc, "Frame waiting error[%x]", ret); + g_mutex_unlock(camerasrc->buffer_lock); + gst_camerasrc_error_handler(camerasrc, ret); + + return GST_FLOW_ERROR; + } + } else { + GST_LOG_OBJECT(camerasrc, "select success, do DQBUF"); + break; + } + } + + /* Buffer DQ */ + __ta__( " camerasrc_dequeue_buffer", + ret = camerasrc_dequeue_buffer(camerasrc->v4l2_handle, &v4l2_buffer_index, &main_buf, NULL); + ); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "Dequeue frame error[%x]", ret); + g_mutex_unlock(camerasrc->buffer_lock); + gst_camerasrc_error_handler(camerasrc, ret); + + return GST_FLOW_ERROR; + } + + camerasrc->num_live_buffers++; + GST_LOG_OBJECT (camerasrc, "after : DQBUF (index %d, live bufs %d)", + v4l2_buffer_index, camerasrc->num_live_buffers); + + g_mutex_unlock (camerasrc->buffer_lock); + + if (camerasrc->fourcc == GST_MAKE_FOURCC('S','N','1','2') || + camerasrc->fourcc == GST_MAKE_FOURCC('S','T','1','2') || + camerasrc->fourcc == GST_MAKE_FOURCC('S','U','Y','V') || + camerasrc->fourcc == GST_MAKE_FOURCC('S','U','Y','2') || + camerasrc->fourcc == GST_MAKE_FOURCC('S','Y','V','Y') || + camerasrc->fourcc == GST_MAKE_FOURCC('S','4','2','0')) { + /* for physical address */ + GST_BUFFER_MALLOCDATA(vid_buf) = gst_camerasrc_make_metadata_for_nonlinear_buffer(camerasrc, v4l2_buffer_index); + + /* for virtual address - GST_BUFFER_DATA and SIZE */ + pData = main_buf.start; + isize = main_buf.length; + } else if (camerasrc->fourcc == GST_MAKE_FOURCC('I','4','2','0') || + camerasrc->fourcc == GST_MAKE_FOURCC('N','V','1','2')) { + ret = _gst_camerasrc_get_normal_buffer(camerasrc, camerasrc->fourcc, + main_buf.start, camerasrc->width, camerasrc->height, + &pData, &isize); + if (ret == FALSE) { + g_mutex_unlock( camerasrc->buffer_lock ); + return GST_FLOW_ERROR; + } + + vid_buf->is_alloc_data = TRUE; + } else { + pData = main_buf.start; + isize = main_buf.length; + } + + GST_BUFFER_DATA(vid_buf) = pData; + GST_BUFFER_SIZE(vid_buf) = isize; + vid_buf->v4l2_buffer_index = v4l2_buffer_index; + + if (camerasrc->firsttime) { + /** Because of basesrc negotiation , "framerate" field is needed. */ + int fps_nu = 0; + int fps_de = 0; + int af_mode = CAMERASRC_AF_MODE_AUTO; + int af_range = CAMERASRC_AF_RANGE_NORMAL; + gchar *caps_string = NULL; + GstCaps *caps = NULL; + + if (camerasrc->fps <= 0) { + /*if fps is zero, auto fps mode*/ + fps_nu = 0; + fps_de = 1; + } else { + fps_nu = 1; + fps_de = camerasrc->fps; + } + + GST_INFO_OBJECT(camerasrc, "FPS auto[%d], FPS[%d], High speed FPS[%d]", + camerasrc->fps_auto, camerasrc->fps, camerasrc->high_speed_fps); + + caps = gst_caps_new_simple("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, camerasrc->fourcc, + "width", G_TYPE_INT, camerasrc->width, + "height", G_TYPE_INT, camerasrc->height, + "framerate", GST_TYPE_FRACTION, fps_de, fps_nu, + NULL); + if (caps == NULL) { + GST_ERROR_OBJECT(camerasrc, "failed to alloc caps"); + gst_buffer_unref((GstBuffer *)vid_buf); + vid_buf = NULL; + buf = NULL; + return GST_FLOW_ERROR; + } + + if (camerasrc->use_rotate_caps) { + gst_caps_set_simple(caps, "rotate", G_TYPE_INT, camerasrc->rotate, NULL); + } + + GST_BUFFER_CAPS(buf) = caps; + + caps_string = gst_caps_to_string(caps); + GST_INFO_OBJECT(camerasrc, "PREVIEW MODE first time [%dx%d], rotate[%d], caps[%s]", + camerasrc->width, camerasrc->height, camerasrc->rotate, caps_string); + if (caps_string) { + g_free(caps_string); + caps_string = NULL; + } + + if (camerasrc->fourcc == GST_MAKE_FOURCC('N','V','1','2') || + camerasrc->fourcc == GST_MAKE_FOURCC('S','N','1','2')) { + /* Start Focusing when Continuous AF */ + camerasrc_get_autofocusing_mode(camerasrc->v4l2_handle, &af_mode, &af_range); + if (af_mode == CAMERASRC_AF_MODE_CONTINUOUS) { + GST_INFO_OBJECT(camerasrc, "This is (NV12 or SN12) and Continuous AF mode. Start AF"); + camerasrc_start_autofocusing(camerasrc->v4l2_handle); + } + } + + camerasrc->firsttime = FALSE; + } + + gst_camerasrc_get_timeinfo(camerasrc, (GstBuffer*)vid_buf); + + *buffer = (GstBuffer*)vid_buf; + + /*GST_DEBUG_OBJECT(camerasrc, "refcount: %d", GST_OBJECT_REFCOUNT(*buffer));*/ + +#if _ENABLE_CAMERASRC_DEBUG + g_preview_frame_cnt++; +#endif + + return GST_FLOW_OK; +} + + +static GstFlowReturn gst_camerasrc_read_preview_pad_alloc(GstCameraSrc *camerasrc, GstBuffer **buffer) +{ + int ret = 0; + int v4l2_buffer_index = 0; + int is_esd = 0; + guint cnt_again = _MAX_PAD_ALLOC_RETRY_COUNT; + void *buf = NULL; + camerasrc_buffer_t main_buf; + GstBuffer *gst_buf = NULL; + GST_CAMERASRC_BUFFER_DATA *buffer_data = NULL; + + /*alloc main buffer*/ + gst_buf = *buffer; + buf = (GstBuffer *)gst_buf; + + g_mutex_lock(camerasrc->buffer_lock); + GST_LOG_OBJECT(camerasrc, "After lock(lvn %d, buf cnt %d)", camerasrc->num_live_buffers, camerasrc->buffer_count); + +AGAIN: + g_mutex_lock (camerasrc->pad_alloc_mutex); + while (!g_queue_is_empty(camerasrc->pad_alloc_list) && !camerasrc->first_invokation) { + int pad_alloc_index = -1; + int proper_index = -1; + camerasrc_buffer_t camerasrc_buffer; + GstBuffer *pad_alloc_buffer; + GstCaps *negotiated_caps = NULL; + + g_mutex_unlock (camerasrc->pad_alloc_mutex); + + camerasrc_buffer.start = NULL; + camerasrc_buffer.length = 0; + + g_mutex_lock (camerasrc->pad_alloc_mutex); + pad_alloc_index = (int)g_queue_pop_head(camerasrc->pad_alloc_list); + g_mutex_unlock (camerasrc->pad_alloc_mutex); + sched_yield(); + GST_LOG_OBJECT (camerasrc, "Index queue have item. pad_alloc_index = %d", pad_alloc_index); + + negotiated_caps = gst_pad_get_negotiated_caps (GST_BASE_SRC_PAD (camerasrc)); + + /* pad allocation from sink(or any where) */ + ret = gst_pad_alloc_buffer(GST_BASE_SRC_PAD (camerasrc), + 0, + camerasrc->main_buf_sz, + negotiated_caps, + &pad_alloc_buffer); + if (ret != GST_FLOW_OK) { + GST_ERROR_OBJECT(camerasrc, "Pad alloc fail, ret = [%d]", ret); + g_cond_signal(camerasrc->buffer_cond); + g_mutex_unlock(camerasrc->buffer_lock); + gst_caps_unref(negotiated_caps); + + return ret; + } + + proper_index = get_proper_index(camerasrc, pad_alloc_buffer); + if (proper_index == -1) { + GST_INFO_OBJECT(camerasrc, "Proper index doesn't exist"); + g_mutex_unlock(camerasrc->buffer_lock); + + return GST_FLOW_ERROR; + } + + if (proper_index != pad_alloc_index) { + GST_LOG_OBJECT(camerasrc, "Proper index different from pad_alloc_index, proper_index = %d, pad_alloc_index = %d", + proper_index, pad_alloc_index); + } + + GST_LOG_OBJECT(camerasrc, "gst_pad_alloc_buffer called. index = %d, GstBuffer address = %p", + proper_index, &(camerasrc->usr_buffer[pad_alloc_index])); + + camerasrc->usr_buffer[proper_index] = pad_alloc_buffer; + + camerasrc_buffer.start = GST_BUFFER_DATA(GST_BUFFER(camerasrc->usr_buffer[proper_index])); + camerasrc_buffer.length = GST_BUFFER_SIZE(GST_BUFFER(camerasrc->usr_buffer[proper_index])); + + camerasrc_buffer.length = PAGE_ALIGN(camerasrc_buffer.length); + + if (!camerasrc_buffer.start) { + GST_ERROR_OBJECT(camerasrc, "Data for queueing is not available one, data = %p", camerasrc_buffer.start); + g_cond_signal(camerasrc->buffer_cond); + g_mutex_unlock(camerasrc->buffer_lock); + + return GST_FLOW_ERROR; + } + + if (camerasrc_buffer.length <= 0) { + GST_ERROR_OBJECT(camerasrc, "Length for queueing is not available one, data = %d", camerasrc_buffer.length); + g_cond_signal(camerasrc->buffer_cond); + g_mutex_unlock(camerasrc->buffer_lock); + + return GST_FLOW_ERROR; + } + + ret = camerasrc_queue_buffer(camerasrc->v4l2_handle, proper_index, &camerasrc_buffer); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "Queue frame error, [%x]", ret); + g_cond_signal(camerasrc->buffer_cond); + g_mutex_unlock(camerasrc->buffer_lock); + gst_caps_unref(negotiated_caps); + + return GST_FLOW_ERROR; + } + + gst_caps_unref(negotiated_caps); + + g_cond_signal(camerasrc->buffer_cond); + GST_LOG_OBJECT(camerasrc, "QBUF : [idx=%d, lvn=%d]", proper_index, camerasrc->num_live_buffers); + g_mutex_lock(camerasrc->pad_alloc_mutex); + } + + g_mutex_unlock(camerasrc->pad_alloc_mutex); + + ret = camerasrc_wait_frame_available(camerasrc->v4l2_handle, _PAD_ALLOC_RETRY_PERIOD); + if (ret == CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT) { + if (cnt_again--) { + if ((cnt_again % 100) == 0) { + GST_LOG_OBJECT (camerasrc, "Check ESD......"); + + is_esd = 0; + ret = camerasrc_check_esd_shock(camerasrc->v4l2_handle, &is_esd); + if (is_esd) { + /* ESD situation */ + GST_LOG_OBJECT(camerasrc, "ESD situation. device reset preview"); + GST_LOG_OBJECT(camerasrc, "register trouble error!! [%x]", CAMERASRC_ERR_DEVICE_UNAVAILABLE); + g_mutex_unlock(camerasrc->buffer_lock); + + gst_camerasrc_error_handler(camerasrc, CAMERASRC_ERR_DEVICE_UNAVAILABLE); + + return GST_FLOW_ERROR; + } + } + goto AGAIN; + } else { + GST_LOG_OBJECT (camerasrc, "Check ESD......"); + + is_esd = 0; + ret = camerasrc_check_esd_shock(camerasrc->v4l2_handle, &is_esd); + if (!is_esd) { + /* Not ESD situation */ + GST_LOG_OBJECT(camerasrc, "Not ESD situation. normal timeout"); + g_mutex_unlock(camerasrc->buffer_lock); + + gst_camerasrc_error_handler(camerasrc, CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT); + + return GST_FLOW_WRONG_STATE; + } else { + /* ESD situation */ + GST_LOG_OBJECT(camerasrc, "ESD situation. device reset preview"); + GST_LOG_OBJECT(camerasrc, "register trouble error!! [%x]", CAMERASRC_ERR_DEVICE_UNAVAILABLE); + g_mutex_unlock(camerasrc->buffer_lock); + + gst_camerasrc_error_handler(camerasrc, CAMERASRC_ERR_DEVICE_UNAVAILABLE); + + return GST_FLOW_ERROR; + } + + GST_ERROR_OBJECT(camerasrc, "Time out retried [%d] times %d", _MAX_PAD_ALLOC_RETRY_COUNT - cnt_again + 1); + } + } else if (ret != CAMERASRC_SUCCESS) { + g_mutex_unlock(camerasrc->buffer_lock); + GST_ERROR_OBJECT(camerasrc, "camerasrc_wait_frame_available error [%x]", ret); + + return GST_FLOW_ERROR; + } + + /* Buffer DQ */ + __ta__( " camerasrc_dequeue_buffer", + ret = camerasrc_dequeue_buffer(camerasrc->v4l2_handle, &v4l2_buffer_index, &main_buf, NULL); + ); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "Dequeue frame error, [%x]", ret); + g_mutex_unlock(camerasrc->buffer_lock); + gst_camerasrc_error_handler(camerasrc, ret); + + return GST_FLOW_ERROR; + } + + camerasrc->num_live_buffers++; + GST_LOG_OBJECT(camerasrc, "after : DQBUF (index %d, live number %d)", + v4l2_buffer_index, camerasrc->num_live_buffers); + g_mutex_unlock(camerasrc->buffer_lock); + + /* For camera state stopped */ + gst_buf = camerasrc->usr_buffer[v4l2_buffer_index]; + if (gst_buf == NULL) { + GST_ERROR_OBJECT(camerasrc, "camerasrc->usr_buffer[v4l2_buffer_index] NULL"); + return GST_FLOW_WRONG_STATE; + } + + GST_LOG_OBJECT(camerasrc, "Start to set up buffer free structure"); + + buffer_data = g_malloc(sizeof(GST_CAMERASRC_BUFFER_DATA)); + if (buffer_data == NULL) { + GST_ERROR_OBJECT(camerasrc, "buffer_data NULL"); + return GST_FLOW_WRONG_STATE; + } + + buffer_data->camerasrc = camerasrc; + buffer_data->index = v4l2_buffer_index; + buffer_data->buffer_data_index = camerasrc->current_buffer_data_index; + + GST_BUFFER_DATA(gst_buf) = main_buf.start; + GST_BUFFER_SIZE(gst_buf) = main_buf.length; + GST_BUFFER_MALLOCDATA(gst_buf) = (guint8 *)buffer_data; + GST_BUFFER_FREE_FUNC(gst_buf) = gst_camerasrc_buffer_free; + + GST_LOG_OBJECT(camerasrc, "End to set up buffer free structure"); + + + if (camerasrc->firsttime) { + /* Because of basesrc negotiation , "framerate" field is needed. */ + int fps_nu = 0; + int fps_de = 0; + gchar *caps_string = NULL; + GstCaps *caps = NULL; + + if (camerasrc->fps <= 0) { + /*if fps is zero, auto fps mode*/ + fps_nu = 0; + fps_de = 1; + } else { + fps_nu = 1; + fps_de = camerasrc->fps; + } + + GST_INFO_OBJECT(camerasrc, "FPS auto[%d], FPS[%d], High speed FPS[%d]", + camerasrc->fps_auto, camerasrc->fps, camerasrc->high_speed_fps); + + caps = gst_caps_new_simple("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, camerasrc->fourcc, + "width", G_TYPE_INT, camerasrc->width, + "height", G_TYPE_INT, camerasrc->height, + "framerate", GST_TYPE_FRACTION, fps_de, fps_nu, + NULL); + if (caps == NULL) { + GST_ERROR_OBJECT(camerasrc, "failed to alloc caps"); + return GST_FLOW_ERROR; + } + + if (camerasrc->use_rotate_caps) { + gst_caps_set_simple(caps, "rotate", G_TYPE_INT, camerasrc->rotate, NULL); + } + + GST_BUFFER_CAPS(gst_buf) = caps; + + caps_string = gst_caps_to_string(caps); + GST_INFO_OBJECT (camerasrc, "PREVIEW MODE first time [%dx%d], rotate[%d], caps[%s]", + camerasrc->width, camerasrc->height, camerasrc->rotate, caps_string); + if (caps_string) { + g_free(caps_string); + caps_string = NULL; + } + + camerasrc->firsttime = FALSE; + } + + gst_camerasrc_get_timeinfo(camerasrc, gst_buf); + + *buffer = gst_buf; + + g_mutex_lock (camerasrc->pad_alloc_mutex); + if (camerasrc->first_invokation) { + GST_INFO_OBJECT(camerasrc, "[DEBUG] Check something in pad_alloc_list"); + g_mutex_unlock (camerasrc->pad_alloc_mutex); + g_mutex_lock (camerasrc->pad_alloc_mutex); + + while (!g_queue_is_empty(camerasrc->pad_alloc_list)) { + g_mutex_unlock(camerasrc->pad_alloc_mutex); + g_mutex_lock(camerasrc->pad_alloc_mutex); + + /* Remove all item */ + + g_queue_pop_head(camerasrc->pad_alloc_list); + GST_INFO_OBJECT(camerasrc, "[DEBUG] Something is in pad_alloc_list before first frame. remove it!"); + + g_mutex_unlock(camerasrc->pad_alloc_mutex); + g_mutex_lock(camerasrc->pad_alloc_mutex); + } + + g_mutex_unlock(camerasrc->pad_alloc_mutex); + g_mutex_lock(camerasrc->pad_alloc_mutex); + camerasrc->first_invokation = FALSE; + } + g_mutex_unlock (camerasrc->pad_alloc_mutex); + +#if _ENABLE_CAMERASRC_DEBUG + g_preview_frame_cnt++; +#endif + + return GST_FLOW_OK; +} + + +static GstFlowReturn gst_camerasrc_draw_black_preview(GstCameraSrc *camerasrc, GstBuffer **buffer) +{ + int fps_nu = 0; + int fps_de = 0; + guint fakebuflen = 0; + GstBuffer *gst_buf = NULL; + + /*alloc main buffer*/ + if (camerasrc->fourcc == GST_MAKE_FOURCC('Y','U','Y','2')) { + fakebuflen = camerasrc->width * camerasrc->height * 2; + gst_buf = gst_buffer_new_and_alloc(fakebuflen); + GenerateYUV422BlackFrame(GST_BUFFER_MALLOCDATA(gst_buf), fakebuflen, camerasrc->width , camerasrc->height); + } else if (camerasrc->fourcc == GST_MAKE_FOURCC ('I','4','2','0') || + camerasrc->fourcc == GST_MAKE_FOURCC ('Y', 'U', '1', '2')) { + fakebuflen = camerasrc->width * camerasrc->height * 3 / 2; + gst_buf = gst_buffer_new_and_alloc(fakebuflen); + GenerateYUV420BlackFrame(GST_BUFFER_MALLOCDATA(gst_buf), fakebuflen, camerasrc->width , camerasrc->height); + } else { + GST_DEBUG_OBJECT(camerasrc, "Wrong fourcc(%x)", camerasrc->fourcc); + return GST_FLOW_OK; + } + + GST_DEBUG_OBJECT(camerasrc, "gst_camerasrc_draw_black_preview (data=%p, len=%d)", + GST_BUFFER_MALLOCDATA(gst_buf), fakebuflen); + /** + Because of basesrc negotiation , "framerate" field is needed. + */ + if (camerasrc->fps <= 0) { + /*if fps is zero, auto fps mod e*/ + fps_nu = 0; + fps_de = 1; + } else { + fps_nu = 1; + fps_de = camerasrc->fps; + } + + GST_INFO_OBJECT(camerasrc, "FPS auto[%d], FPS[%d], High speed FPS[%d]", + camerasrc->fps_auto, camerasrc->fps, camerasrc->high_speed_fps); + + GST_BUFFER_CAPS(gst_buf) = gst_caps_new_simple("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, camerasrc->fourcc, + "width", G_TYPE_INT, camerasrc->width, + "height", G_TYPE_INT, camerasrc->height, + "framerate", GST_TYPE_FRACTION, fps_de, fps_nu, + NULL); + + GST_DEBUG_OBJECT(camerasrc, "PREVIEW MODE first time [%d] [%d]", camerasrc->width, camerasrc->height); + gst_camerasrc_get_timeinfo(camerasrc, gst_buf); + + *buffer = gst_buf; + return GST_FLOW_OK; +} + + +static GstFlowReturn gst_camerasrc_read_capture(GstCameraSrc *camerasrc, GstBuffer **buffer, int command) +{ + int ret; + int buffer_index = 0; + unsigned long cur_time; + gboolean is_jpeg = FALSE; + + static gboolean get_stop_command = FALSE; + static gboolean get_stop_multi_command = FALSE; + + GstCameraBuffer *buf = NULL; /*output buffer for preview*/ + GstBuffer *buf_cap_signal1 = NULL; /*output main buffer for capture signal*/ + GstBuffer *buf_cap_signal2 = NULL; /*output thumbnail buffer for capture signal*/ + GstBuffer *buf_cap_signal3 = NULL; /*output screennail buffer for capture signal*/ + + camerasrc_buffer_t main_buf = {0, NULL, 0}; /*original size buffer*/ + camerasrc_buffer_t thumb_buf = {0, NULL, 0}; /*thumbnail size buffer*/ + camerasrc_buffer_t scrnl_buf = {0, NULL, 0}; /*screennail size buffer*/ + + GST_DEBUG_OBJECT(camerasrc, "ENTERED. Command[%d]", command); + + GST_INFO_OBJECT(camerasrc, "src size[%dx%d], capture size[%dx%d]", + camerasrc->width, camerasrc->height, + camerasrc->cap_width, camerasrc->cap_height ); + + if (command == GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP) { + get_stop_command = TRUE; + } else if (command == GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP_MULTISHOT) { + get_stop_multi_command = TRUE; + } + + GST_INFO_OBJECT(camerasrc, "cnt current:%d, reverse:%d, stop cmd:%d, multi stop cmd:%d", + camerasrc->cap_count_reverse, camerasrc->cap_count_current, + get_stop_command, get_stop_multi_command); + + while (TRUE) { + if (camerasrc->cap_count_reverse == 0 || + ((get_stop_command || get_stop_multi_command) && + camerasrc->cap_count_current != 0 )) { + g_mutex_lock(camerasrc->mutex); + + GST_INFO_OBJECT(camerasrc, "Capture finished."); + + __ta__( " capture: gst_camerasrc_capture_stop", + gst_camerasrc_capture_stop(camerasrc); + ); + if (get_stop_command == FALSE) { + if (!g_queue_is_empty(camerasrc->command_list)) { + command = (int)g_queue_pop_head(camerasrc->command_list); + GST_INFO_OBJECT(camerasrc, "Pop command [%d]", command); + if (command == GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP) { + get_stop_command = TRUE; + } + } + + if (get_stop_command == FALSE) { + GST_INFO_OBJECT(camerasrc, "Start : Wait for Capture stop signal"); + __ta__( " capture: wait for cond after image capture", + g_cond_wait(camerasrc->cond, camerasrc->mutex); + ); + GST_INFO_OBJECT(camerasrc, "End : Wait for Capture stop signal"); + } + } + + __ta__(" capture: gst_camerasrc_start", + gst_camerasrc_start(camerasrc); + ); + + __ta__(" capture: one gst_camerasrc_read_preview_mmap", + ret = gst_camerasrc_read_preview_mmap(camerasrc, buffer); + ); + + get_stop_command = FALSE; + get_stop_multi_command = FALSE; + + g_mutex_unlock(camerasrc->mutex); + + MMTA_ACUM_ITEM_END( " Shot to Shot in gstcamerasrc", FALSE); + + return ret; + } + + if (camerasrc->cap_fourcc == GST_MAKE_FOURCC('J','P','E','G') || + camerasrc->cap_fourcc == GST_MAKE_FOURCC('j','p','e','g')) { + is_jpeg = TRUE; + } else { + is_jpeg = FALSE; + } + + /** + *@important JPEG still: always same image generated by camerasrc_read_frame. + * if you want to multi shot, set YUV format ! + */ + __ta__(" camerasrc_read_frame:select,DQ,Copy,Q", + ret = camerasrc_read_frame(camerasrc->v4l2_handle, &main_buf, &thumb_buf, &buffer_index); + ); + if (ret != CAMERASRC_SUCCESS) { + if (ret == CAMERASRC_ERR_DEVICE_UNAVAILABLE) { + GST_ERROR_OBJECT (camerasrc, "Video src device return register trouble error!! [%x]", ret); + /*g_signal_emit (G_OBJECT (camerasrc), gst_camerasrc_signals[SIGNAL_REGISTER_TROUBLE], (GQuark)NULL);*/ + gst_camerasrc_error_handler(camerasrc, ret); + return GST_FLOW_ERROR; + } else { + GST_ERROR_OBJECT (camerasrc, "camerasrc_read_frame() failed. [ret = 0x%08X]", ret); + GST_ERROR_OBJECT (camerasrc, "return GST_FLOW_ERROR"); + /* should stop capture; */ + /*retrun EOS*/ + *buffer = NULL; + gst_camerasrc_error_handler(camerasrc, ret); + + return GST_FLOW_ERROR; + } + } + + /* Get screennail buffer */ + scrnl_buf.start = NULL; + scrnl_buf.length = 0; + camerasrc_get_screennail_buffer(camerasrc->v4l2_handle, &scrnl_buf); + + GST_INFO_OBJECT(camerasrc, "main(%p,%d), thumb(%p,%d), scrnl(%p,%d)", + main_buf.start, main_buf.length, + thumb_buf.start, thumb_buf.length, + scrnl_buf.start, scrnl_buf.length); + +CHECK_CAPTURE_INTERVAL: + /* get shot time */ + cur_time = gst_get_current_time(); + + if (camerasrc->cap_next_time == 0UL) { + camerasrc->cap_next_time = cur_time; + } + + if (camerasrc->cap_count_reverse > 0 && camerasrc->cap_next_time <= cur_time) { + GST_INFO_OBJECT(camerasrc, "CHECK: reverse capture count: %d, next time:%lu current time:%lu", + camerasrc->cap_count_reverse, camerasrc->cap_next_time, cur_time); + + camerasrc->cap_next_time = cur_time + camerasrc->cap_interval; + camerasrc->cap_count_reverse--; + camerasrc->cap_count_current++; + + /* alloc buffer for capture callback */ + buf_cap_signal1 = gst_buffer_new (); + + /* make buffers for capture callback and display(raw format) */ + if (is_jpeg) { + GST_INFO_OBJECT (camerasrc, "JPEG CAPTURE MODE"); + + GST_BUFFER_DATA(buf_cap_signal1) = main_buf.start; + GST_BUFFER_SIZE(buf_cap_signal1) = main_buf.length; + GST_BUFFER_CAPS(buf_cap_signal1) = gst_caps_new_simple("image/jpeg", + "width", G_TYPE_INT, camerasrc->cap_width, + "height", G_TYPE_INT, camerasrc->cap_height, + NULL); + + if (thumb_buf.start) { + buf_cap_signal2 = gst_buffer_new(); + GST_BUFFER_DATA(buf_cap_signal2) = thumb_buf.start; + GST_BUFFER_SIZE(buf_cap_signal2) = thumb_buf.length; + GST_BUFFER_CAPS(buf_cap_signal2) = gst_caps_new_simple("image/jpeg", + "width", G_TYPE_INT, _THUMBNAIL_WIDTH, + "height", G_TYPE_INT, _THUMBNAIL_HEIGHT, + NULL); + } else { + buf_cap_signal2 = NULL; + } + + if (scrnl_buf.start && scrnl_buf.length > 0) { + buf_cap_signal3 = gst_buffer_new(); + GST_BUFFER_DATA(buf_cap_signal3) = scrnl_buf.start; + GST_BUFFER_SIZE(buf_cap_signal3) = scrnl_buf.length; + GST_BUFFER_CAPS(buf_cap_signal3) = gst_caps_new_simple("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, _DEFAULT_SCRNL_FOURCC, + "width", G_TYPE_INT, camerasrc->width, + "height", G_TYPE_INT, camerasrc->height, + NULL); + } else { + buf_cap_signal3 = NULL; + } + + *buffer = NULL; + } else { + unsigned char *pMetaData = NULL; + + GST_INFO_OBJECT (camerasrc, "RAW CAPTURE MODE"); + + /*alloc main buffer*/ + buf = gst_camerasrc_buffer_new(camerasrc);; + if (buf == NULL) { + GST_ERROR_OBJECT(camerasrc, "Buffer alloc failed."); + *buffer = NULL; + gst_camerasrc_error_handler(camerasrc, CAMERASRC_ERR_ALLOCATION); + return GST_FLOW_ERROR; + } + + pMetaData = gst_camerasrc_make_metadata_for_nonlinear_buffer(camerasrc, buffer_index); + if (!pMetaData) { + GST_ERROR_OBJECT(camerasrc, "Error on making metadata"); + } + + GST_BUFFER_MALLOCDATA(buf) = pMetaData; + buf->v4l2_buffer_index = buffer_index; + + if (camerasrc->cap_fourcc == GST_MAKE_FOURCC('I','4','2','0') || + camerasrc->cap_fourcc == GST_MAKE_FOURCC('S','4','2','0') || + camerasrc->cap_fourcc == GST_MAKE_FOURCC('N','V','1','2') || + camerasrc->cap_fourcc == GST_MAKE_FOURCC('S','N','1','2')) { + ret = _gst_camerasrc_get_normal_buffer(camerasrc, camerasrc->cap_fourcc, + main_buf.start, camerasrc->cap_width, camerasrc->cap_height, + &GST_BUFFER_DATA(buf), &GST_BUFFER_SIZE(buf)); + if (ret == FALSE) { + g_mutex_unlock( camerasrc->buffer_lock ); + return GST_FLOW_ERROR; + } + + buf->is_alloc_data = TRUE; + } else { + GST_BUFFER_DATA(buf) = main_buf.start; + GST_BUFFER_SIZE(buf) = main_buf.length; + } + + *buffer = (GstBuffer *)buf; + GST_INFO_OBJECT(camerasrc, "BUF for PREVIEW: addr %p size %d", + GST_BUFFER_DATA (buf), GST_BUFFER_SIZE (buf)); + + GST_BUFFER_DATA(buf_cap_signal1) = GST_BUFFER_DATA(buf); + GST_BUFFER_SIZE(buf_cap_signal1) = GST_BUFFER_SIZE(buf); + GST_BUFFER_CAPS(buf_cap_signal1) = gst_caps_new_simple("video/x-raw-yuv", + "format", GST_TYPE_FOURCC, camerasrc->cap_fourcc, + "width", G_TYPE_INT, camerasrc->cap_width, + "height", G_TYPE_INT, camerasrc->cap_height, + NULL); + buf_cap_signal2 = NULL; + buf_cap_signal3 = NULL; + } + + /*call signal*/ + GST_INFO_OBJECT (camerasrc, "CALL: capture callback"); + + g_signal_emit( G_OBJECT (camerasrc), + gst_camerasrc_signals[SIGNAL_STILL_CAPTURE], + 0, + buf_cap_signal1, + buf_cap_signal2, + buf_cap_signal3 ); + + GST_INFO_OBJECT (camerasrc, "RETURN: capture callback"); + + if (is_jpeg || + (!is_jpeg && (camerasrc->fourcc != camerasrc->cap_fourcc || + camerasrc->width != camerasrc->cap_width || + camerasrc->height != camerasrc->cap_height))) { + /* Queue buffer */ + camerasrc_queue_buffer(camerasrc->v4l2_handle, buffer_index, &main_buf); + + /* release buffer */ + if (*buffer) { + gst_buffer_unref(*buffer); + *buffer = NULL; + } + } else { + camerasrc->num_live_buffers++; + /*escape loop for passing buffer to videosink*/ + break; + } + } else { + if (camerasrc->cap_next_time < cur_time + _CONTINUOUS_SHOT_MARGIN) { + GST_DEBUG_OBJECT(camerasrc, "check again time"); + usleep((camerasrc->cap_next_time - cur_time) * 1000); + goto CHECK_CAPTURE_INTERVAL; + } + + /* RAW capture buffer should be reach here */ + camerasrc_queue_buffer(camerasrc->v4l2_handle, buffer_index, &main_buf); + + /* Skip passing this buffer */ + *buffer = NULL; + + GST_DEBUG_OBJECT(camerasrc, "Skip pssing this buffer"); + break; + } + } + + GST_DEBUG_OBJECT (camerasrc, "LEAVED"); + + return GST_FLOW_OK; +} + + +static GstFlowReturn gst_camerasrc_read(GstCameraSrc *camerasrc, GstBuffer **buffer) +{ + int err = 0; + int command = GST_CAMERA_CONTROL_CAPTURE_COMMAND_NONE; + GstFlowReturn ret = GST_FLOW_OK; + camerasrc_state_t state = CAMERASRC_STATE_NONE; + + g_mutex_lock(camerasrc->mutex); + + if (!g_queue_is_empty(camerasrc->command_list)) { + command = (int)g_queue_pop_head(camerasrc->command_list); + GST_INFO_OBJECT(camerasrc, "popped cmd : %d", command); + } + + /* Normal Capture Routine */ + if (command == GST_CAMERA_CONTROL_CAPTURE_COMMAND_START) { + MMTA_ACUM_ITEM_BEGIN(" Shot to Shot in gstcamerasrc", FALSE); + __ta__(" gst_camerasrc_capture_start", + gst_camerasrc_capture_start(camerasrc); + ); + } + + g_mutex_unlock(camerasrc->mutex); + + switch (camerasrc->mode) { + case VIDEO_IN_MODE_PREVIEW: + case VIDEO_IN_MODE_VIDEO: + if (camerasrc->use_pad_alloc == TRUE) { + err = camerasrc_get_state(camerasrc->v4l2_handle, &state); + + if (state == CAMERASRC_STATE_READY) { + GST_INFO_OBJECT (camerasrc,"Prepare buffer"); + ret = gst_camerasrc_prepare_preview(camerasrc, camerasrc->num_alloc_buf); + } + } + + if (camerasrc->use_pad_alloc == TRUE) { + __ta__(" gst_camerasrc_read_preview_pad_alloc", + ret = gst_camerasrc_read_preview_pad_alloc(camerasrc, buffer); + ); + } else { + __ta__(" gst_camerasrc_read_preview_mmap", + ret = gst_camerasrc_read_preview_mmap(camerasrc, buffer); + ) + } + break; + case VIDEO_IN_MODE_CAPTURE: + __ta__( " gst_camerasrc_read_capture", + ret = gst_camerasrc_read_capture(camerasrc, buffer, command); + ); + break; + case VIDEO_IN_MODE_UNKNOWN: + default: + ret = GST_FLOW_ERROR; + GST_ERROR_OBJECT (camerasrc, "can't reach statement.[camerasrc->mode=%d]", camerasrc->mode); + break; + } + + if (!buffer || !(*buffer) || !GST_IS_BUFFER(*buffer)) { + /* To avoid seg fault, make dummy buffer. */ + GST_WARNING_OBJECT (camerasrc, "Make a dummy buffer"); + *buffer = gst_buffer_new(); + GST_BUFFER_DATA(*buffer) = NULL; + GST_BUFFER_SIZE(*buffer) = 0; + } + + return ret; +} + + +/* Buffer related functions */ +static void gst_camerasrc_buffer_pad_alloc_qbuf(GstCameraBuffer *buffer) +{ + int ret = 0; + gint index = 0; + GstCaps *negotiated_caps = NULL; + GstBuffer *queue_buf = NULL; + GstCameraSrc *camerasrc = NULL; + camerasrc_buffer_t camerasrc_buffer; + + if (buffer) { + camerasrc = buffer->camerasrc; + } else { + GST_ERROR("buffer is NULL"); + return; + } + + if (camerasrc) { + negotiated_caps = gst_pad_get_negotiated_caps(GST_BASE_SRC_PAD(camerasrc)); + } else { + GST_ERROR("camerasrc is NULL"); + return; + } + + index = buffer->v4l2_buffer_index; + + GST_LOG_OBJECT(camerasrc, "pad alloc qbuf"); + + ret = gst_pad_alloc_buffer(GST_BASE_SRC_PAD (camerasrc), + 0, + camerasrc->main_buf_sz, + negotiated_caps, + &queue_buf); + if (!GST_IS_BUFFER(queue_buf)) { + GST_INFO_OBJECT (camerasrc, "[DEBUG] NOT BUFFER!!?"); + } + + if (ret != GST_FLOW_OK) { + GST_ERROR_OBJECT(camerasrc, "gst_pad_alloc_buffer failed. [%d]", ret); + return; + } else { + GST_LOG_OBJECT(camerasrc, "Alloced Size = %dAlloced address : %p", + GST_BUFFER_SIZE(GST_BUFFER(queue_buf)), GST_BUFFER_DATA(GST_BUFFER(queue_buf))); + } + + gst_caps_unref(negotiated_caps); + negotiated_caps = NULL; + + camerasrc_buffer.start = GST_BUFFER_DATA(GST_BUFFER(queue_buf)); + camerasrc_buffer.length = GST_BUFFER_SIZE(GST_BUFFER(queue_buf)); + ret = camerasrc_queue_buffer(camerasrc->v4l2_handle, index, &camerasrc_buffer); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "QBUF error, [%x]", ret); + return; + } else { + GST_LOG_OBJECT (camerasrc, "QBUF : [idx=%d]", index); + } + + return; +} + + +static void gst_camerasrc_buffer_mmap_qbuf(GstCameraBuffer *buffer) +{ + int ret = 0; + gint index = 0; + GstCameraSrc *camerasrc = NULL; + camerasrc_buffer_t camerasrc_buffer; + + camerasrc = buffer->camerasrc; + index = buffer->v4l2_buffer_index; + + ret = camerasrc_queue_buffer(camerasrc->v4l2_handle, index, &camerasrc_buffer); + if (ret != CAMERASRC_SUCCESS) { + GST_ERROR_OBJECT(camerasrc, "QBUF error, [%x]", ret); + } else { + GST_LOG_OBJECT(camerasrc, "QBUF : [idx=%d]", index); + } + + return; +} + +static void gst_camerasrc_buffer_finalize(GstCameraBuffer *buffer) +{ + gint index = 0; + GstCameraSrc *camerasrc = NULL; + + camerasrc = buffer->camerasrc; + index = buffer->v4l2_buffer_index; + + GST_LOG_OBJECT(camerasrc, "finalizing buffer %p, %d [%" + GST_TIME_FORMAT " dur %" GST_TIME_FORMAT "]", buffer, index, + GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)), + GST_TIME_ARGS(GST_BUFFER_DURATION(buffer))); + + if (camerasrc->buffer_running) { + /* Buffer Q again */ + if (camerasrc->use_pad_alloc == TRUE){ + gst_camerasrc_buffer_pad_alloc_qbuf(buffer); + } else { + gst_camerasrc_buffer_mmap_qbuf(buffer); + } + } else { + GST_INFO_OBJECT(camerasrc, "It is not running. skip QBUF"); + } + + camerasrc->num_live_buffers--; + g_cond_signal(camerasrc->buffer_cond); + GST_LOG_OBJECT(camerasrc, "QBUF : [idx=%d, lvn=%d]", index, camerasrc->num_live_buffers); + + if (buffer->is_alloc_data) { + GST_DEBUG("free allocated data %p", GST_BUFFER_DATA(buffer)); + if (GST_BUFFER_DATA(buffer)) { + free(GST_BUFFER_DATA(buffer)); + GST_BUFFER_DATA(buffer) = NULL; + } + + buffer->is_alloc_data = FALSE; + } + + if (GST_BUFFER_MALLOCDATA(buffer)) { + free(GST_BUFFER_MALLOCDATA(buffer)); + GST_BUFFER_MALLOCDATA(buffer) = NULL; + } + + gst_object_unref(camerasrc); + + if (GST_MINI_OBJECT_CLASS (camera_buffer_parent_class)->finalize) { + GST_MINI_OBJECT_CLASS (camera_buffer_parent_class)->finalize (GST_MINI_OBJECT(buffer)); + } + + return; +} + + +static void gst_camerasrc_buffer_class_init(gpointer g_class, gpointer class_data) +{ + GstMiniObjectClass *mini_object_class = GST_MINI_OBJECT_CLASS(g_class); + + camera_buffer_parent_class = g_type_class_peek_parent(g_class); + mini_object_class->finalize = (GstMiniObjectFinalizeFunction)gst_camerasrc_buffer_finalize; +} + + +static GType gst_camerasrc_buffer_get_type(void) +{ + static GType _gst_camerasrc_buffer_type; + + if (G_UNLIKELY(_gst_camerasrc_buffer_type == 0)) { + static const GTypeInfo camera_buffer_info = { + sizeof (GstBufferClass), + NULL, + NULL, + gst_camerasrc_buffer_class_init, + NULL, + NULL, + sizeof (GstCameraBuffer), + 0, + NULL, + NULL + }; + + _gst_camerasrc_buffer_type = g_type_register_static(GST_TYPE_BUFFER, + "GstCameraBuffer", + &camera_buffer_info, 0); + } + + return _gst_camerasrc_buffer_type; +} + + +static GstCameraBuffer *gst_camerasrc_buffer_new(GstCameraSrc *camerasrc) +{ + GstCameraBuffer *ret = NULL; + + ret = (GstCameraBuffer *)gst_mini_object_new(GST_TYPE_CAMERASRC_BUFFER); + + GST_LOG_OBJECT(camerasrc, "creating buffer : %p", ret); + + ret->camerasrc = gst_object_ref(GST_OBJECT(camerasrc)); + ret->is_alloc_data = FALSE; + + return ret; +} + + +static void gst_camerasrc_buffer_free(gpointer data) +{ + GST_CAMERASRC_BUFFER_DATA *buffer_data = (GST_CAMERASRC_BUFFER_DATA *)data; + + GST_LOG_OBJECT(buffer_data->camerasrc, "freeing buffer with %p %d", + buffer_data->camerasrc, buffer_data->index); + + g_mutex_lock(buffer_data->camerasrc->pad_alloc_mutex); + + if (buffer_data->buffer_data_index == buffer_data->camerasrc->current_buffer_data_index) { + GST_LOG_OBJECT(buffer_data->camerasrc, "Push index [%d] to pad_alloc_list", buffer_data->index); + g_queue_push_tail(buffer_data->camerasrc->pad_alloc_list, (gpointer)buffer_data->index); + } else { + GST_WARNING_OBJECT(buffer_data->camerasrc, "Skip Pushing index [%d] to pad_alloc_list.", buffer_data->index ); + GST_WARNING_OBJECT(buffer_data->camerasrc, "buffer_data_index [%d], current_buffer_data_index [%d]", + buffer_data->buffer_data_index, + buffer_data->camerasrc->current_buffer_data_index); + } + + buffer_data->camerasrc->num_live_buffers--; + + g_mutex_unlock(buffer_data->camerasrc->pad_alloc_mutex); + g_cond_signal(buffer_data->camerasrc->buffer_cond); + + buffer_data->camerasrc = NULL; + buffer_data->index = -1; + + /* Free data argument */ + g_free(data); + + return; +} + + +static void gst_camerasrc_buffer_trace(GstCameraSrc *camerasrc) +{ + int i = 0; + GstBuffer *buf = NULL; + + if (!camerasrc) { + GST_ERROR_OBJECT(camerasrc, "Element is NULL"); + return; + } + + for (i = 0 ; i < camerasrc->num_alloc_buf ; i ++) { + buf = camerasrc->usr_buffer[i]; + if (GST_IS_BUFFER(buf)) { + GST_ELEMENT_WARNING(camerasrc, RESOURCE, FAILED, + NULL, (("Chainfunc of buf[%d]=%s()"), i, + GST_DEBUG_FUNCPTR_NAME(buf->_gst_reserved[0]))); + } else { + GST_ELEMENT_WARNING(camerasrc, RESOURCE, FAILED, + NULL, (("buf[%d] is not GstBuffer"), i)); + } + } + + return; +} + + +static unsigned char *gst_camerasrc_make_metadata_for_nonlinear_buffer(GstCameraSrc *camerasrc, guint32 index) +{ + unsigned char *meta_string = NULL; + camerasrc_frame_data_t data; + SCMN_IMGB *psimgb = NULL; + + /*GST_LOG_OBJECT (camerasrc, "index[%d],pix_format[%x]", index, camerasrc->fourcc);*/ + + psimgb = (SCMN_IMGB *)malloc(sizeof(SCMN_IMGB)); + if (psimgb == NULL) { + GST_ERROR_OBJECT(camerasrc, "failed to alloc SCMN_IMGB"); + return NULL; + } + + memset(psimgb, 0x00, sizeof(SCMN_IMGB)); + + data.index = index; + camerasrc_get_frame_data(camerasrc->v4l2_handle, &data); + + psimgb->p[0] = (void *)data.phyAddrY; + psimgb->a[0] = (void *)data.virAddrY; + psimgb->p[1] = (void *)data.phyAddrCbCr; + psimgb->a[1] = (void *)data.virAddrCbCr; + + psimgb->w[0] = camerasrc->width; + psimgb->h[0] = camerasrc->height; + + if (camerasrc->fourcc == GST_MAKE_FOURCC('S','T','1','2')) { + psimgb->cs = SCMN_CS_NV12; + psimgb->w[1] = camerasrc->width; + psimgb->h[1] = camerasrc->height >> 1; + + psimgb->s[0] = GST_ROUND_UP_16(psimgb->w[0]); + psimgb->e[0] = GST_ROUND_UP_16(psimgb->h[0]); + psimgb->s[1] = GST_ROUND_UP_16(psimgb->w[1]); + psimgb->e[1] = GST_ROUND_UP_16(psimgb->h[1]); + } else { + if (camerasrc->fourcc == GST_MAKE_FOURCC('S','N','1','2')) { + psimgb->cs = SCMN_CS_NV12_T64X32; + psimgb->w[1] = camerasrc->width; + psimgb->h[1] = camerasrc->height >> 1; + } else if (camerasrc->fourcc == GST_MAKE_FOURCC('S','U','Y','V')) { + psimgb->cs = SCMN_CS_YUYV; + } else if (camerasrc->fourcc == GST_MAKE_FOURCC('S','U','Y','2')) { + psimgb->cs = SCMN_CS_YUY2; + } else if (camerasrc->fourcc == GST_MAKE_FOURCC('S','Y','V','Y')) { + psimgb->cs = SCMN_CS_UYVY; + } else if (camerasrc->fourcc == GST_MAKE_FOURCC('S','4','2','0')) { + guint offset = 0; + + psimgb->cs = SCMN_CS_I420; + offset = CAMERASRC_ALIGN(camerasrc->width * camerasrc->height >> 2, ALIGN_SIZE_I420); + psimgb->p[2] = (void *)(data.phyAddrCbCr + offset); + psimgb->a[2] = (void *)(data.virAddrCbCr + offset); + + psimgb->w[1] = psimgb->w[2] = camerasrc->width; + psimgb->h[1] = psimgb->h[2] = camerasrc->height >> 2; + } else { + GST_WARNING_OBJECT (camerasrc, "Unknown pixel format."); + } + + psimgb->s[0] = psimgb->w[0]; + psimgb->e[0] = psimgb->h[0]; + psimgb->s[1] = psimgb->w[1]; + psimgb->e[1] = psimgb->h[1]; + psimgb->s[2] = psimgb->w[2]; + psimgb->e[2] = psimgb->h[2]; + } + + /*GST_LOG_OBJECT(camerasrc, "index[%d],Plane0[%p],Plane1[%p],Plane2[%p]", + index, psimgb->p[0], psimgb->p[1], psimgb->p[2]);*/ + meta_string = (unsigned char*)psimgb; + + return meta_string; +} + + +static gboolean gst_camerasrc_device_is_open(GstCameraSrc *camerasrc) +{ + return camerasrc_device_is_open((camsrc_handle_t)camerasrc->v4l2_handle); +} + + +static gboolean gst_camerasrc_get_timeinfo(GstCameraSrc *camerasrc, GstBuffer *buffer) +{ + int fps_nu = 0; + int fps_de = 0; + GstClock *clock = NULL; + GstClockTime timestamp = GST_CLOCK_TIME_NONE; + GstClockTime duration = GST_CLOCK_TIME_NONE; + + if (!camerasrc || !buffer) { + GST_WARNING_OBJECT (camerasrc, "Invalid pointer [hadle:%p, buffer:%p]", camerasrc, buffer); + return FALSE; + } + + /* timestamps, LOCK to get clock and base time. */ + clock = GST_ELEMENT_CLOCK(camerasrc); + if (clock) { + /* the time now is the time of the clock minus the base time */ + gst_object_ref(clock); + timestamp = gst_clock_get_time(clock) - GST_ELEMENT(camerasrc)->base_time; + gst_object_unref(clock); + + /* if we have a framerate adjust timestamp for frame latency */ + if (camerasrc->fps_auto) { + /*if fps is zero, auto fps mode*/ + duration = GST_CLOCK_TIME_NONE; + } else { + if (camerasrc->fps <= 0) { + /*if fps is zero, auto fps mode*/ + fps_nu = 0; + fps_de = 1; + } else { + fps_nu = 1; + fps_de = camerasrc->fps; + } + + if (fps_nu > 0 && fps_de > 0) { + GstClockTime latency; + + latency = gst_util_uint64_scale_int(GST_SECOND, fps_nu, fps_de); + duration = latency; + } + } + } else { + /* no clock, can't set timestamps */ + timestamp = GST_CLOCK_TIME_NONE; + } + + GST_BUFFER_TIMESTAMP(buffer) = timestamp; + GST_BUFFER_DURATION(buffer) = duration; +/* + GST_INFO_OBJECT(camerasrc, "[%"GST_TIME_FORMAT" dur %" GST_TIME_FORMAT "]", + GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)), + GST_TIME_ARGS(GST_BUFFER_DURATION(buffer))); +*/ + + return TRUE; +} + + +static int get_proper_index(GstCameraSrc *camerasrc, GstBuffer *pad_alloc_buffer) +{ + int temp_idx = 0; + + while (GST_BUFFER_DATA(GST_BUFFER(pad_alloc_buffer)) != g_present_buf.present_buffer[temp_idx++].start) { + if (temp_idx >= camerasrc->num_alloc_buf) { + return -1; + } + } + + return temp_idx - 1; /* -1 is caused that it already increased in ++ */ +} + + +/* Gstreamer general functions */ +static gboolean gst_camerasrc_src_start(GstBaseSrc *src) +{ + int ret = TRUE; + GstCameraSrc *camerasrc = GST_CAMERA_SRC (src); + + GST_DEBUG_OBJECT(camerasrc, "ENTERED"); + +#if _ENABLE_CAMERASRC_DEBUG + g_preview_frame_cnt = 0; +#endif + + camerasrc->firsttime = TRUE; + /* 'gst_camerasrc_set_caps' will call gst_camerasrc_start(). So skip to call it. */ + /*ret = gst_camerasrc_start(camerasrc);*/ + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return ret; +} + + +static gboolean gst_camerasrc_src_stop(GstBaseSrc *src) +{ + int ret = 0; + GstCameraSrc *camerasrc = GST_CAMERA_SRC(src); + + GST_DEBUG_OBJECT (camerasrc, "ENTERED"); + + ret = gst_camerasrc_stop(camerasrc); + + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return TRUE; +} + + +static GstFlowReturn gst_camerasrc_src_create(GstPushSrc *src, GstBuffer **buffer) +{ + GstCameraSrc *camerasrc = GST_CAMERA_SRC (src); + GstFlowReturn ret; + + /*GST_DEBUG_OBJECT(camerasrc, "ENTERED");*/ + + if (camerasrc->req_negotiation) { + GST_INFO_OBJECT(camerasrc, "negotiation start"); + + GST_BASE_SRC_GET_CLASS(camerasrc)->negotiate(GST_BASE_SRC(camerasrc)); + camerasrc->req_negotiation = FALSE; + g_signal_emit(G_OBJECT(camerasrc), gst_camerasrc_signals[SIGNAL_NEGO_COMPLETE], (GQuark)NULL); + + GST_INFO_OBJECT (camerasrc, "negotiation stop"); + } + + __ta__(" gst_camerasrc_read", + ret = gst_camerasrc_read(camerasrc, buffer); + ) + /*GST_DEBUG_OBJECT (camerasrc, "LEAVED");*/ + + return ret; +} + + +static void gst_camerasrc_set_property(GObject *object, guint prop_id, + const GValue *value, GParamSpec *pspec) +{ + int tmp = 0; + GstCameraSrc *camerasrc = NULL; + + g_return_if_fail(GST_IS_CAMERA_SRC(object)); + camerasrc = GST_CAMERA_SRC(object); + + switch (prop_id) { + case ARG_REQ_NEGOTIATION: + camerasrc->req_negotiation = g_value_get_boolean(value); + break; + case ARG_CAMERA_HIGH_SPEED_FPS: + tmp = g_value_get_int(value); + camerasrc->high_speed_fps = tmp; + break; + case ARG_CAMERA_AUTO_FPS: + camerasrc->fps_auto = g_value_get_boolean(value); + GST_DEBUG_OBJECT(camerasrc, "Set AUTO_FPS:%d", camerasrc->fps_auto); + break; + case ARG_CAMERA_ID: + camerasrc->camera_id = g_value_get_int(value); + break; + case ARG_CAMERA_EXT_VIDEO_FD: + camerasrc->external_videofd = g_value_get_int(value); + break; + case ARG_CAMERA_CAPTURE_FOURCC: + camerasrc->cap_fourcc = g_value_get_uint(value); + break; + case ARG_CAMERA_CAPTURE_QUALITY: + camerasrc->cap_quality = g_value_get_enum(value); + break; + case ARG_CAMERA_CAPTURE_WIDTH: + camerasrc->cap_width = g_value_get_int(value); + break; + case ARG_CAMERA_CAPTURE_HEIGHT: + camerasrc->cap_height = g_value_get_int(value); + break; + case ARG_CAMERA_CAPTURE_INTERVAL: + camerasrc->cap_interval = g_value_get_int(value); + break; + case ARG_CAMERA_CAPTURE_COUNT: + tmp = g_value_get_int(value); + camerasrc->cap_count = tmp; + g_mutex_lock(camerasrc->jpg_mutex); + camerasrc->cap_count_reverse = tmp; + g_mutex_unlock(camerasrc->jpg_mutex); + GST_INFO("SET reverse capture count: %d", camerasrc->cap_count_reverse); + break; + case ARG_CAMERA_CAPTURE_JPG_QUALITY: + camerasrc->cap_jpg_quality = g_value_get_int(value); + GST_INFO("SET jpeg compress ratio : %d", camerasrc->cap_jpg_quality); + break; + case ARG_SIGNAL_STILLCAPTURE: + camerasrc->signal_still_capture = g_value_get_boolean(value); + break; + case ARG_USE_PAD_ALLOC: + camerasrc->use_pad_alloc = g_value_get_boolean(value); + break; + case ARG_NUM_ALLOC_BUF: + camerasrc->num_alloc_buf = g_value_get_int(value); + break; + case ARG_HOLD_AF_AFTER_CAPTURE: + camerasrc->hold_af_after_capturing = g_value_get_boolean(value); + camerasrc_set_af_hold_after_capture(camerasrc->v4l2_handle, (int)camerasrc->hold_af_after_capturing); + break; + case ARG_SENSOR_MODE: + camerasrc->sensor_mode = g_value_get_int(value); + break; + case ARG_VFLIP: + camerasrc->vflip = g_value_get_boolean(value); + break; + case ARG_HFLIP: + camerasrc->hflip = g_value_get_boolean(value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + break; + } +} + + +static void gst_camerasrc_get_property(GObject *object, guint prop_id, + GValue *value, GParamSpec *pspec) +{ + GstCameraSrc *camerasrc; + + g_return_if_fail(GST_IS_CAMERA_SRC(object)); + camerasrc = GST_CAMERA_SRC(object); + + switch (prop_id) { + case ARG_REQ_NEGOTIATION: + g_value_set_boolean(value, camerasrc->req_negotiation); + break; + case ARG_CAMERA_HIGH_SPEED_FPS: + g_value_set_int(value, camerasrc->high_speed_fps); + break; + case ARG_CAMERA_AUTO_FPS: + g_value_set_boolean(value, camerasrc->fps_auto); + break; + case ARG_CAMERA_ID: + g_value_set_int(value, camerasrc->camera_id); + break; + case ARG_CAMERA_EXT_VIDEO_FD: + g_value_set_int(value, camerasrc->external_videofd); + break; + case ARG_CAMERA_CAPTURE_FOURCC: + g_value_set_uint(value, camerasrc->cap_fourcc); + break; + case ARG_CAMERA_CAPTURE_QUALITY: + g_value_set_enum(value, camerasrc->cap_quality); + break; + case ARG_CAMERA_CAPTURE_WIDTH: + g_value_set_int(value, camerasrc->cap_width); + break; + case ARG_CAMERA_CAPTURE_HEIGHT: + g_value_set_int(value, camerasrc->cap_height); + break; + case ARG_CAMERA_CAPTURE_INTERVAL: + g_value_set_int(value, camerasrc->cap_interval); + break; + case ARG_CAMERA_CAPTURE_COUNT: + g_value_set_int(value, camerasrc->cap_count); + break; + case ARG_CAMERA_CAPTURE_JPG_QUALITY: + g_value_set_int(value, camerasrc->cap_jpg_quality); + GST_INFO("GET jpeg compress ratio : %d", camerasrc->cap_jpg_quality); + break; + case ARG_CAMERA_CAPTURE_PROVIDE_EXIF: + camerasrc_support_embed_exif(camerasrc->v4l2_handle, &(camerasrc->cap_provide_exif)); + g_value_set_boolean(value, camerasrc->cap_provide_exif); + GST_INFO("Is Exif provided? : %d", camerasrc->cap_provide_exif); + break; + case ARG_SIGNAL_STILLCAPTURE: + g_value_set_boolean(value, camerasrc->signal_still_capture); + break; + case ARG_USE_PAD_ALLOC: + g_value_set_boolean(value, camerasrc->use_pad_alloc); + break; + case ARG_NUM_ALLOC_BUF: + g_value_set_int(value, camerasrc->num_alloc_buf); + break; + case ARG_OPERATION_STATUS: + g_value_set_int(value, 0); + gst_camerasrc_buffer_trace(camerasrc); + break; + case ARG_HOLD_AF_AFTER_CAPTURE: + g_value_set_boolean(value, camerasrc->hold_af_after_capturing); + break; + case ARG_SENSOR_MODE: + g_value_set_int(value, camerasrc->sensor_mode); + break; + case ARG_VFLIP: + g_value_set_boolean(value, camerasrc->vflip); + break; + case ARG_HFLIP: + g_value_set_boolean(value, camerasrc->hflip); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); + break; + } +} + + +static GstStateChangeReturn gst_camerasrc_change_state(GstElement *element, GstStateChange transition) +{ + GstStateChangeReturn ret = GST_STATE_CHANGE_SUCCESS; + GstCameraSrc *camerasrc; + camerasrc = GST_CAMERA_SRC (element); + + switch (transition) { + case GST_STATE_CHANGE_NULL_TO_READY: + GST_INFO_OBJECT(camerasrc, "GST CAMERA SRC: NULL -> READY"); + __ta__(" gst_camerasrc_create", + if (!gst_camerasrc_create(camerasrc)){ + goto statechange_failed; + } + ); + break; + case GST_STATE_CHANGE_READY_TO_PAUSED: + GST_INFO_OBJECT(camerasrc, "GST CAMERA SRC: READY -> PAUSED"); + ret = GST_STATE_CHANGE_NO_PREROLL; + break; + case GST_STATE_CHANGE_PAUSED_TO_PLAYING: + GST_INFO_OBJECT(camerasrc, "GST CAMERA SRC: PAUSED -> PLAYING"); + break; + default: + break; + } + + ret = GST_ELEMENT_CLASS(parent_class)->change_state(element, transition); + if (ret == GST_STATE_CHANGE_FAILURE){ + return ret; + } + + switch (transition) { + case GST_STATE_CHANGE_PLAYING_TO_PAUSED: + GST_INFO_OBJECT(camerasrc, "GST CAMERA SRC: PLAYING -> PAUSED"); + ret = GST_STATE_CHANGE_NO_PREROLL; + break; + case GST_STATE_CHANGE_PAUSED_TO_READY: + GST_INFO_OBJECT(camerasrc, "GST CAMERA SRC: PAUSED -> READY"); + break; + case GST_STATE_CHANGE_READY_TO_NULL: + GST_INFO_OBJECT(camerasrc, "GST CAMERA SRC: READY -> NULL"); + __ta__(" gst_camerasrc_destroy", + if (!gst_camerasrc_destroy(camerasrc)){ + goto statechange_failed; + } + ); + break; + default: + break; + } + + return ret; + + statechange_failed: + /* subclass must post a meaningfull error message */ + GST_ERROR_OBJECT(camerasrc, "state change failed"); + + return GST_STATE_CHANGE_FAILURE; +} + + +static void gst_camerasrc_finalize(GObject *object) +{ + GstCameraSrc *camerasrc = GST_CAMERA_SRC(object); + +#if _ENABLE_CAMERASRC_DEBUG + GST_INFO_OBJECT(camerasrc, "total [%u] preview frame(s) outputed.",g_preview_frame_cnt); +#endif + + g_mutex_free(camerasrc->jpg_mutex); + g_mutex_free(camerasrc->mutex); + g_cond_free(camerasrc->cond); + g_mutex_free(camerasrc->buffer_lock); + g_cond_broadcast(camerasrc->buffer_cond); + g_cond_free(camerasrc->buffer_cond); + + if (camerasrc->command_list != NULL) { + g_queue_free(camerasrc->command_list); + camerasrc->command_list = NULL; + } + + G_OBJECT_CLASS(parent_class)->finalize(object); +} + + +void gst_camerasrc_set_capture_command(GstCameraSrc *camerasrc, GstCameraControlCaptureCommand cmd) +{ + gboolean is_zsl = FALSE; + + if (camerasrc == NULL) { + GST_ERROR_OBJECT(camerasrc, "camerasrc is NULL"); + return; + } + + GST_INFO_OBJECT(camerasrc, "ENTERED"); + + g_mutex_lock(camerasrc->mutex); + + /* Do not push command when ZSL mode */ + if (!is_zsl) { + g_queue_push_tail(camerasrc->command_list, (gpointer)cmd); + GST_INFO_OBJECT(camerasrc, "ACTION: Push capture command [%d] finished.", cmd); + } + + if (cmd == GST_CAMERA_CONTROL_CAPTURE_COMMAND_STOP) { + g_cond_signal(camerasrc->cond); + GST_INFO_OBJECT(camerasrc, "Send signal for CAPTURE STOP"); + } + + g_mutex_unlock(camerasrc->mutex); + + return; +} + + +static gboolean gst_camerasrc_negotiate (GstBaseSrc * basesrc) +{ + GstCaps *thiscaps; + GstCaps *caps = NULL; + GstCaps *peercaps = NULL; + gboolean result = FALSE; + GstStructure *s; + GstCameraSrc *camerasrc = GST_CAMERA_SRC(basesrc); + + GST_INFO_OBJECT(camerasrc, "ENTERED"); + /* first see what is possible on our source pad */ + thiscaps = gst_pad_get_caps (GST_BASE_SRC_PAD (basesrc)); + GST_DEBUG_OBJECT (basesrc, "caps of src: %" GST_PTR_FORMAT, thiscaps); + + /* nothing or anything is allowed, we're done */ + if (thiscaps == NULL || gst_caps_is_any (thiscaps)) + goto no_nego_needed; + + /* get the peer caps */ + peercaps = gst_pad_peer_get_caps (GST_BASE_SRC_PAD (basesrc)); + GST_DEBUG_OBJECT (basesrc, "caps of peer: %" GST_PTR_FORMAT, peercaps); + //LOG_CAPS (basesrc, peercaps); + if (peercaps && !gst_caps_is_any (peercaps)) { + GstCaps *icaps = NULL; + int i; + + /* Prefer the first caps we are compatible with that the peer proposed */ + for (i = 0; i < gst_caps_get_size (peercaps); i++) { + /* get intersection */ + GstCaps *ipcaps = gst_caps_copy_nth (peercaps, i); + + icaps = gst_caps_intersect (thiscaps, ipcaps); + gst_caps_unref (ipcaps); + + if (!gst_caps_is_empty (icaps)) + break; + + gst_caps_unref (icaps); + icaps = NULL; + } + + GST_DEBUG_OBJECT (basesrc, "intersect: %" GST_PTR_FORMAT, icaps); + if (icaps) { + /* If there are multiple intersections pick the one with the smallest + * resolution strictly bigger than the first peer caps */ + if (gst_caps_get_size (icaps) > 1) { + s = gst_caps_get_structure (peercaps, 0); + int best = 0; + int twidth, theight; + int width = G_MAXINT, height = G_MAXINT; + + if (gst_structure_get_int (s, "width", &twidth) + && gst_structure_get_int (s, "height", &theight)) { + + /* Walk the structure backwards to get the first entry of the + * smallest resolution bigger (or equal to) the preferred resolution) + */ + for (i = gst_caps_get_size (icaps) - 1; i >= 0; i--) { + GstStructure *is = gst_caps_get_structure (icaps, i); + int w, h; + + if (gst_structure_get_int (is, "width", &w) + && gst_structure_get_int (is, "height", &h)) { + if (w >= twidth && w <= width && h >= theight && h <= height) { + width = w; + height = h; + best = i; + } + } + } + } + + caps = gst_caps_copy_nth (icaps, best); + gst_caps_unref (icaps); + } else { + caps = icaps; + } + } + gst_caps_unref (thiscaps); + gst_caps_unref (peercaps); + } else { + /* no peer or peer has ANY caps, work with our own caps then */ + caps = thiscaps; + } + if (caps) { + caps = gst_caps_make_writable (caps); + gst_caps_truncate (caps); + + /* now fixate */ + if (!gst_caps_is_empty (caps)) { + gst_pad_fixate_caps (GST_BASE_SRC_PAD (basesrc), caps); + GST_DEBUG_OBJECT (basesrc, "fixated to: %" GST_PTR_FORMAT, caps); + + if (gst_caps_is_any (caps)) { + /* hmm, still anything, so element can do anything and + * nego is not needed */ + result = TRUE; + } else if (gst_caps_is_fixed (caps)) { + /* yay, fixed caps, use those then */ + if (gst_pad_set_caps (GST_BASE_SRC_PAD (basesrc), caps)) + result = TRUE; + } + } + gst_caps_unref (caps); + } + return result; + +no_nego_needed: + { + GST_DEBUG_OBJECT (basesrc, "no negotiation needed"); + if (thiscaps) + gst_caps_unref (thiscaps); + return TRUE; + } +} + + +static GstCaps *gst_camerasrc_get_caps(GstBaseSrc *src) +{ + GstCameraSrc *camerasrc = GST_CAMERA_SRC(src); + GstCaps *ret = NULL; + + GST_DEBUG_OBJECT(camerasrc, "ENTERED"); + + if (camerasrc->mode == VIDEO_IN_MODE_UNKNOWN) { + GST_INFO_OBJECT(camerasrc, "Unknown mode. Just return template caps."); + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return gst_caps_copy(gst_pad_get_pad_template_caps(GST_BASE_SRC_PAD(camerasrc))); + } + + /*FIXME: Using "VIDIOC_ENUM_FMT".*/ + ret = gst_caps_copy(gst_pad_get_pad_template_caps(GST_BASE_SRC_PAD(camerasrc))); + + GST_INFO_OBJECT(camerasrc, "probed caps: %x", ret); + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + + return ret; +} + + +static gboolean _gst_camerasrc_get_raw_pixel_info(int fourcc, int *pix_format, int *colorspace) +{ + switch (fourcc) { + case GST_MAKE_FOURCC('I','4','2','0'): /* V4L2_PIX_FMT_YUV420 */ + case GST_MAKE_FOURCC('I','Y','U','V'): + case GST_MAKE_FOURCC('Y','U','1','2'): + case GST_MAKE_FOURCC('S','4','2','0'): + *pix_format = CAMERASRC_PIX_YUV420P; + *colorspace = CAMERASRC_COL_RAW; + break; + case GST_MAKE_FOURCC('Y','U','Y','V'): /* V4L2_PIX_FMT_YUYV */ + case GST_MAKE_FOURCC('Y','U','Y','2'): /* V4L2_PIX_FMT_YUYV */ + case GST_MAKE_FOURCC('S','U','Y','V'): + case GST_MAKE_FOURCC('S','U','Y','2'): + *pix_format = CAMERASRC_PIX_YUY2; + *colorspace = CAMERASRC_COL_RAW; + break; + case GST_MAKE_FOURCC('U','Y','V','Y'): /* V4L2_PIX_FMT_UYVY */ + case GST_MAKE_FOURCC('S','Y','V','Y'): /* V4L2_PIX_FMT_UYVY */ + *pix_format = CAMERASRC_PIX_UYVY; + *colorspace = CAMERASRC_COL_RAW; + break; + case GST_MAKE_FOURCC('4','2','2','P'): /* V4L2_PIX_FMT_YUV422P */ + case GST_MAKE_FOURCC('Y','4','2','B'): /* V4L2_PIX_FMT_YUV422P */ + *pix_format = CAMERASRC_PIX_YUV422P; + *colorspace = CAMERASRC_COL_RAW; + break; + case GST_MAKE_FOURCC('N','V','1','2'): /* V4L2_PIX_FMT_NV12 */ + *pix_format = CAMERASRC_PIX_NV12; + *colorspace = CAMERASRC_COL_RAW; + break; + case GST_MAKE_FOURCC('S','N','1','2'): /* V4L2_PIX_FMT_NV12 non-linear */ + *pix_format = CAMERASRC_PIX_SN12; + *colorspace = CAMERASRC_COL_RAW; + break; + case GST_MAKE_FOURCC('S','T','1','2'): /* V4L2_PIX_FMT_NV12 tiled non-linear */ + *pix_format = CAMERASRC_PIX_ST12; + *colorspace = CAMERASRC_COL_RAW; + break; + case GST_MAKE_FOURCC('J','P','E','G'): + case GST_MAKE_FOURCC('j','p','e','g'): + *pix_format = CAMERASRC_PIX_RGGB8; + *colorspace = CAMERASRC_COL_JPEG; + break; + case GST_MAKE_FOURCC('Y','4','1','P'): /* V4L2_PIX_FMT_Y41P */ + case GST_MAKE_FOURCC('N','V','2','1'): /* V4L2_PIX_FMT_NV21 */ + case GST_MAKE_FOURCC('Y','4','1','B'): /* V4L2_PIX_FMT_YUV411P */ + case GST_MAKE_FOURCC('Y','V','1','2'): /* V4L2_PIX_FMT_YVU420 */ + default: + /* ERROR */ + *pix_format = CAMERASRC_PIX_NONE; + *colorspace = CAMERASRC_COL_NONE; + break; + } + + return TRUE; +} + + +static gboolean _gst_camerasrc_get_frame_size(int fourcc, int width, int height, unsigned int *outsize) +{ + switch (fourcc) { + case GST_MAKE_FOURCC('I','4','2','0'): /* V4L2_PIX_FMT_YUV420 */ + case GST_MAKE_FOURCC('I','Y','U','V'): + case GST_MAKE_FOURCC('Y','U','1','2'): + case GST_MAKE_FOURCC('Y','V','1','2'): + case GST_MAKE_FOURCC('S','4','2','0'): /* V4L2_PIX_FMT_NV12 tiled non-linear */ + *outsize = GST_ROUND_UP_4 (width) * GST_ROUND_UP_2 (height); + *outsize += 2 * ((GST_ROUND_UP_8 (width) / 2) * (GST_ROUND_UP_2 (height) / 2)); + break; + case GST_MAKE_FOURCC('Y','U','Y','V'): /* V4L2_PIX_FMT_YUYV */ + case GST_MAKE_FOURCC('Y','U','Y','2'): /* V4L2_PIX_FMT_YUYV */ + case GST_MAKE_FOURCC('S','U','Y','V'): + case GST_MAKE_FOURCC('S','U','Y','2'): + case GST_MAKE_FOURCC('U','Y','V','Y'): /* V4L2_PIX_FMT_UYVY */ + case GST_MAKE_FOURCC('S','Y','V','Y'): /* V4L2_PIX_FMT_UYVY */ + case GST_MAKE_FOURCC('4','2','2','P'): /* V4L2_PIX_FMT_YUV422P */ + case GST_MAKE_FOURCC('Y','4','2','B'): /* V4L2_PIX_FMT_YUV422P */ + case GST_MAKE_FOURCC('Y','4','1','P'): /* V4L2_PIX_FMT_Y41P */ + *outsize = (GST_ROUND_UP_2 (width) * 2) * height; + break; + case GST_MAKE_FOURCC('Y','4','1','B'): /* V4L2_PIX_FMT_YUV411P */ + *outsize = GST_ROUND_UP_4 (width) * height; + *outsize += 2 * ((GST_ROUND_UP_8 (width) / 4) * height); + break; + case GST_MAKE_FOURCC('N','V','1','2'): /* V4L2_PIX_FMT_NV12 */ + case GST_MAKE_FOURCC('N','V','2','1'): /* V4L2_PIX_FMT_NV21 */ + case GST_MAKE_FOURCC('S','N','1','2'): /* V4L2_PIX_FMT_NV12 non-linear */ + case GST_MAKE_FOURCC('S','T','1','2'): /* V4L2_PIX_FMT_NV12 tiled non-linear */ + *outsize = GST_ROUND_UP_4 (width) * GST_ROUND_UP_2 (height); + *outsize += (GST_ROUND_UP_4 (width) * height) / 2; + break; + case GST_MAKE_FOURCC('J','P','E','G'): + case GST_MAKE_FOURCC('j','p','e','g'): + /* jpeg size can't be calculated here. */ + *outsize = 0; + break; + default: + /* unkown format!! */ + *outsize = 0; + break; + } + + return TRUE; +} + +static gboolean _gst_camerasrc_get_normal_buffer(GstCameraSrc *camerasrc, int fourcc, + unsigned char *base_buffer, int width, int height, + unsigned char **new_buffer, unsigned int *new_buffer_length) +{ + unsigned char *copy_data = NULL; + guint length_Y = 0; + + if (camerasrc == NULL || base_buffer == NULL || + new_buffer == NULL || new_buffer_length == NULL) { + GST_WARNING_OBJECT(camerasrc, "something is NULL(%p,%p,%p,%p)", + camerasrc, base_buffer, new_buffer, new_buffer_length); + return FALSE; + } + + switch (fourcc) { + case GST_MAKE_FOURCC('I','4','2','0'): + case GST_MAKE_FOURCC('S','4','2','0'): + { + guint length_Cb = 0; + guint length_Cr = 0; + guint offset_Cb = 0; + guint offset_Cr = 0; + + length_Y = width * height; + length_Cb = length_Cr = (width * height) >> 2; + + copy_data = (unsigned char*)malloc(length_Y + length_Cb + length_Cr); + if (copy_data == NULL) { + GST_ERROR_OBJECT(camerasrc, "New buffer data ALLOC FAILED"); + gst_camerasrc_error_handler(camerasrc, CAMERASRC_ERR_ALLOCATION); + return FALSE; + } + + offset_Cb = CAMERASRC_ALIGN(length_Y, ALIGN_SIZE_I420); + offset_Cr = offset_Cb + CAMERASRC_ALIGN(length_Cb, ALIGN_SIZE_I420); + + memcpy(copy_data, base_buffer, length_Y); + memcpy(copy_data + length_Y, base_buffer + offset_Cb, length_Cb); + memcpy(copy_data + length_Y + length_Cb, base_buffer + offset_Cr, length_Cr); + + *new_buffer = copy_data; + *new_buffer_length = length_Y + length_Cb + length_Cr; + + GST_DEBUG_OBJECT(camerasrc, "Total(0x%x), I420(S420) length Y(0x%x),Cb(0x%x),Cr(0x%x), offset Cb(0x%x),Cr(0x%x)", + *new_buffer_length, length_Y, length_Cb, length_Cr, offset_Cb, offset_Cr); + break; + } + case GST_MAKE_FOURCC('N','V','1','2'): + case GST_MAKE_FOURCC('S','N','1','2'): + { + guint length_CbCr = 0; + guint offset_CbCr = 0; + + length_Y = width * height; + length_CbCr = (width * height) >> 1; + + copy_data = (unsigned char*)malloc(length_Y + length_CbCr); + if (copy_data == NULL) { + GST_ERROR_OBJECT(camerasrc, "New buffer data ALLOC FAILED"); + gst_camerasrc_error_handler(camerasrc, CAMERASRC_ERR_ALLOCATION); + return FALSE; + } + + offset_CbCr = CAMERASRC_ALIGN(length_Y, ALIGN_SIZE_NV12); + + memcpy(copy_data, base_buffer, length_Y); + memcpy(copy_data + length_Y, base_buffer + offset_CbCr, length_CbCr); + + *new_buffer = copy_data; + *new_buffer_length = length_Y + length_CbCr; + + GST_DEBUG_OBJECT(camerasrc, "Total(0x%x), NV12(SN12) length Y(0x%x),CbCr(0x%x), offset CbCr(0x%x)", + *new_buffer_length, length_Y, length_CbCr, offset_CbCr); + break; + } + default: + { + char *pfourcc = (char*)&fourcc; + GST_WARNING_OBJECT(camerasrc, "Unknown fourcc(%c%c%c%c)", + pfourcc[0], pfourcc[1], pfourcc[2], pfourcc[3]); + *new_buffer = NULL; + *new_buffer_length = 0; + return FALSE; + } + } + + GST_DEBUG_OBJECT(camerasrc, "Done."); + + return TRUE; +} + + +static gboolean gst_camerasrc_get_caps_info(GstCameraSrc *camerasrc, GstCaps *caps, guint *size) +{ + gint fps_n = 0; + gint fps_d = 0; + gint w = 0; + gint h = 0; + gint rot = 0; + gchar *caps_string = NULL; + const gchar *mimetype; + const GValue *framerate; + GstStructure *structure = NULL; + + GST_INFO_OBJECT(camerasrc, "ENTERED Collect data for given caps.(caps:%x)", caps); + + structure = gst_caps_get_structure(caps, 0); + + if (!gst_structure_get_int(structure, "width", &w)) { + goto _caps_info_failed; + } + + if (!gst_structure_get_int(structure, "height", &h)) { + goto _caps_info_failed; + } + + if (!gst_structure_get_int(structure, "rotate", &rot)) { + GST_WARNING_OBJECT(camerasrc, "Failed to get rotate info in caps. set default 0."); + camerasrc->use_rotate_caps = FALSE; + } else { + GST_INFO_OBJECT(camerasrc, "Succeed to get rotate[%d] info in caps", rot); + camerasrc->use_rotate_caps = TRUE; + } + + /* set default size if there is no capsfilter */ + if (w == 1) { + w = _DEFAULT_WIDTH * 2; + } + + if (h == 1) { + h = _DEFAULT_HEIGHT * 2; + } + + camerasrc->width = w; + camerasrc->height = h; + camerasrc->rotate = rot; + + framerate = gst_structure_get_value(structure, "framerate"); + if (!framerate) { + GST_INFO("Set FPS as default"); + + /* set default fps if framerate is not existed in caps */ + fps_n = _DEFAULT_FPS; + fps_d = 1; + } else { + fps_n = gst_value_get_fraction_numerator(framerate); + fps_d = gst_value_get_fraction_denominator(framerate); + + /* numerator and denominator should be bigger than zero */ + if (fps_n <= 0) { + GST_WARNING("numerator of FPS is %d. make it default(15).", fps_n); + fps_n = _DEFAULT_FPS; + } + + if (fps_d <= 0) { + GST_WARNING("denominator of FPS is %d. make it 1.", fps_d); + fps_d = 1; + } + } + + camerasrc->fps = (int)((float)fps_n / (float)fps_d); + + mimetype = gst_structure_get_name (structure); + + *size = 0; + + if (!strcmp(mimetype, "video/x-raw-yuv")) { + gst_structure_get_fourcc(structure, "format", &camerasrc->fourcc); + if (camerasrc->fourcc == 0) { + GST_INFO_OBJECT(camerasrc, "Getting fourcc is zero."); + goto _caps_info_failed; + } + + _gst_camerasrc_get_frame_size(camerasrc->fourcc, w, h, size); + _gst_camerasrc_get_raw_pixel_info(camerasrc->fourcc, &(camerasrc->pix_format), &(camerasrc->colorspace)); + } else if (!strcmp (mimetype, "video/x-raw-rgb")) { + gint depth = 0; + gint endianness = 0; + gint r_mask = 0; + + gst_structure_get_int(structure, "depth", &depth); + gst_structure_get_int(structure, "endianness", &endianness); + gst_structure_get_int(structure, "red_mask", &r_mask); + + switch (depth) { + case 8: /* V4L2_PIX_FMT_RGB332 */ + camerasrc->pix_format = CAMERASRC_PIX_RGGB8; + camerasrc->colorspace = CAMERASRC_COL_RAW; + break; + case 15: /* V4L2_PIX_FMT_RGB555 : V4L2_PIX_FMT_RGB555X */ + camerasrc->pix_format = CAMERASRC_PIX_NONE; + camerasrc->colorspace = CAMERASRC_COL_NONE; + break; + case 16: /* V4L2_PIX_FMT_RGB565 : V4L2_PIX_FMT_RGB565X */ + camerasrc->pix_format = CAMERASRC_PIX_NONE; + camerasrc->colorspace = CAMERASRC_COL_NONE; + break; + case 24: /* V4L2_PIX_FMT_BGR24 : V4L2_PIX_FMT_RGB24 */ + camerasrc->pix_format = CAMERASRC_PIX_NONE; + camerasrc->colorspace = CAMERASRC_COL_NONE; + break; + case 32: /* V4L2_PIX_FMT_BGR32 : V4L2_PIX_FMT_RGB32 */ + camerasrc->pix_format = CAMERASRC_PIX_NONE; + camerasrc->colorspace = CAMERASRC_COL_NONE; + break; + } + } else if (strcmp(mimetype, "video/x-dv") == 0) { /* V4L2_PIX_FMT_DV */ + camerasrc->pix_format = CAMERASRC_PIX_NONE; + camerasrc->colorspace = CAMERASRC_COL_NONE; + } else if (strcmp(mimetype, "image/jpeg") == 0) { /* V4L2_PIX_FMT_JPEG */ + camerasrc->pix_format = CAMERASRC_PIX_RGGB8; /* default */ + camerasrc->colorspace = CAMERASRC_COL_JPEG; + } + + caps_string = gst_caps_to_string(caps); + GST_INFO_OBJECT(camerasrc, "pixformat %d, colorspace %d, size %d, caps : [%s]", + camerasrc->pix_format, camerasrc->colorspace, *size, caps_string); + if (caps_string) { + g_free(caps_string); + caps_string = NULL; + } + + return TRUE; + +_caps_info_failed: + GST_INFO_OBJECT(camerasrc, "Failed to get caps info."); + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + return FALSE; +} + + +static gboolean gst_camerasrc_set_caps(GstBaseSrc *src, GstCaps *caps) +{ + guint size; + GstCameraSrc *camerasrc = NULL; + + camerasrc = GST_CAMERA_SRC(src); + + GST_INFO_OBJECT(camerasrc, "ENTERED"); + + if (camerasrc->mode == VIDEO_IN_MODE_PREVIEW || + camerasrc->mode == VIDEO_IN_MODE_VIDEO) { + GST_INFO_OBJECT(camerasrc, "Proceed set_caps"); + __ta__(" gst_camerasrc_stop", + if (!gst_camerasrc_stop(camerasrc)) { + GST_INFO_OBJECT(camerasrc, "Cam sensor stop failed."); + } + ); + } else if (camerasrc->mode == VIDEO_IN_MODE_CAPTURE) { + GST_ERROR_OBJECT(camerasrc, "A mode of avsystem camera is capture. Not to proceed set_caps."); + GST_DEBUG_OBJECT(camerasrc, "LEAVED"); + return FALSE; + } else { + GST_INFO_OBJECT(camerasrc, "A mode of avsystem camera is unknown[%d]. Proceed set_caps.", camerasrc->mode); + } + + /* we want our own v4l2 type of fourcc codes */ + if (!gst_camerasrc_get_caps_info(camerasrc, caps, &size)) { + GST_INFO_OBJECT(camerasrc, "can't get capture information from caps %x", caps); + return FALSE; + } + + __ta__(" gst_camerasrc_start", + if (!gst_camerasrc_start(camerasrc)) { + GST_INFO_OBJECT (camerasrc, "Cam sensor start failed."); + } + ); + + GST_INFO_OBJECT (camerasrc, "LEAVED"); + + return TRUE; +} + + +static void gst_camerasrc_base_init(gpointer klass) +{ + GstElementClass *element_class = GST_ELEMENT_CLASS(klass); + + GST_DEBUG_CATEGORY_INIT(camerasrc_debug, "camerasrc", 0, "camerasrc element"); + + GST_INFO("ENTERED"); + + gst_element_class_add_pad_template(element_class, gst_static_pad_template_get (&src_factory)); + gst_element_class_set_details(element_class, &camerasrc_details); + + GST_INFO("LEAVED"); +} + + +static void gst_camerasrc_class_init(GstCameraSrcClass *klass) +{ + GObjectClass *gobject_class; + GstElementClass *element_class; + GstBaseSrcClass *basesrc_class; + GstPushSrcClass *pushsrc_class; + + GST_DEBUG("ENTERED"); + + gobject_class = G_OBJECT_CLASS(klass); + element_class = GST_ELEMENT_CLASS(klass); + basesrc_class = GST_BASE_SRC_CLASS(klass); + pushsrc_class = GST_PUSH_SRC_CLASS(klass); + + gobject_class->set_property = gst_camerasrc_set_property; + gobject_class->get_property = gst_camerasrc_get_property; + gobject_class->finalize = gst_camerasrc_finalize; + element_class->change_state = gst_camerasrc_change_state; + basesrc_class->start = gst_camerasrc_src_start; + basesrc_class->stop = gst_camerasrc_src_stop; + basesrc_class->get_caps = gst_camerasrc_get_caps; + basesrc_class->set_caps = gst_camerasrc_set_caps; + basesrc_class->negotiate = gst_camerasrc_negotiate; + pushsrc_class->create = gst_camerasrc_src_create; + + g_object_class_install_property(gobject_class, ARG_REQ_NEGOTIATION, + g_param_spec_boolean("req-negotiation", "Request re-negotiation", + "Request to negotiate while on playing", + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_HIGH_SPEED_FPS, + g_param_spec_int("high-speed-fps", "Fps for high speed recording", + "If this value is 0, the element doesn't activate high speed recording.", + 0, G_MAXINT, _DEFAULT_HIGH_SPEED_FPS, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_AUTO_FPS, + g_param_spec_boolean("fps-auto", "FPS Auto", + "Field for auto fps setting", + _DEFAULT_FPS_AUTO, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_EXT_VIDEO_FD, + g_param_spec_int("extern_videofd", "External video file descriptor", + "External video file descriptor", + _FD_MIN, _FD_MAX, _FD_MIN, + G_PARAM_READWRITE)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_ID, + g_param_spec_int("camera-id", "index number of camera to activate", + "index number of camera to activate", + _FD_MIN, _FD_MAX, 0, + G_PARAM_READWRITE)); + + /*Capture*/ + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_FOURCC, + g_param_spec_uint("capture-fourcc", "Capture format", + "Fourcc value for capture format", + 0, G_MAXUINT, 0, + G_PARAM_READWRITE)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_QUALITY, + g_param_spec_enum("capture-quality", "Capture quality", + "Quality of capture image (JPEG: 'high', RAW: 'high' or 'low')", + GST_TYPE_CAMERASRC_QUALITY, _DEFAULT_CAP_QUALITY, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_WIDTH, + g_param_spec_int("capture-width", "Capture width", + "Width for camera size to capture", + 0, G_MAXINT, _DEFAULT_CAP_WIDTH, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_HEIGHT, + g_param_spec_int("capture-height", "Capture height", + "Height for camera size to capture", + 0, G_MAXINT, _DEFAULT_CAP_HEIGHT, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_INTERVAL, + g_param_spec_int("capture-interval", "Capture interval", + "Interval time to capture (millisecond)", + 0, G_MAXINT, _DEFAULT_CAP_INTERVAL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_COUNT, + g_param_spec_int("capture-count", "Capture count", + "Capture conut for multishot", + 1, G_MAXINT, _DEFAULT_CAP_COUNT, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_JPG_QUALITY, + g_param_spec_int("capture-jpg-quality", "JPEG Capture compress ratio", + "Quality of capture image compress ratio", + 1, 100, _DEFAULT_CAP_JPG_QUALITY, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_CAMERA_CAPTURE_PROVIDE_EXIF, + g_param_spec_boolean("provide-exif", "Whether EXIF is provided", + "Does capture provide EXIF?", + _DEFAULT_CAP_PROVIDE_EXIF, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_SIGNAL_STILLCAPTURE, + g_param_spec_boolean("signal-still-capture", "Signal still capture", + "Send a signal before pushing the buffer", + _DEFAULT_SIGNAL_STILL_CAPTURE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_USE_PAD_ALLOC, + g_param_spec_boolean("use-pad-alloc", "Use pad alloc", + "Use gst_pad_alloc_buffer() for image frame buffer", + _DEFAULT_USE_PAD_ALLOC, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_NUM_ALLOC_BUF, + g_param_spec_int("num-alloc-buf", "Number alloced buffer", + "Number of buffer to alloc using gst_pad_alloc_buffer()", + 1, _MAX_NUM_ALLOC_BUF, _DEFAULT_NUM_ALLOC_BUF, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_OPERATION_STATUS, + g_param_spec_int("operation-status", "Check operation status of camerasrc", + "This value has bit flags that describe current operation status.", + G_MININT, G_MAXINT, 0, + G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_HOLD_AF_AFTER_CAPTURE, + g_param_spec_boolean("hold-af-after-capturing", "Hold af after capturing", + "Hold af position after capturing", + FALSE, G_PARAM_READWRITE)); + + g_object_class_install_property(gobject_class, ARG_FAKE_ESD, + g_param_spec_boolean("fake-esd", "Fake ESD generate", + "Generate fake esd situation", + FALSE, G_PARAM_READWRITE)); + + g_object_class_install_property(gobject_class, ARG_SENSOR_MODE, + g_param_spec_int("sensor-mode", "Sensor mode", + "Set sensor mode as CAMERA or MOVIE(camcorder)", + CAMERASRC_SENSOR_MODE_CAMERA, CAMERASRC_SENSOR_MODE_MOVIE, CAMERASRC_SENSOR_MODE_CAMERA, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_VFLIP, + g_param_spec_boolean("vflip", "Flip vertically", + "Flip camera input vertically", + 0, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + g_object_class_install_property(gobject_class, ARG_HFLIP, + g_param_spec_boolean("hflip", "Flip horizontally", + "Flip camera input horizontally", + 0, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); + + /** + * GstCameraSrc::still-capture: + * @camerasrc: the camerasrc instance + * @buffer: the buffer that will be pushed - Main + * @buffer: the buffer that will be pushed - Thumbnail + * @buffer: the buffer that will be pushed - Screennail + * + * This signal gets emitted before sending the buffer. + */ + gst_camerasrc_signals[SIGNAL_STILL_CAPTURE] = + g_signal_new("still-capture", + G_TYPE_FROM_CLASS(klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GstCameraSrcClass, still_capture), + NULL, + NULL, + gst_camerasrc_VOID__OBJECT_OBJECT, + G_TYPE_NONE, + 3, /* Number of parameter */ + GST_TYPE_BUFFER, /* Main image buffer */ + GST_TYPE_BUFFER, /* Thumbnail image buffer */ + GST_TYPE_BUFFER); /* Screennail image buffer */ + + + /* wh01.cho:req-negotiation:+:To notify user of camerasrc, after changing resolution. */ + /** + * GstCameraSrc::nego-complete: + * @camerasrc: the camerasrc instance + * @start: when re-negotiation is finished. + * + */ + gst_camerasrc_signals[SIGNAL_NEGO_COMPLETE] = + g_signal_new("nego-complete", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET(GstCameraSrcClass, nego_complete), + NULL, + NULL, + gst_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + GST_DEBUG("LEAVED"); +} + + +static void gst_camerasrc_init(GstCameraSrc *camerasrc, GstCameraSrcClass *klass) +{ + GST_DEBUG_OBJECT (camerasrc, "ENTERED"); + + camerasrc->v4l2_handle = NULL; + camerasrc->mode = VIDEO_IN_MODE_UNKNOWN; + camerasrc->firsttime = TRUE; + camerasrc->main_buf_sz = 0; + camerasrc->cap_count_current = -1; + camerasrc->cap_count_reverse = _DEFAULT_CAP_COUNT; + camerasrc->cap_next_time = 0UL; + camerasrc->command_list = g_queue_new (); + camerasrc->cond = g_cond_new (); + camerasrc->mutex = g_mutex_new (); + + /*camera*/ + camerasrc->width = _DEFAULT_WIDTH; + camerasrc->height = _DEFAULT_HEIGHT; + camerasrc->fps = _DEFAULT_FPS; + camerasrc->rotate = 0; + camerasrc->use_rotate_caps = FALSE; + camerasrc->high_speed_fps = _DEFAULT_HIGH_SPEED_FPS; + camerasrc->fps_auto = _DEFAULT_FPS_AUTO; + camerasrc->pix_format = _DEFAULT_PIX_FORMAT; + camerasrc->colorspace = _DEFAULT_COLORSPACE; + camerasrc->fourcc = _DEFAULT_FOURCC; + camerasrc->req_negotiation = FALSE; + camerasrc->num_live_buffers = _DEFAULT_NUM_LIVE_BUFFER; + camerasrc->buffer_count = _DEFAULT_BUFFER_COUNT; + camerasrc->buffer_running = _DEFAULT_BUFFER_RUNNING; + camerasrc->buffer_lock = g_mutex_new (); + camerasrc->buffer_cond = g_cond_new (); + camerasrc->bfirst = TRUE; + camerasrc->pad_alloc_list = g_queue_new (); + camerasrc->pad_alloc_mutex = g_mutex_new (); + camerasrc->current_buffer_data_index = 0; + camerasrc->sensor_mode = CAMERASRC_SENSOR_MODE_CAMERA; + camerasrc->vflip = 0; + camerasrc->hflip = 0; + + /* Initialize usr buffer to be alloced by sink to NULL */ + { + int i = 0; + for(i = 0; i < MAX_USR_BUFFER_NUM; i++) { + camerasrc->usr_buffer[i] = NULL; + } + } + camerasrc->use_pad_alloc = FALSE; + camerasrc->num_alloc_buf = 0; + camerasrc->camera_id = _DEFAULT_CAMERA_ID; + + /*capture*/ + camerasrc->cap_fourcc = _DEFAULT_FOURCC; + camerasrc->cap_quality = _DEFAULT_CAP_QUALITY; + camerasrc->cap_width = _DEFAULT_CAP_WIDTH; + camerasrc->cap_height = _DEFAULT_CAP_HEIGHT; + camerasrc->cap_interval = _DEFAULT_CAP_INTERVAL; + camerasrc->cap_count = _DEFAULT_CAP_COUNT; + camerasrc->cap_jpg_quality = _DEFAULT_CAP_JPG_QUALITY; + camerasrc->cap_provide_exif = _DEFAULT_CAP_PROVIDE_EXIF; + camerasrc->signal_still_capture = _DEFAULT_SIGNAL_STILL_CAPTURE; + camerasrc->hold_af_after_capturing = FALSE; + camerasrc->create_jpeg = FALSE; + camerasrc->jpg_mutex = g_mutex_new(); + camerasrc->first_invokation = TRUE; + camerasrc->external_videofd = _FD_DEFAULT; + +#ifdef _SPEED_UP_RAW_CAPTURE + camerasrc->cap_stream_diff = FALSE; +#endif /* _SPEED_UP_RAW_CAPTURE */ + + /* we operate in time */ + gst_base_src_set_format(GST_BASE_SRC(camerasrc), GST_FORMAT_TIME); + gst_base_src_set_live(GST_BASE_SRC(camerasrc), TRUE); + gst_base_src_set_do_timestamp(GST_BASE_SRC(camerasrc), TRUE); + + GST_DEBUG("LEAVED"); +} + + +static void GenerateYUV420BlackFrame(unsigned char *buf, int buf_size, int width, int height) +{ + int i; + int y_len = 0; + int yuv_len = 0; + + y_len = width * height; + yuv_len = (width * height * 3) >> 1; + + if (buf_size < yuv_len) { + return; + } + + if (width % 4) { + for (i = 0 ; i < y_len ; i++) { + buf[i] = 0x10; + } + + for ( ; i < yuv_len ; i++) { + buf[i] = 0x80; + } + } else { + /* faster way */ + int *ibuf = NULL; + short *sbuf = NULL; + ibuf = (int *)buf; + + for (i = 0 ; i < y_len / 4 ; i++) { + ibuf[i] = 0x10101010; /* set YYYY */ + } + + sbuf = (short*)(&buf[y_len]); + + for (i = 0 ; i < (yuv_len - y_len) / 2 ; i++) { + sbuf[i] = 0x8080; /* set UV */ + } + } + + return; +} + + +static void GenerateYUV422BlackFrame(unsigned char *buf, int buf_size, int width, int height) +{ + /* YUYV */ + int i; + int yuv_len = 0; + int *ibuf = NULL; + + ibuf = (int *)buf; + + yuv_len = (width * height * 2); + + if (buf_size < yuv_len) { + return; + } + + for (i = 0 ; i < yuv_len / 4 ; i++) { + ibuf[i] = 0x80108010; /* YUYV -> 0xVYUY */ + } + + return; +} + + +static gboolean GenerateST12BlackFrame(GstCameraSrc *camerasrc, unsigned char *buf, int buf_size, int width, int height) +{ + int i; + int y_len = 0; + int yuv_len = 0; + int ystride = 0; + int uvstride = 0; + int yelevation = 0; + int uvelevation = 0; + gboolean boolret = TRUE; + unsigned char *blkframe = NULL; + + /* Calculation of stride. need to be confirmation from driver team */ + if ((width % 128) != 0 ) { + ystride = width + (128 - (width % 128)); + uvstride = ystride; + } else { + ystride = width; + uvstride = width; + } + + /* Calculation of elevation. need to be confirmation from driver team */ + /* Y elevation */ + if ((height % 32) != 0) { + yelevation= height + (32 - (height % 32)); + } else { + yelevation = height; + } + /* UV elevation */ + if (((height >>1) % 32) != 0) { + uvelevation = (height >> 1) + (32 - ((height >> 1) % 32)); + } else { + uvelevation = (height >> 1); + } + + GST_DEBUG("ystride = %d and uvstride = %d", ystride, uvstride); + GST_DEBUG("yelevation = %d and uvelevation = %d", yelevation, uvelevation); + + y_len = ystride * yelevation; + yuv_len = y_len + uvstride * uvelevation; + + /* Generate black frame */ + blkframe = (unsigned char*)g_malloc(yuv_len); + + if (blkframe == NULL) { + GST_ERROR ("ST12Blk: Failed to allocate memory..."); + boolret = FALSE; + goto FINISH; + } + + for (i = 0 ; i < y_len ; i++) { + blkframe [i] = 0x10; + } + + for (; i < yuv_len ; i++) { + blkframe [i] = 0x80; + } + + +FINISH: + if (blkframe != NULL) { + g_free (blkframe); + } + + return boolret; + +} + + +static unsigned long gst_get_current_time(void) +{ + struct timeval lc_time; + + gettimeofday(&lc_time, NULL); + + return ((unsigned long)(lc_time.tv_sec * 1000L) + (unsigned long)(lc_time.tv_usec / 1000L)); +} + + +#if _ENABLE_CAMERASRC_DEBUG +#include <stdio.h> +static int __util_write_file(char *filename, void *data, int size) +{ + FILE *fp = NULL; + + fp = fopen(filename, "wb"); + if (!fp) { + return FALSE; + } + + fwrite(data, 1, size, fp); + fclose(fp); + + return TRUE; +} +#endif + + +static gboolean plugin_init(GstPlugin *plugin) +{ + gboolean error; + + error = gst_element_register(plugin, "camerasrc", GST_RANK_PRIMARY + 100, GST_TYPE_CAMERA_SRC); + + return error; +} + + +GST_PLUGIN_DEFINE(GST_VERSION_MAJOR, + GST_VERSION_MINOR, + "camerasrc", + "Camera source plug-in", + plugin_init, + PACKAGE_VERSION, + "LGPL", + "Samsung Electronics Co", + "http://www.samsung.com") + +/* GstURIHandler interface */ +static GstURIType gst_camerasrc_uri_get_type (void) +{ + return GST_URI_SRC; +} + +static gchar ** gst_camerasrc_uri_get_protocols (void) +{ + static gchar *protocols[] = { (char *) "camera", NULL }; + return protocols; +} + +static const gchar * gst_camerasrc_uri_get_uri (GstURIHandler * handler) +{ + GstCameraSrc *camerasrc = GST_CAMERA_SRC (handler); + + gchar uri[256]; + g_snprintf (uri, sizeof (uri), "camera://0"); + return g_intern_string (uri); +} + +static gboolean gst_camerasrc_uri_set_uri (GstURIHandler * handler, const gchar * uri) +{ + GstCameraSrc *camerasrc = GST_CAMERA_SRC (handler); + const gchar *device = "0"; + if (strcmp (uri, "camera://") != 0) { + device = uri + 9; + } + g_object_set (camerasrc, "camera-id", atoi(device), NULL); + + return TRUE; +} + + +static void gst_camerasrc_uri_handler_init (gpointer g_iface, gpointer iface_data) +{ + GstURIHandlerInterface *iface = (GstURIHandlerInterface *) g_iface; + + iface->get_type = gst_camerasrc_uri_get_type; + iface->get_protocols = gst_camerasrc_uri_get_protocols; + iface->get_uri = gst_camerasrc_uri_get_uri; + iface->set_uri = gst_camerasrc_uri_set_uri; +} +/* EOF */ diff --git a/camerasrc/src/gstcamerasrccolorbalance.c b/camerasrc/src/gstcamerasrccolorbalance.c new file mode 100644 index 0000000..242f9db --- /dev/null +++ b/camerasrc/src/gstcamerasrccolorbalance.c @@ -0,0 +1,117 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <gst/gst.h> +#include "gstcamerasrccolorbalance.h" + +GST_BOILERPLATE( GstCameraSrcColorBalanceChannel, + gst_camerasrc_color_balance_channel, + GstColorBalanceChannel, + GST_TYPE_COLOR_BALANCE_CHANNEL ); + +#ifndef GST_CAT_DEFAULT +GST_DEBUG_CATEGORY_EXTERN(camerasrc_debug); +#define GST_CAT_DEFAULT camerasrc_debug +#endif /* GST_CAT_DEFAULT */ + +static void +gst_camerasrc_color_balance_channel_base_init( gpointer g_class ) +{ +} + +static void +gst_camerasrc_color_balance_channel_class_init( GstCameraSrcColorBalanceChannelClass* klass ) +{ +} + +static void +gst_camerasrc_color_balance_channel_init( GstCameraSrcColorBalanceChannel* camerasrc_color_channel, GstCameraSrcColorBalanceChannelClass* klass ) +{ + camerasrc_color_channel->id = (guint32) - 1; +} + +static G_GNUC_UNUSED gboolean +gst_camerasrc_color_balance_contains_channel( GstCameraSrc* camerasrc, GstCameraSrcColorBalanceChannel* camerasrc_color_channel ) +{ + const GList *item; + + for( item = camerasrc->colors ; item != NULL ; item = item->next ) + { + if (item->data == camerasrc_color_channel) + return TRUE; + } + + return FALSE; +} + +const GList * +gst_camerasrc_color_balance_list_channels( GstCameraSrc* camerasrc ) +{ + return camerasrc->colors; +} + +void +gst_camerasrc_color_balance_set_value( GstCameraSrc* camerasrc, GstColorBalanceChannel* color_channel, gint value ) +{ + int error = CAMERASRC_ERR_UNKNOWN; + + GstCameraSrcColorBalanceChannel *camerasrc_color_channel = GST_CAMERASRC_COLOR_BALANCE_CHANNEL( color_channel ); + + /* assert that we're opened and that we're using a known item */ + g_return_if_fail( camerasrc ); + g_return_if_fail( gst_camerasrc_color_balance_contains_channel( camerasrc, camerasrc_color_channel ) ); + + error = camerasrc_set_control( camerasrc->v4l2_handle, camerasrc_color_channel->id, value ); + + if( error != CAMERASRC_SUCCESS ) + { + GST_WARNING("Failed to Set ColorBalance[%s],value[%d]", camerasrc_color_channel->parent.label, value); + } +} + +gint +gst_camerasrc_color_balance_get_value( GstCameraSrc* camerasrc, GstColorBalanceChannel* color_channel ) +{ + int error, value; + GstCameraSrcColorBalanceChannel *camerasrc_color_channel = GST_CAMERASRC_COLOR_BALANCE_CHANNEL( color_channel ); + + /* assert that we're opened and that we're using a known item */ + g_return_val_if_fail( camerasrc, FALSE ); + g_return_val_if_fail( gst_camerasrc_color_balance_contains_channel( camerasrc, camerasrc_color_channel ), FALSE ); + + error = camerasrc_get_control( camerasrc->v4l2_handle, camerasrc_color_channel->id, &value ); + + if( error != CAMERASRC_SUCCESS ) + { + GST_WARNING("Failed to Get ColorBalance[%s].", camerasrc_color_channel->parent.label); + return FALSE; + } + + return value; +} + + diff --git a/camerasrc/src/gstcamerasrccontrol.c b/camerasrc/src/gstcamerasrccontrol.c new file mode 100644 index 0000000..2cb910f --- /dev/null +++ b/camerasrc/src/gstcamerasrccontrol.c @@ -0,0 +1,1098 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include <gst/gst.h> +#include "gstcamerasrccontrol.h" +#include "camerasrc-common.h" + +#define gst_camerasrc_debug(fmt, args...) GST_INFO(fmt, ##args) + +#define CAMERA_CONTROL_AF_STOP_TOTALTIME 2000000 +#define CAMERA_CONTROL_AF_STOP_INTERVAL 20000 + +GST_BOILERPLATE (GstCamerasrcControlChannel, + gst_camerasrc_control_channel, + GstCameraControlChannel, GST_TYPE_CAMERA_CONTROL_CHANNEL); + + +static void +gst_camerasrc_control_channel_base_init( gpointer g_class ) +{ + gst_camerasrc_debug( "" ); +} + +static void +gst_camerasrc_control_channel_class_init( GstCamerasrcControlChannelClass* klass ) +{ + gst_camerasrc_debug( "" ); +} + +static void +gst_camerasrc_control_channel_init( GstCamerasrcControlChannel* control_channel, GstCamerasrcControlChannelClass* klass ) +{ + gst_camerasrc_debug( "" ); + + control_channel->id = (guint32) - 1; +} + +static G_GNUC_UNUSED gboolean +gst_camerasrc_control_contains_channel( GstCameraSrc* camerasrc, GstCamerasrcControlChannel* camerasrc_control_channel ) +{ + gst_camerasrc_debug( "" ); + + const GList* item; + + for( item = camerasrc->camera_controls ; item != NULL ; item = item->next ) + { + if( item->data == camerasrc_control_channel ) + { + return TRUE; + } + } + + return FALSE; +} + +const GList* +gst_camerasrc_control_list_channels( GstCameraSrc* camerasrc ) +{ + gst_camerasrc_debug( "" ); + + return camerasrc->camera_controls; +} + +gboolean +gst_camerasrc_control_set_value( GstCameraSrc* camerasrc, GstCameraControlChannel *control_channel, gint value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + GstCamerasrcControlChannel *camerasrc_control_channel = GST_CAMERASRC_CONTROL_CHANNEL( control_channel ); + + g_return_val_if_fail( camerasrc, FALSE ); + g_return_val_if_fail( gst_camerasrc_control_contains_channel( camerasrc, camerasrc_control_channel ), FALSE ); + + error = camerasrc_set_control( camerasrc->v4l2_handle, camerasrc_control_channel->id, value ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set value. Ctrl-id [%d], value [%d], err code [%d]", camerasrc_control_channel->id, value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_value( GstCameraSrc* camerasrc, GstCameraControlChannel *control_channel, gint *value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + GstCamerasrcControlChannel *camerasrc_control_channel = GST_CAMERASRC_CONTROL_CHANNEL( control_channel ); + + g_return_val_if_fail( camerasrc, FALSE ); + g_return_val_if_fail( gst_camerasrc_control_contains_channel( camerasrc, camerasrc_control_channel ), FALSE ); + + error = camerasrc_get_control( camerasrc->v4l2_handle, camerasrc_control_channel->id, value ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get control value. Ctrl-id [%d], err code[%x]", camerasrc_control_channel->id, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_exposure( GstCameraSrc* camerasrc, gint type, gint value1, gint value2 ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + camerasrc_frac_t frac; + + g_return_val_if_fail( camerasrc, FALSE ); + + /* TODO : F number */ + switch( type ) + { + case GST_CAMERA_CONTROL_F_NUMBER: + error = CAMERASRC_SUCCESS; + break; + case GST_CAMERA_CONTROL_SHUTTER_SPEED: + frac.numerator = value1; + frac.denominator = value2; + __ta__(" camerasrc_set_shutter_speed", + error = camerasrc_set_shutter_speed( camerasrc->v4l2_handle, frac ); + ) + break; + case GST_CAMERA_CONTROL_ISO: + __ta__(" camerasrc_set_iso_value", + error = camerasrc_set_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_ISO, value1 ); + ) + break; + case GST_CAMERA_CONTROL_PROGRAM_MODE: + __ta__(" camerasrc_set_control", + error = camerasrc_set_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PROGRAM_MODE, value1 ); + ) + break; + case GST_CAMERA_CONTROL_EXPOSURE_MODE: + __ta__(" camerasrc_set_exposure_mode", + error = camerasrc_set_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PHOTOMETRY, value1 ); + ) + break; + case GST_CAMERA_CONTROL_EXPOSURE_VALUE: + frac.numerator = value1; + frac.denominator = value2; + __ta__(" camerasrc_set_exposure_value", + error = camerasrc_set_exposure_value( camerasrc->v4l2_handle, frac ); + ) + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set exposure. Type[%d],value1[%d],value2[%d],err code[%x]", type, value1, value2, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_exposure( GstCameraSrc* camerasrc, gint type, gint* value1, gint* value2 ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + camerasrc_frac_t frac; + + g_return_val_if_fail( camerasrc, FALSE ); + + /* TODO : F number */ + switch( type ) + { + case GST_CAMERA_CONTROL_F_NUMBER: + break; + case GST_CAMERA_CONTROL_SHUTTER_SPEED: + error = camerasrc_get_shutter_speed( camerasrc->v4l2_handle, &frac ); + if( error == CAMERASRC_SUCCESS ) + { + *value1 = frac.numerator; + *value2 = frac.denominator; + } + break; + case GST_CAMERA_CONTROL_ISO: + error = camerasrc_get_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_ISO, value1 ); + break; + case GST_CAMERA_CONTROL_PROGRAM_MODE: + error = camerasrc_get_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PROGRAM_MODE, value1 ); + break; + case GST_CAMERA_CONTROL_EXPOSURE_MODE: + error = camerasrc_get_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PHOTOMETRY, value1 ); + break; + case GST_CAMERA_CONTROL_EXPOSURE_VALUE: + error = camerasrc_get_exposure_value( camerasrc->v4l2_handle, &frac ); + if( error == CAMERASRC_SUCCESS ) + { + *value1 = frac.numerator; + *value2 = frac.denominator; + } + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get exposure. Type [%d]", type ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_capture_mode( GstCameraSrc* camerasrc, gint type, gint value ) +{ + /* TODO : single/multishot select(capture mode), output mode, frame count, JPEG quality */ + + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_CAPTURE_MODE: + break; + case GST_CAMERA_CONTROL_OUTPUT_MODE: + break; + case GST_CAMERA_CONTROL_FRAME_COUNT: + break; + case GST_CAMERA_CONTROL_JPEG_QUALITY: + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set capture mode. Type[%d],value[%d],err code[%x]", type, value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_capture_mode( GstCameraSrc* camerasrc, gint type, gint *value ) +{ + /* TODO : single/multishot select(capture mode), output mode, frame count, JPEG quality */ + + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_CAPTURE_MODE: + break; + case GST_CAMERA_CONTROL_OUTPUT_MODE: + break; + case GST_CAMERA_CONTROL_FRAME_COUNT: + break; + case GST_CAMERA_CONTROL_JPEG_QUALITY: + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set capture mode. Type[%d],value[%d],err code[%x]", type, value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_strobe( GstCameraSrc* camerasrc, gint type, gint value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_STROBE_MODE: + error = camerasrc_set_strobe_mode( camerasrc->v4l2_handle, value ); + break; + case GST_CAMERA_CONTROL_STROBE_CONTROL: + case GST_CAMERA_CONTROL_STROBE_CAPABILITIES: + case GST_CAMERA_CONTROL_STROBE_STATUS: + case GST_CAMERA_CONTROL_STROBE_EV: + default: + gst_camerasrc_debug( "Not supported type[%d], return CAMERASRC_ERR_DEVICE_NOT_SUPPORT.", type ); + error = CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + break; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set strobe. Type[%d],value[%d],err code[%x]", type, value, error ); + return FALSE; + } + + gst_camerasrc_debug( "Succeed to set strobe. Type[%d],value[%d]", type, value ); + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_strobe( GstCameraSrc* camerasrc, gint type, gint* value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_STROBE_MODE: + error = camerasrc_get_strobe_mode( camerasrc->v4l2_handle, (camerasrc_strobe_mode_t *)value ); + break; + case GST_CAMERA_CONTROL_STROBE_CONTROL: + case GST_CAMERA_CONTROL_STROBE_CAPABILITIES: + case GST_CAMERA_CONTROL_STROBE_STATUS: + case GST_CAMERA_CONTROL_STROBE_EV: + default: + gst_camerasrc_debug( "Not supported type[%d].", type ); + error = CAMERASRC_ERR_DEVICE_NOT_SUPPORT; + break; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get strobe. Type[%d],err code[%x]", type, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_detect( GstCameraSrc* camerasrc, gint type, gint value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + /* TODO : detection number, focus select, select number, detect status */ + switch( type ) + { + case GST_CAMERA_CONTROL_FACE_DETECT_MODE: + if( value == 0 ) + { + error = camerasrc_stop_facedetection(camerasrc->v4l2_handle ); + } + else if( value == 1 ) + { + error = camerasrc_start_facedetection(camerasrc->v4l2_handle ); + } + break; + case GST_CAMERA_CONTROL_FACE_DETECT_NUMBER: + break; + case GST_CAMERA_CONTROL_FACE_FOCUS_SELECT: + break; + case GST_CAMERA_CONTROL_FACE_SELECT_NUMBER: + break; + case GST_CAMERA_CONTROL_FACE_DETECT_STATUS: + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set detect. Type[%d],value[%d],err code[%x]", type, value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_detect( GstCameraSrc* camerasrc, gint type, gint *value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + /* TODO : detection number, focus select, select number, detect status */ + switch( type ) + { + case GST_CAMERA_CONTROL_FACE_DETECT_MODE: + error = camerasrc_get_facedetection(camerasrc->v4l2_handle, value); + break; + case GST_CAMERA_CONTROL_FACE_DETECT_NUMBER: + break; + case GST_CAMERA_CONTROL_FACE_FOCUS_SELECT: + break; + case GST_CAMERA_CONTROL_FACE_SELECT_NUMBER: + break; + case GST_CAMERA_CONTROL_FACE_DETECT_STATUS: + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get detect. Type[%d],err code[%x]", type, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_zoom( GstCameraSrc* camerasrc, gint type, gint value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_DIGITAL_ZOOM: + error = camerasrc_set_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_DIGITAL_ZOOM, value ); + break; + case GST_CAMERA_CONTROL_OPTICAL_ZOOM: + error = camerasrc_set_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_OPTICAL_ZOOM, value ); + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set zoom. Type[%d],value[%d],err code[%x]", type, value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_zoom( GstCameraSrc* camerasrc, gint type, gint *value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_DIGITAL_ZOOM: + error = camerasrc_get_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_DIGITAL_ZOOM, value ); + break; + case GST_CAMERA_CONTROL_OPTICAL_ZOOM: + error = camerasrc_get_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_OPTICAL_ZOOM, value ); + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get zoom. Type[%d],err code[%x]", type, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_focus( GstCameraSrc* camerasrc, gint focus_mode, gint focus_range ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_init_autofocusing_mode( camerasrc->v4l2_handle, focus_mode, focus_range ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set AF mode." ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_focus( GstCameraSrc* camerasrc, gint *focus_mode, gint *focus_range ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_get_autofocusing_mode(camerasrc->v4l2_handle, (camerasrc_af_mode_t *)focus_mode, (camerasrc_af_scan_range_t *)focus_range); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get AF mode." ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_start_auto_focus( GstCameraSrc* camerasrc ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + MMTA_ACUM_ITEM_BEGIN( "AutoFocus operating time", FALSE ); + + error = camerasrc_start_autofocusing( camerasrc->v4l2_handle ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to start AF. error[%x]", error ); + return FALSE; + } + else + { + gst_camerasrc_debug( "Succeeded to start AF." ); + return TRUE; + } +} + +gboolean +gst_camerasrc_control_stop_auto_focus( GstCameraSrc* camerasrc ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + int try_count = 0; + camerasrc_auto_focus_status_t af_status = CAMERASRC_AUTO_FOCUS_STATUS_RELEASED; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_stop_autofocusing( camerasrc->v4l2_handle ); + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to stop autofocus." ); + return FALSE; + } + + while( try_count++ < CAMERA_CONTROL_AF_STOP_TOTALTIME/CAMERA_CONTROL_AF_STOP_INTERVAL ) + { + error = camerasrc_get_autofocusing_status( camerasrc->v4l2_handle, &af_status ); + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get af status.(%x)", error ); + return FALSE; + } + + if( af_status == CAMERASRC_AUTO_FOCUS_STATUS_RELEASED ) + { + gst_camerasrc_debug( "AF Stop done. try count[%d]", try_count ); + break; + } + + usleep( CAMERA_CONTROL_AF_STOP_INTERVAL ); + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_focus_level( GstCameraSrc* camerasrc, gint focus_level ) +{ + /* TODO : */ + + gst_camerasrc_debug( "Not support" ); + return FALSE; +} + +gboolean +gst_camerasrc_control_get_focus_level( GstCameraSrc* camerasrc, gint *focus_level ) +{ + /* TODO : */ + + gst_camerasrc_debug( "Not support" ); + return FALSE; +} + +gboolean +gst_camerasrc_control_set_auto_focus_area( GstCameraSrc* camerasrc, GstCameraControlRectType rect ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + camerasrc_rect_t camerasrc_rect = { 0, 0, 0, 0 }; + + g_return_val_if_fail( camerasrc, FALSE ); + + if (camerasrc->camera_id == CAMERASRC_DEV_ID_SECONDARY) { + GST_INFO_OBJECT(camerasrc, "It's secondary camera. Skip setting..."); + return TRUE; + } + + camerasrc_rect.x = rect.x; + camerasrc_rect.y = rect.y; + camerasrc_rect.width = rect.width; + camerasrc_rect.height = rect.height; + + GST_INFO_OBJECT(camerasrc, "Set AF area %d,%d,%dx%d", + camerasrc_rect.x, camerasrc_rect.y, + camerasrc_rect.width, camerasrc_rect.height); + + error = camerasrc_set_autofocusing_area( camerasrc->v4l2_handle, &camerasrc_rect ); + + if( error != CAMERASRC_SUCCESS ) + { + GST_ERROR_OBJECT(camerasrc, "Failed to set auto focus area."); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_auto_focus_area( GstCameraSrc* camerasrc, GstCameraControlRectType* rect ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + camerasrc_rect_t camerasrc_rect = { 0, 0, 0, 0 }; + + g_return_val_if_fail( camerasrc, FALSE ); + g_return_val_if_fail( rect, FALSE ); + + error = camerasrc_get_autofocusing_area( camerasrc->v4l2_handle, &camerasrc_rect ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get auto focus area." ); + + rect->x = rect->y = -1; + rect->width = rect->height = -1; + + return FALSE; + } + + rect->x = camerasrc_rect.x; + rect->y = camerasrc_rect.y; + rect->width = camerasrc_rect.width; + rect->height = camerasrc_rect.height; + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_wdr( GstCameraSrc* camerasrc, gint value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_set_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_WIDE_DYNAMIC_RANGE, value ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set wdr. value[%d],err code[%x]", value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_wdr( GstCameraSrc* camerasrc, gint* value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_get_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_WIDE_DYNAMIC_RANGE, value ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get wdr. err code[%x]", error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_ahs( GstCameraSrc* camerasrc, gint value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_set_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_ANTI_HANDSHAKE, value ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set ahs. value[%d],err code[%x]", value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_ahs( GstCameraSrc* camerasrc, gint* value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_get_control (camerasrc->v4l2_handle, CAMERASRC_CTRL_ANTI_HANDSHAKE, value ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get ahs. err code[%x]", error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_set_part_color( GstCameraSrc* camerasrc, gint type, gint value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_PART_COLOR_SRC: + error = camerasrc_set_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PARTCOLOR_SRC, value ); + break; + case GST_CAMERA_CONTROL_PART_COLOR_DST: + error = camerasrc_set_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PARTCOLOR_DST, value ); + break; + case GST_CAMERA_CONTROL_PART_COLOR_MODE: + error = camerasrc_set_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PARTCOLOR_MODE, value ); + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to set part color. Type[%d],value[%d],err code[%x]", type, value, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_part_color( GstCameraSrc* camerasrc, gint type, gint* value ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + switch( type ) + { + case GST_CAMERA_CONTROL_PART_COLOR_SRC: + error = camerasrc_get_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PARTCOLOR_SRC, value ); + break; + case GST_CAMERA_CONTROL_PART_COLOR_DST: + error = camerasrc_get_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PARTCOLOR_DST, value ); + break; + case GST_CAMERA_CONTROL_PART_COLOR_MODE: + error = camerasrc_get_control( camerasrc->v4l2_handle, CAMERASRC_CTRL_PARTCOLOR_MODE, value ); + break; + default: + gst_camerasrc_debug( "Not supported type." ); + return FALSE; + } + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get part color. Type[%d],err code[%x]", type, error ); + return FALSE; + } + + return TRUE; +} + +gboolean +gst_camerasrc_control_get_exif_info( GstCameraSrc* camerasrc, GstCameraControlExifInfo* info ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + camerasrc_exif_t exif_struct; + + g_return_val_if_fail( camerasrc, FALSE ); + + error = camerasrc_get_exif_info( camerasrc->v4l2_handle, &exif_struct ); + + if( error != CAMERASRC_SUCCESS ) + { + gst_camerasrc_debug( "Failed to get exif info. err code[%x]", error ); + return FALSE; + } + + /* Dynamic value */ + info->exposure_time_numerator = exif_struct.exposure_time_numerator; + info->exposure_time_denominator = exif_struct.exposure_time_denominator; + info->shutter_speed_numerator = exif_struct.shutter_speed_numerator; + info->shutter_speed_denominator = exif_struct.shutter_speed_denominator; + info->brigtness_numerator = exif_struct.brigtness_numerator; + info->brightness_denominator = exif_struct.brightness_denominator; + info->iso = exif_struct.iso; + info->flash = exif_struct.flash; + info->metering_mode = exif_struct.metering_mode; + info->exif_image_width = exif_struct.exif_image_width; + info->exif_image_height = exif_struct.exif_image_height; + info->software_used = exif_struct.software_used; + info->exposure_bias_in_APEX = exif_struct.exposure_bias_in_APEX; + + /* Fixed value */ + info->component_configuration = exif_struct.component_configuration; + info->colorspace = exif_struct.colorspace; + info->max_lens_aperture_in_APEX = exif_struct.max_lens_aperture_in_APEX; + + /*FIXME*/ + if (camerasrc->camera_id == CAMERASRC_DEV_ID_PRIMARY) { + info->focal_len_numerator = CAMERASRC_PRIMARY_FOCAL_LEGNTH_NUM; + info->focal_len_denominator = CAMERASRC_PRIMARY_FOCAL_LEGNTH_DENOM; + info->aperture_f_num_numerator = CAMERASRC_PRIMARY_F_NUMBER_NUM; + info->aperture_f_num_denominator = CAMERASRC_PRIMARY_F_NUMBER_DENOM; + } else { + info->focal_len_numerator = CAMERASRC_SECONDARY_FOCAL_LEGNTH_NUM; + info->focal_len_denominator = CAMERASRC_SECONDARY_FOCAL_LEGNTH_DENOM; + info->aperture_f_num_numerator = CAMERASRC_SECONDARY_F_NUMBER_NUM; + info->aperture_f_num_denominator = CAMERASRC_SECONDARY_F_NUMBER_DENOM; + } + info->aperture_in_APEX = CAMERASRC_EXIF_APERTURE_VALUE_IN_APEX(info->aperture_f_num_numerator, info->aperture_f_num_denominator); + + return TRUE; +} + +gboolean gst_camerasrc_control_get_basic_dev_info ( GstCameraSrc* camerasrc, gint dev_id, GstCameraControlCapsInfoType* info ) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + /** + * Just implementation issue, but at this time, we assume + * GstCameraControlCapsInfoType is exactly same with camerasrc_caps_info_t + * For performance. + * Here is plugin code. we can do like this? + */ +#if 1 + error = camerasrc_read_basic_dev_info(dev_id, (camerasrc_caps_info_t*)info); + if(error != CAMERASRC_SUCCESS) + { + return FALSE; + } +#else + int i, j, k; + camerasrc_caps_info_t caps_info; + + error = camerasrc_read_basic_dev_info(dev_id, &caps_info); + if(error != CAMERASRC_SUCCESS) + { + return FALSE; + } + + if(caps_info.num_fmt_desc != 0) + { + info->num_fmt_desc = caps_info.num_fmt_desc; + for (i=0; i<caps_info.num_fmt_desc; i++) { + if(caps_info.fmt_desc[i].num_resolution != 0) + { + info->fmt_desc[i].fcc = caps_info.fmt_desc[i].fcc; + info->fmt_desc[i].num_resolution = caps_info.fmt_desc[i].num_resolution; + for (j=0; j<caps_info.fmt_desc[i].num_resolution; j++) + { + if(caps_info.fmt_desc[i].resolutions[j].num_avail_tpf != 0) + { + info->fmt_desc[i].resolutions[j].w = caps_info.fmt_desc[i].resolutions[j].w; + info->fmt_desc[i].resolutions[j].h = caps_info.fmt_desc[i].resolutions[j].h; + info->fmt_desc[i].resolutions[j].num_avail_tpf = caps_info.fmt_desc[i].resolutions[j].num_avail_tpf; + for(k=0; k< caps_info.fmt_desc[i].resolutions[j].num_avail_tpf; k++) + { + info->fmt_desc[i].resolutions[j].tpf[k].num = caps_info.fmt_desc[i].resolutions[j].tpf[k].num; + info->fmt_desc[i].resolutions[j].tpf[k].den = caps_info.fmt_desc[i].resolutions[j].tpf[k].den; + } + } + else + { + /* No available timeperframe */ + return FALSE; + } + } + } + else + { + /* No available resolution set */ + return FALSE; + } + } + } + else + { + /* No available image format(fourcc) */ + return FALSE; + } +#endif + return TRUE; +} + +gboolean gst_camerasrc_control_get_misc_dev_info( GstCameraSrc* camerasrc, gint dev_id, GstCameraControlCtrlListInfoType * info) +{ + gst_camerasrc_debug( "" ); + + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + /** + * Just implementation issue, but at this time, we assume + * GstCameraControlCtrlListInfoType is exactly same with camerasrc_ctrl_list_info_t + * For performance. + * Here is plugin code. we can do like this? + */ +#if 1 + error = camerasrc_read_misc_dev_info(dev_id, (camerasrc_ctrl_list_info_t*)info); + if(error != CAMERASRC_SUCCESS) + { + return FALSE; + } +#else + int i, j; + camerasrc_ctrl_list_info_t ctrl_info; + + error = camerasrc_read_misc_dev_info(dev_id, &ctrl_info); + if(error != CAMERASRC_SUCCESS) + { + return FALSE; + } + + if(ctrl_info.num_ctrl_list_info != 0) + { + info->num_ctrl_list_info = ctrl_info.num_ctrl_list_info; + for(i=0; i< ctrl_info.num_ctrl_list_info; i++) + { + info->ctrl_info[i].camerasrc_ctrl_id = ctrl_info.ctrl_info[i].camerasrc_ctrl_id; + info->ctrl_info[i].v4l2_ctrl_id = ctrl_info.ctrl_info[i].v4l2_ctrl_id; + info->ctrl_info[i].ctrl_type = ctrl_info.ctrl_info[i].ctrl_type; + info->ctrl_info[i].max = ctrl_info.ctrl_info[i].max; + info->ctrl_info[i].min = ctrl_info.ctrl_info[i].min; + info->ctrl_info[i].step = ctrl_info.ctrl_info[i].step; + info->ctrl_info[i].default_val = ctrl_info.ctrl_info[i].default_val; + info->ctrl_info[i].num_ctrl_menu = ctrl_info.ctrl_info[i].num_ctrl_menu; + memcpy(info->ctrl_info[i].ctrl_name,ctrl_info.ctrl_info[i].ctrl_name,MAX_SZ_CTRL_NAME_STRING); + if(ctrl_info.ctrl_info[i].ctrl_type == CTRL_TYPE_ARRAY && ctrl_info.ctrl_info[i].num_ctrl_menu != 0) + { + for(j=0; j<ctrl_info.ctrl_info[i].num_ctrl_menu; j++) + { + info->ctrl_info[i].ctrl_menu[j].menu_index = ctrl_info.ctrl_info[i].ctrl_menu[j].menu_index; + memcpy(info->ctrl_info[i].ctrl_menu[j].menu_name, ctrl_info.ctrl_info[i].ctrl_menu[j].menu_name, MAX_SZ_CTRL_NAME_STRING); + } + } + else + { + /* Not a menu type or not available menus */ + return FALSE; + } + } + } + else + { + /* Not avaliable controls */ + return FALSE; + } +#endif + return TRUE; +} + +gboolean gst_camerasrc_control_get_extra_dev_info( GstCameraSrc* camerasrc, gint dev_id, GstCameraControlExtraInfoType * info) +{ + int error = CAMERASRC_ERROR; + + g_return_val_if_fail( camerasrc, FALSE ); + + gst_camerasrc_debug( "" ); + + /** + * Just implementation issue, but at this time, we assume + * GstCameraControlCtrlListInfoType is exactly same with camerasrc_ctrl_list_info_t + * For performance. + * Here is plugin code. we can do like this? + */ + + error = camerasrc_read_extra_dev_info(dev_id, (camerasrc_extra_info_t*)info); + if(error != CAMERASRC_SUCCESS) + { + return FALSE; + } + + return TRUE; +} + +void gst_camerasrc_control_set_capture_command( GstCameraSrc* camerasrc, GstCameraControlCaptureCommand cmd ) +{ + gst_camerasrc_debug( "" ); + + if( camerasrc == NULL ) + { + gst_camerasrc_debug( "camerasrc is NULL" ); + return; + } + + gst_camerasrc_set_capture_command( camerasrc, cmd ); + + return; +} diff --git a/camerasrc/src/include/camerasrc-common.h b/camerasrc/src/include/camerasrc-common.h new file mode 100644 index 0000000..207cdd3 --- /dev/null +++ b/camerasrc/src/include/camerasrc-common.h @@ -0,0 +1,408 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __CAMERASRC_COMMON_H__ +#define __CAMERASRC_COMMON_H__ + +#include <stdio.h> +#include <malloc.h> +#include <pthread.h> +#include <errno.h> /*EXXX*/ +#include <sys/ioctl.h> /*ioctl*/ +#include <string.h> /*memcpy*/ + +#include <sys/types.h> /*open*/ +#include <sys/stat.h> +#include <fcntl.h> + +#include <unistd.h> /*mmap*/ +#include <sys/mman.h> /*alloc series, free..*/ +#include <sys/time.h> /*gettimeofday*/ +#include <math.h> /*log2*/ +#include <gst/gst.h> + +#undef __ASM_ARM_TYPES_H +#undef __ASSEMBLY_ +#undef _I386_TYPES_H + +#include <asm/types.h> +#include <linux/videodev2.h> /* V4L2 APIs */ +#include <linux/videodev2_exynos_camera.h> +#include <linux/videodev2_exynos_media.h> + +#include "camerasrc.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * Memory utility definitions + */ +#if !defined (PAGE_SHIFT) + #define PAGE_SHIFT sysconf(_SC_PAGESIZE) +#endif +#if !defined (PAGE_SIZE) + #define PAGE_SIZE (1UL << PAGE_SHIFT) +#endif +#if !defined (PAGE_MASK) + #define PAGE_MASK (~(PAGE_SIZE-1)) +#endif + +#define PAGE_ALIGN(addr) (((addr)+PAGE_SIZE-1)&PAGE_MASK) +#define CLEAR(x) memset (&(x), 0, sizeof (x)) + +#define CAMERASRC_MAX_WIDTH 2560 +#define CAMERASRC_MAX_HEIGHT 1920 +#define CAMERASRC_CID_NOT_SUPPORT -1 +#define CAMERASRC_USRPTR_MAX_BUFFER_NUM 12 +#define CAMERASRC_MAX_FILENAME_LEN 255 +#define CAMERASRC_DEV_NODE_PREFIX "/dev/video" +#define CAMERASRC_DEV_FD_INIT -1 +#define CAMERASRC_DEV_ON_ACCESS_STR "ONACCESS" +#define CAMERASRC_DEV_RELEASED_STR "RELEASED" +#define CAMERASRC_OPENED_CHK_FILENAME "/tmp/.dev_chk" +#define CAMERASRC_THREAD_KILL -999 +#define CAMERASRC_DEV_FD_EMERGENCY_CLOSED -999 +#define CAMERASRC_ERRMSG_MAX_LEN 128 +#define CAMERASRC_FRAME_DUMP_PATH "/tmp/" +#define CAMERASRC_DBG_SCRIPT_PATH "/mnt/mmc/cam_dbg_script" +#define CAMERASRC_PRIMARY_BASIC_INFO_PATH "/tmp/.camprimarybasicinfo" +#define CAMERASRC_PRIMARY_MISC_INFO_PATH "/tmp/.camprimarymiscinfo" +#define CAMERASRC_PRIMARY_EXTRA_INFO_PATH "/tmp/.camprimaryextrainfo" +#define CAMERASRC_SECONDARY_BASIC_INFO_PATH "/tmp/.camsecondarybasicinfo" +#define CAMERASRC_SECONDARY_MISC_INFO_PATH "/tmp/.camsecondarymiscinfo" +#define CAMERASRC_SECONDARY_EXTRA_INFO_PATH "/tmp/.camsecondaryextrainfo" +#define CAMERASRC_MAX_IMAGE_BUFFER_PLANES 3 + +#define USE_OPEN_CHK /*< Using open check with temporary file */ +#define USE_SENSOR_MODE 1 +/*#define USE_SKIP_FRAME*/ /*< Skip frame toggle */ +/*#define USE_IOCTL_DEBUG*/ /*< For debugging ioctl name, argument, address, etc */ +/*#define USE_FRAME_COPY_BOUNDARY_CHECK*/ /*< Copy boundary checks occurs seg fault when overrun */ +/*#define USE_SKIP_FRAME_AT_RAW_FRAME*/ /*< In pumping raw frame, initial 2-3 frames are darker. so skip it */ +/*#define USE_CAMERASRC_FRAME_DUMP*/ /*< Debug system annoying me. Use printf!!!! */ +/*#define USE_USERPTR_DEBUG*/ +/*#define ENABLE_Q_ERROR*/ + +#ifndef GST_CAT_DEFAULT +GST_DEBUG_CATEGORY_EXTERN(camerasrc_debug); +#define GST_CAT_DEFAULT camerasrc_debug +#endif /* GST_CAT_DEFAULT */ + + +#define camsrc_info(msg, args...) GST_INFO(msg, ##args) +#define camsrc_warning(msg, args...) GST_WARNING(msg, ##args) +#define camsrc_error(msg, args...) GST_ERROR(msg, ##args) +#define camsrc_critical(msg, args...) GST_ERROR(msg, ##args) +#define camsrc_assert(condition) { \ + if (!(condition)) { \ + GST_ERROR("failed [%s]", #condition); \ + } \ +} + +/* + * Values for internal + */ +enum camerasrc_op_mode_t { + CAMERASRC_OP_PREVIEW = 0, + CAMERASRC_OP_CAPTURE, + CAMERASRC_OP_VIDEO, + CAMERASRC_OP_REGISTER_VALUE, + CAMERASRC_OP_NUM, +}; + +/* + * Values for internal + */ +enum camerasrc_ctrl_property_t{ + CAMERASRC_CTRL_SUPPORT = 0, + CAMERASRC_CTRL_MAX_VALUE, + CAMERASRC_CTRL_MIN_VALUE, + CAMERASRC_CTRL_CID_VALUE, + CAMERASRC_CTRL_CURRENT_VALUE, + CAMERASRC_CTRL_PROPERTY_NUM, +}; + +/* + * Values for internal + */ +enum camerasrc_quality_t{ + CAMERASRC_QUALITY_NORMAL = 0, + CAMERASRC_QUALITY_HIGH, + CAMERASRC_QUALITY_NUM, +}; + +enum camerasrc_dev_recog_t{ + CAMERASRC_DEV_RECOG_ID = 0, + CAMERASRC_DEV_RECOG_INDEX, + CAMERASRC_DEV_RECOG_NUM, +}; + +/** + * Phase, camerasrc consist of two phase, running and non-running. + */ +typedef enum { + CAMERASRC_PHASE_RUNNING = 0, + CAMERASRC_PHASE_NON_RUNNING, + CAMERASRC_PHASE_NUM, +} _camerasrc_phase_t; + +typedef enum { + CAMERASRC_MISC_STILL_SIGNAL = 0, + CAMERASRC_MISC_SKIP_FRAME, + CAMERASRC_MISC_FUNC_NUM, +} _camerasrc_misc_func_t; + +typedef enum{ + _CAMERASRC_CMD_AF_CONTROL = 0, + _CAMERASRC_CMD_AF_AREA, + _CAMERASRC_CMD_STROBE_MODE, + _CAMERASRC_CMD_FACEDETECTION, + _CAMERASRC_CMD_SHUTTER_SPEED, + _CAMERASRC_CMD_SUPPORT_EMBED_EXIF, + _CAMERASRC_CMD_SUPPORT_JPEG_ENCODING, + _CAMERASRC_CMD_CHECK_ESD, + _CAMERASRC_CMD_JPEG_COMPRESS_RATIO, + _CAMERASRC_CMD_JPEG_LENGTH, + _CAMERASRC_CMD_JPEG_THMBNL_LENGTH, + _CAMERASRC_CMD_JPEG_THMBNL_OFFSET, + _CAMERASRC_CMD_JPEG_SCRNL_LENGTH, + _CAMERASRC_CMD_JPEG_SCRNL_OFFSET, + _CAMERASRC_CMD_EXPOSURE_VALUE, + _CAMERASRC_CMD_ESD_CHECK, + _CAMERASRC_CMD_FRAME_DATA, + _CAMERASRC_CMD_EXIF_INFO, + _CAMERASRC_CMD_CTRL, + _CAMERASRC_CMD_ROTATION, + _CAMERASRC_CMD_SENSOR_MODE, + _CAMERASRC_CMD_VFLIP, + _CAMERASRC_CMD_HFLIP, + _CAMERASRC_CMD_NUM, +}_camsrc_cmd_t; + +typedef struct{ + int cid; + int value; +} _camerasrc_ctrl_t; + +enum { + _CAMERASRC_FACEDETECTION_START = 0, + _CAMERASRC_FACEDETECTION_STOP, + _CAMERASRC_FACEDETECTION_NUM, +}; + +enum { + _CAMERASRC_AF_START = 0, + _CAMERASRC_AF_STOP, + _CAMERASRC_AF_RELEASE, + _CAMERASRC_AF_INIT, + _CAMERASRC_AF_DESTROY, +}; + +// U T I L I T Y D E F I N I T I O N +/** + * Mapping device index - Device ID + */ +#define _CAMERASRC_GET_DEV_INDEX(dev_id) _camerasrc_dev_index[dev_id][CAMERASRC_DEV_RECOG_INDEX] +#define _CAMERASRC_GET_DEV_ID(dev_idx) _camerasrc_dev_index[dev_idx][CAMERASRC_DEV_RECOG_ID] + +/** + * For colorspace - pixel format combinability check + */ +#define _CAMERASRC_MATCH_COL_TO_PIX(dev_id, colorspace, pixel_fmt, quality) _camerasrc_match_col_to_pix[dev_id][colorspace][pixel_fmt][quality] + +/** + * For control capability check + */ +#define _CAMERASRC_CHK_SUPPORT_CONTROL(ctrl_id, dev_id) _camerasrc_ctrl_list[dev_id][ctrl_id][CAMERASRC_CTRL_SUPPORT] +#define _CAMERASRC_MAX_VALUE(ctrl_id, dev_id) _camerasrc_ctrl_list[dev_id][ctrl_id][CAMERASRC_CTRL_MAX_VALUE] +#define _CAMERASRC_MIN_VALUE(ctrl_id, dev_id) _camerasrc_ctrl_list[dev_id][ctrl_id][CAMERASRC_CTRL_MIN_VALUE] +#define _CAMERASRC_GET_CID(ctrl_id, dev_id) _camerasrc_ctrl_list[dev_id][ctrl_id][CAMERASRC_CTRL_CID_VALUE] +#define _CAMERASRC_GET_CURRENT_VALUE(ctrl_id, dev_id) _camerasrc_ctrl_list[dev_id][ctrl_id][CAMERASRC_CTRL_CURRENT_VALUE] +#define _CAMERASRC_SET_CURRENT_VALUE(ctrl_id, dev_id, value) _camerasrc_ctrl_list[dev_id][ctrl_id][CAMERASRC_CTRL_CURRENT_VALUE] = value + +/** + * Need miscellaneous function on operation? + */ +#define _CAMERASRC_NEED_MISC_FUNCTION(dev_id, operation, colorspace, misc_func) _camerasrc_misc_func_list[dev_id][operation][colorspace][misc_func] +#define _CAMERASRC_SUPPORT_AF(dev_id) _camerasrc_af_support[dev_id] + +/** + * Utility definitions + */ +#define CAMERASRC_SET_STATE(handle, state) { \ + handle->prev_state = handle->cur_state; \ + handle->cur_state = state; \ + camsrc_info("Set state [%d] -> [%d]", handle->prev_state, handle->cur_state); \ +} +#define CAMERASRC_SET_PHASE(handle, phase) handle->cur_phase = phase; +#define CAMERASRC_STATE(handle) (handle->cur_state) +#define CAMERASRC_PREV_STREAM_STATE(handle) -1 +#define CAMERASRC_PHASE(handle) (handle->cur_phase) +#define CAMERASRC_HANDLE(handle) ((camerasrc_handle_t*) handle) +#define CAMERASRC_CURRENT_DEV_ID(handle) (handle->dev_id) +#define CAMERASRC_IS_DEV_CLOSED(p) (p->dev_fd == -1 || p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) + +#define YUV422_SIZE(handle) ((handle->format.img_size.dim.height * handle->format.img_size.dim.width) << 1) +#define YUV420_SIZE(handle) ((handle->format.img_size.dim.height * handle->format.img_size.dim.width * 3) >> 1) +#define RGB565_SIZE(handle) ((handle->format.img_size.dim.height * handle->format.img_size.dim.width) << 1) + +#define ISO_APPROXIMATE_VALUE(iso_in, iso_approximated) { \ + if(iso_in > 8.909 && iso_in <= 11.22) iso_approximated = 10; \ + else if(iso_in > 11.22 && iso_in <= 14.14) iso_approximated = 12; \ + else if(iso_in > 14.14 && iso_in <= 17.82) iso_approximated = 16; \ + else if(iso_in > 17.82 && iso_in <= 22.45) iso_approximated = 20; \ + else if(iso_in > 22.45 && iso_in <= 28.28) iso_approximated = 25; \ + else if(iso_in > 28.28 && iso_in <= 35.64) iso_approximated = 32; \ + else if(iso_in > 35.64 && iso_in <= 44.90) iso_approximated = 40; \ + else if(iso_in > 44.90 && iso_in <= 56.57) iso_approximated = 50; \ + else if(iso_in > 56.57 && iso_in <= 71.27) iso_approximated = 64; \ + else if(iso_in > 71.27 && iso_in <= 89.09) iso_approximated = 80; \ + else if(iso_in > 89.09 && iso_in <= 112.2) iso_approximated = 100; \ + else if(iso_in > 112.2 && iso_in <= 141.4) iso_approximated = 125; \ + else if(iso_in > 141.4 && iso_in <= 178.2) iso_approximated = 160; \ + else if(iso_in > 178.2 && iso_in <= 224.5) iso_approximated = 200; \ + else if(iso_in > 224.5 && iso_in <= 282.8) iso_approximated = 250; \ + else if(iso_in > 282.8 && iso_in <= 356.4) iso_approximated = 320; \ + else if(iso_in > 356.4 && iso_in <= 449.0) iso_approximated = 400; \ + else if(iso_in > 449.0 && iso_in <= 565.7) iso_approximated = 500; \ + else if(iso_in > 565.7 && iso_in <= 712.7) iso_approximated = 640; \ + else if(iso_in > 712.7 && iso_in <= 890.9) iso_approximated = 800; \ + else if(iso_in > 890.9 && iso_in <= 1122) iso_approximated = 1000; \ + else if(iso_in > 1122 && iso_in <= 1414) iso_approximated = 1250; \ + else if(iso_in > 1414 && iso_in <= 1782) iso_approximated = 1600; \ + else if(iso_in > 1782 && iso_in <= 2245) iso_approximated = 2000; \ + else if(iso_in > 2245 && iso_in <= 2828) iso_approximated = 2500; \ + else if(iso_in > 2828 && iso_in <= 3564) iso_approximated = 3200; \ + else if(iso_in > 3564 && iso_in <= 4490) iso_approximated = 4000; \ + else if(iso_in > 4490 && iso_in <= 5657) iso_approximated = 5000; \ + else if(iso_in > 5657 && iso_in <= 7127) iso_approximated = 6400; \ + else if(iso_in > 7127 && iso_in <= 8909) iso_approximated = 8000; \ + else { \ + camsrc_warning("Invalid parameter(Maybe kernel failure).. give default value, 100");\ + iso_approximated = 100;\ + }\ +} + +#define PHOTOMETRY_MODE_TO_METERING_MODE(photometry_mode, metering_mode) { \ + if(photometry_mode == V4L2_PHOTOMETRY_MULTISEG) metering_mode = 1; \ + else if (photometry_mode == V4L2_PHOTOMETRY_CWA) metering_mode = 2; \ + else if (photometry_mode == V4L2_PHOTOMETRY_SPOT) metering_mode = 3; \ + else if (photometry_mode == V4L2_PHOTOMETRY_AFSPOT) metering_mode = 3; \ + else metering_mode = 1; \ +} + +#define CAMERASRC_EXIF_SHUTTERSPEED_VALUE_IN_APEX(NUM, DEN) (int)(-(log2((double)((double)NUM/(double)DEN)))) +#define CAMERASRC_EXIF_APERTURE_VALUE_IN_APEX(NUM, DEN) (int)(2 * (log2((double)((double)NUM/(double)DEN)))) + + +typedef void *(*camerasrc_signal_func_t) (camsrc_handle_t handle); +typedef int (*camerasrc_skip_frame_func_t) (camsrc_handle_t handle, long int timeout, int skip_frame); + +typedef struct _camerasrc_handle_t { + int is_async_open; + + /* device information */ + int dev_fd; + int cur_dev_id; + camerasrc_buffer_t alter_frame; + int check_esd; + int errnum; + int lens_rotation; /* physical rotation of lens */ + + /* state information */ + int prev_stream_state; + int prev_state; + int cur_state; + int cur_phase; + + /* image format information */ + int is_highquality; + int is_preset; + camerasrc_resol_name_t resolution; + camerasrc_format_t format; + + /* buffer information */ + camerasrc_io_method_t io_method; + camerasrc_usr_buf_t *present_buf; + int buffer_idx; + int num_buffers; + int queued_buffer_count; + int first_frame; + struct v4l2_buffer queued_buf_list[CAMERASRC_USRPTR_MAX_BUFFER_NUM]; + camerasrc_buffer_t *buffer; + camerasrc_buffer_t scrnl_buf; /* screennail buffer of captured JPEG image */ + + /* autofocusing information */ + camerasrc_af_mode_t cur_af_mode; + camerasrc_af_scan_range_t cur_af_range; + camerasrc_callback_t af_cb; + pthread_t focusing_thread; + pthread_cond_t af_wait_cond; + camerasrc_auto_focus_status_t af_status; + camerasrc_auto_focus_cmd_t af_cmd; + int af_dev_val; + void *af_usr_data; + int hold_af_after_capturing; + int af_init_called; /* whether af init was called after device open. */ + struct timeval set_af_area_time; /* for AF start delay after set AF area */ + + /* Jpg Still information */ + camerasrc_skip_frame_func_t skip_frame_func; + + /* Shutter & exposure value */ + int isAutoexposure; + + /* fps */ + camerasrc_frac_t timeperframe; + + /* sensor mode */ + camerasrc_sensor_mode_t sensor_mode; + + /* flip */ + int vflip; + int hflip; + + /* thread safe mechanism */ + pthread_mutex_t mutex; + pthread_mutex_t af_mutex; + pthread_cond_t cond; +} camerasrc_handle_t; + +typedef struct { + int (*_ioctl) (camerasrc_handle_t *handle, int request, void *arg); + int (*_ioctl_once) (camerasrc_handle_t *handle, int request, void *arg); + void *(*_run_autofocusing) (camerasrc_handle_t *handle); + int (*_skip_frame) (camerasrc_handle_t *handle, long int timeout, int skip_frame); + int (*_copy_frame) (camerasrc_handle_t *handle, camerasrc_buffer_t *src_buffer, camerasrc_buffer_t *dst_buffer, int isThumbnail); + int (*_set_cmd) (camerasrc_handle_t *handle, _camsrc_cmd_t cmd, void *value); + int (*_get_cmd) (camerasrc_handle_t *handle, _camsrc_cmd_t cmd, void *value); +} CAMERASRC_DEV_DEPENDENT_MISC_FUNC; + +#ifdef __cplusplus +} +#endif + +#endif /*__CAMERASRC_COMMON_H__*/ diff --git a/camerasrc/src/include/camerasrc-error.h b/camerasrc/src/include/camerasrc-error.h new file mode 100644 index 0000000..4ea8c7f --- /dev/null +++ b/camerasrc/src/include/camerasrc-error.h @@ -0,0 +1,140 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __CAMERASRC_ERROR_H__ +#define __CAMERASRC_ERROR_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * CAMSRC CLASS + */ +#define CAMERASRC_SUCCESS (0x00000000) /**< No Error */ +#define CAMERASRC_ERROR (0x80000000) /**< Error Class */ +#define CAMERASRC_WARING (0x70000000) /**< Waring Class */ + +/* + * Detail enumeration + */ +enum { + CAMSRC_IN_UNKNOWN = 0, + CAMSRC_IN_PARAMETER, + CAMSRC_IN_HANDLE, + CAMSRC_IN_POINTER, + CAMSRC_IN_VALUE, + CAMSRC_IN_OVERRUN, + CAMSRC_IN_UNDERRUN, + CAMSRC_IN_RANGE_OVER, + CAMSRC_IN_RANGE_UNDER, + CAMSRC_IN_MODE, + CAMSRC_IN_FORMAT, + CAMSRC_IN_CHANNEL, + CAMSRC_IN_SAMPLERATE, + CAMSRC_IN_LAYER, + CAMSRC_IN_ROTATE, + CAMSRC_IN_ALLOC, + CAMSRC_IN_INTERNAL, + /*Extra state for camera*/ + CAMSRC_IN_IO_CONTROL, + CAMSRC_IN_DEVICE_OPEN, + CAMSRC_IN_DEVICE_BUSY, + CAMSRC_IN_DEVICE_NOT_FOUND, + CAMSRC_IN_DEVICE_REGISTER_TROUBLE, + CAMSRC_IN_WAIT_RES, + CAMSRC_IN_SUPPORT, + CAMSRC_IN_STATE, + CAMSRC_IN_PRIVILEGE, + CAMSRC_IN_SECURITY_SERVICE, +}; + +/* + * CAMERASRC_WARNING + */ +#define CAMERASRC_WAR_INVALID_PARAMETER (CAMERASRC_WARING | CAMSRC_IN_PARAMETER) +#define CAMERASRC_WAR_INVALID_HANDLE (CAMERASRC_WARING | CAMSRC_IN_HANDLE) +#define CAMERASRC_WAR_INVALID_VALUE (CAMERASRC_WARING | CAMSRC_IN_VALUE) +#define CAMERASRC_WAR_INVALID_MODE (CAMERASRC_WARING | CAMSRC_IN_MODE) +#define CAMERASRC_WAR_INVALID_FORMAT (CAMERASRC_WARING | CAMSRC_IN_FORMAT) +#define CAMERASRC_WAR_INVALID_CHANNEL (CAMERASRC_WARING | CAMSRC_IN_CHANNEL) +#define CAMERASRC_WAR_INVALID_SAMPLERATE (CAMERASRC_WARING | CAMSRC_IN_SAMPLERATE) +#define CAMERASRC_WAR_INVALID_LAYER (CAMERASRC_WARING | CAMSRC_IN_LAYER) +#define CAMERASRC_WAR_INVALID_ROTATE (CAMERASRC_WARING | CAMSRC_IN_ROTATE) +#define CAMERASRC_WAR_NULL_POINTER (CAMERASRC_WARING | CAMSRC_IN_POINTER) +#define CAMERASRC_WAR_UNDERRUN (CAMERASRC_WARING | CAMSRC_IN_UNDERRUN) +#define CAMERASRC_WAR_OVERRUN (CAMERASRC_WARING | CAMSRC_IN_OVERRUN) +#define CAMERASRC_WAR_RANGE_OVER (CAMERASRC_WARING | CAMSRC_IN_RANGE_OVER) +#define CAMERASRC_WAR_RANGE_UNDER (CAMERASRC_WARING | CAMSRC_IN_RANGE_UNDER) +#define CAMERASRC_WAR_ALLOCATION (CAMERASRC_WARING | CAMSRC_IN_ALLOC) +#define CAMERASRC_WAR_INTERNAL (CAMERASRC_WARING | CAMSRC_IN_INTERNAL) +/*Extra warning for camera*/ +#define CAMERASRC_WAR_IO_CONTROL (CAMERASRC_WARING | CAMSRC_IN_IO_CONTROL) +#define CAMERASRC_WAR_DEVICE_OPEN (CAMERASRC_WARING | CAMSRC_IN_DEVICE_OPEN) +#define CAMERASRC_WAR_DEVICE_BUSY (CAMERASRC_WARING | CAMSRC_IN_DEVICE_BUSY) +#define CAMERASRC_WAR_DEVICE_NOT_FOUND (CAMERASRC_WARING | CAMSRC_IN_DEVICE_NOT_FOUND) +#define CAMERASRC_WAR_DEVICE_UNAVAILABLE (CAMERASRC_WARING | CAMSRC_IN_DEVICE_REGISTER_TROUBLE) +#define CAMERASRC_WAR_DEVICE_WAIT_TIMEOUT (CAMERASRC_WARING | CAMSRC_IN_WAIT_RES) +#define CAMERASRC_WAR_DEVICE_NOT_SUPPORT (CAMERASRC_WARING | CAMSRC_IN_SUPPORT) +#define CAMERASRC_WAR_INVALID_STATE_TRANSITION (CAMERASRC_WARING | CAMSRC_IN_STATE) + +/** + * CAMERASRC_ERROR + */ +#define CAMERASRC_ERR_INVALID_PARAMETER (CAMERASRC_ERROR | CAMSRC_IN_PARAMETER) +#define CAMERASRC_ERR_INVALID_HANDLE (CAMERASRC_ERROR | CAMSRC_IN_HANDLE) +#define CAMERASRC_ERR_INVALID_VALUE (CAMERASRC_ERROR | CAMSRC_IN_VALUE) +#define CAMERASRC_ERR_INVALID_MODE (CAMERASRC_ERROR | CAMSRC_IN_MODE) +#define CAMERASRC_ERR_INVALID_FORMAT (CAMERASRC_ERROR | CAMSRC_IN_FORMAT) +#define CAMERASRC_ERR_INVALID_CHANNEL (CAMERASRC_ERROR | CAMSRC_IN_CHANNEL) +#define CAMERASRC_ERR_INVALID_SAMPLERATE (CAMERASRC_ERROR | CAMSRC_IN_SAMPLERATE) +#define CAMERASRC_ERR_INVALID_LAYER (CAMERASRC_ERROR | CAMSRC_IN_LAYER) +#define CAMERASRC_ERR_INVALID_ROTATE (CAMERASRC_ERROR | CAMSRC_IN_ROTATE) +#define CAMERASRC_ERR_NULL_POINTER (CAMERASRC_ERROR | CAMSRC_IN_POINTER) +#define CAMERASRC_ERR_UNDERRUN (CAMERASRC_ERROR | CAMSRC_IN_UNDERRUN) +#define CAMERASRC_ERR_OVERRUN (CAMERASRC_ERROR | CAMSRC_IN_OVERRUN) +#define CAMERASRC_ERR_RANGE_OVER (CAMERASRC_ERROR | CAMSRC_IN_RANGE_OVER) +#define CAMERASRC_ERR_RANGE_UNDER (CAMERASRC_ERROR | CAMSRC_IN_RANGE_UNDER) +#define CAMERASRC_ERR_ALLOCATION (CAMERASRC_ERROR | CAMSRC_IN_ALLOC) +#define CAMERASRC_ERR_INTERNAL (CAMERASRC_ERROR | CAMSRC_IN_INTERNAL) +#define CAMERASRC_ERR_UNKNOWN (CAMERASRC_ERROR | CAMSRC_IN_UNKNOWN) /**< unknown error */ +/*Extra warning for camera*/ +#define CAMERASRC_ERR_IO_CONTROL (CAMERASRC_ERROR | CAMSRC_IN_IO_CONTROL) +#define CAMERASRC_ERR_DEVICE_OPEN (CAMERASRC_ERROR | CAMSRC_IN_DEVICE_OPEN) +#define CAMERASRC_ERR_DEVICE_BUSY (CAMERASRC_ERROR | CAMSRC_IN_DEVICE_BUSY) +#define CAMERASRC_ERR_DEVICE_NOT_FOUND (CAMERASRC_ERROR | CAMSRC_IN_DEVICE_NOT_FOUND) +#define CAMERASRC_ERR_DEVICE_UNAVAILABLE (CAMERASRC_ERROR | CAMSRC_IN_DEVICE_REGISTER_TROUBLE) +#define CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT (CAMERASRC_ERROR | CAMSRC_IN_WAIT_RES) +#define CAMERASRC_ERR_DEVICE_NOT_SUPPORT (CAMERASRC_ERROR | CAMSRC_IN_SUPPORT) +#define CAMERASRC_ERR_INVALID_STATE (CAMERASRC_ERROR | CAMSRC_IN_STATE) +#define CAMERASRC_ERR_PRIVILEGE (CAMERASRC_ERROR | CAMSRC_IN_PRIVILEGE) +#define CAMERASRC_ERR_SECURITY_SERVICE (CAMERASRC_ERROR | CAMSRC_IN_SECURITY_SERVICE) + + +#define CAMERASRC_IS_FAIL(_A_) (CAMERASRC_ERROR & (_A_)) + +#ifdef __cplusplus +} +#endif + +#endif /* __CAMERASRC_ERROR_H__ */ diff --git a/camerasrc/src/include/camerasrc-internal.h b/camerasrc/src/include/camerasrc-internal.h new file mode 100644 index 0000000..6b97589 --- /dev/null +++ b/camerasrc/src/include/camerasrc-internal.h @@ -0,0 +1,247 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __CAMERASRC_INTERNAL_H__ +#define __CAMERASRC_INTERNAL_H__ + +#include "camerasrc-common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Video 4 linux control ID definitions (Extended by kernel team) + * extended pixel format for V4l2 + */ + + +/** + * Miscellaneous camera-dependent definitions + */ +#define CAMERASRC_DEV_INDEX_MAX 2 +#define CAMERASRC_AF_TOTALTIME 5000000 +#define CAMERASRC_AF_INTERVAL 20000 +#define CAMERASRC_AF_STOP_INTERVAL 10000 +#define CAMERASRC_MEGA_DEV_NAME "/dev/video0" +#define CAMERASRC_VGA_DEV_NAME "/dev/video0" +#define CAMERASRC_JPG_STILL_H_SYNC 2048 +#define CAMERASRC_JPG_STILL_V_SYNC 2048 +#define CAMERASRC_JPG_STILL_SKIP_FRAME 0 +#define CAMERASRC_RAW_STILL_THUMBNAIL_OFFSET 1689600 +#define CAMERASRC_JPG_STILL_THUMBNAIL_OFFSET 0x1bd000 +#define CAMERASRC_MAX_MAIN_JPEG_SIZE CAMERASRC_JPG_STILL_H_SYNC * CAMERASRC_JPG_STILL_V_SYNC /* 0x1bd000 */ +#define CAMERASRC_MAX_THM_JPEG_SIZE 0 +#define CAMERASRC_PREVIEW_BUFFER_NUM 6 +#define CAMERASRC_VIDEO_BUFFER_NUM 7 +#define CAMERASRC_STILL_BUFFER_NUM 1 +#define CAMERASRC_YUV_THMBNL_SIZE 320 * 240 * 2 +#define CAMERASRC_TIMEOUT_CRITICAL_VALUE 5000 +#define CAMERASRC_PRE_AF_INTERVAL 0 +#define CAMERASRC_REGISTER_SET_RETRY_NO 200 +#define CAMERASRC_V4L2_PREVIEW_PIX_FMT_DEFAULT V4L2_PIX_FMT_YUYV +#define CAMERASRC_V4L2_JPEG_CAPTURE_PIX_FMT_DEFAULT V4L2_PIX_FMT_JPEG +#define CAMERASRC_V4L2_JPG_YUV_CAPTURE_PIX_FMT_DEFAULT V4L2_PIX_FMT_MJPEG +#define CAMERASRC_V4L2_RGB_CAPTURE_PIX_FMT_DEFAULT V4L2_PIX_FMT_RGB565 + +#define CAMERASRC_SYNC_KEY_PATH "FUJITSU_M5MOLS" +#define CAMERASRC_SYNC_KEY_PREFIX 0x55 + +#define CAMERASRC_AF_DELAY_AFTER_SET_AF_AREA 350 /* msec */ + +#define _CAMERASRC_EXIF_COMP_CONF (0x00000000) | (0x00000001) | (0x00000002 << 8) | (0x00000003 << 16) /* Y Cb Cr - */ +#define _CAMERASRC_EXIF_COLORSPACE 0x00000001 +#define _CAMERASRC_EXIF_FOCAL_LEN_NUM 454 +#define _CAMERASRC_EXIF_FOCAL_LEN_DEN 100 +#define _CAMERASRC_EXIF_F_NUM_NUM 28 +#define _CAMERASRC_EXIF_F_NUM_DEN 10 +#define _CAMERASRC_EXIF_MAX_F_NUM_NUM_IN_APEX 3 + +#define _CAMERASRC_CMD_SUPPORT_EMBED_EXIF_DEF 0 + +/* + * |------------------------------------------------------------| + * | | Primary | Secondary | Extension| Unknown | + * |------------------------------------------------------------| + * | Index | 2 | 1 | 0 | -1 | + * |------------------------------------------------------------| + * + * |------------------------------------------------------------| + * | | 0 | 1 | 2 | 3 | + * |------------------------------------------------------------| + * | ID | Unknown | Secondary | Primary | Extension | + * |------------------------------------------------------------| + */ + +static int _camerasrc_dev_index[CAMERASRC_DEV_ID_NUM][CAMERASRC_DEV_RECOG_NUM] = +{ + {CAMERASRC_DEV_ID_SECONDARY, 0}, + {CAMERASRC_DEV_ID_PRIMARY, 1}, + {CAMERASRC_DEV_ID_EXTENSION, 2}, + {CAMERASRC_DEV_ID_UNKNOWN, -1}, +}; + + +/** + * preset size index + * |-------------------------------------------------------------------------| + * | | | YUV422P | YUV420P | SRGGB8 | SRGGB10 | + * |-------------------------------------------------------------------------| + * | | Highquality | O | X | X | X | + * | RAW |-----------------------------------------------------------| + * | | Normal | O | X | X | X | + * |-------------------------------------------------------------------------| + * | | Highquality | X | X | O | X | + * | JPEG |-----------------------------------------------------------| + * | | Normal | X | X | X | X | + * |-------------------------------------------------------------------------| + */ +static char _camerasrc_match_col_to_pix[CAMERASRC_DEV_ID_EXTENSION][CAMERASRC_COL_NUM][CAMERASRC_PIX_NUM][CAMERASRC_QUALITY_NUM] = +{ + {/*SECONDARY*/ + /*422P, 420P, SRGGB8, SRGGB10*/ + {{0x1,0x0}, {0x0,0x0}, {0x0,0x0}, {0x0,0x0}}, /**< RAW */ + {{0x0,0x0}, {0x0,0x0}, {0x0,0x0}, {0x0,0x0}}, /**< JPG */ + }, + {/*PRIMARY*/ + /*422P, 420P, SRGGB8, SRGGB10 */ + {{0x1,0x0}, {0x0,0x0}, {0x0,0x0}, {0x0,0x0}}, /**< RAW */ + {{0x0,0x0}, {0x0,0x0}, {0x0,0x1}, {0x0,0x1}}, /**< JPG */ + }, +}; /* {Normal quality, High quality} */ + +/* + * |--------------------------------------------------------------------------------| + * | | Support | MAX value | MIN value | CID | + * |--------------------------------------------------------------------------------| + * | Brightness | 1 | 8 | 0 | V4L2_CID_BRIGHTNESS | + * |--------------------------------------------------------------------------------| + * | Contrast | 1 | 9 | 0 | -1 | + * |--------------------------------------------------------------------------------| + * | Digital zoom | 1 | 100 | 0 | V4L2_CID_BASE+29 | + * |--------------------------------------------------------------------------------| + * | Optical zoom | 0 | -1 | -1 | -1 | + * |--------------------------------------------------------------------------------| + * | White balance | 1 | 9 | 0 | V4L2_CID_DO_WHITE_BALANCE | + * |--------------------------------------------------------------------------------| + * | Color tone | 1 | 14 | 0 | V4L2_CID_BASE+28 | + * |--------------------------------------------------------------------------------| + * | Program mode | 0 | -1 | -1 | -1 | + * |--------------------------------------------------------------------------------| + * | Flip | 1 | 1 | 0 | V4L2_CID_FLIP | + * |--------------------------------------------------------------------------------| + * | Flash | 1 | 2 | 0 | V4L2_CID_BASE+32 | + * |--------------------------------------------------------------------------------| + */ + +/* CUSTOM V4L2 CONTROL ID DEFINITIONS */ + +#define CAM_AF_STATUS_ONGOING 0 +#define CAM_AF_STATUS_FOCUSED 1 +#define CAM_AF_STATUS_FAILED 2 + +enum { + CAMERASRC_SENSOR_AF_STATUS_ONGOING = CAM_AF_STATUS_ONGOING, + CAMERASRC_SENSOR_AF_STATUS_FOCUSED = CAM_AF_STATUS_FOCUSED, + CAMERASRC_SENSOR_AF_STATUS_FAILED = CAM_AF_STATUS_FAILED +}; + +/* FACE_DETECTION CMD & STATUS */ +#define V4L2_CID_FACE_DETECTION (V4L2_CID_PRIVATE_BASE + 38) + +#define CAM_FACE_DETECTION_OFF 0 +#define CAM_FACE_DETECTION_ON 1 + +/* ESD INTERRUPT CHECK */ +/*To read interrupt status of "Data output stop from sensor"*/ +#define V4L2_CID_ESD_INT (V4L2_CID_PRIVATE_BASE + 40) + +#define CAM_ESD_INT_NORMAL 0 +#define CAM_ESD_INT_TROUBLE 1 + + +/* CUSTOM V4L2 CONTROL ID DEFINITIONS (END) */ +static int _camerasrc_ctrl_list[CAMERASRC_DEV_ID_EXTENSION][CAMERASRC_CTRL_NUM][CAMERASRC_CTRL_PROPERTY_NUM] = +{ /* { SUPPORT, MAX_VALUE, MIN_VALUE, CID, CURRENT_VALUE } */ + { /* Primary camera */ + {-1, 4, -4, V4L2_CID_EXPOSURE, 0}, /* Brightness */ + {-1, 3, -3, V4L2_CID_CONTRAST, 0}, /* Contrast */ + {-1, 30, 0, V4L2_CID_CAMERA_ZOOM, 0}, /* Digital zoom */ + {0, -1, -1, -1, -1}, /* Optical zoom */ + {-1, CAMERASRC_WHITEBALANCE_HORIZON, CAMERASRC_WHITEBALANCE_AUTO, V4L2_CID_WHITE_BALANCE_PRESET, CAMERASRC_WHITEBALANCE_AUTO}, /* White balance */ + {-1, CAMERASRC_COLORTONE_ANTIQUE, CAMERASRC_COLORTONE_NONE, V4L2_CID_COLORFX, CAMERASRC_COLORTONE_NONE}, /* Colortone */ + {-1, CAMERASRC_PROGRAM_MODE_BACK_LIGHT, CAMERASRC_PROGRAM_MODE_NORMAL, V4L2_CID_CAMERA_SCENE_MODE, CAMERASRC_PROGRAM_MODE_NORMAL}, /* program mode */ + {0, -1, -1, -1, -1}, /* Flip. V4L2_CID_VFLIP/HFLIP */ + {0, -1, -1, -1, -1}, /* PARTCOLOR_SRC */ + {0, -1, -1, -1, -1}, /* PARTCOLOR_DST */ + {0, -1, -1, -1, -1}, /* PARTCOLOR_MODE */ + {-1, 3, 0, V4L2_CID_CAM_STABILIZE, 0}, /* ANTI_HANDSHAKE */ + {-1, 2, 0, V4L2_CID_CAM_DR, 0}, /* WIDE_DYNAMIC_RANGE */ + {-1, 3, -3, V4L2_CID_SATURATION, 0}, /* SATURATION */ + {-1, 3, -3, V4L2_CID_SHARPNESS, 0}, /* SHARPNESS */ + {-1, -1, -1, V4L2_CID_CAMERA_ISO, -1}, /* ISO */ + {-1, -1, -1, V4L2_CID_CAMERA_METERING, -1}, /* PHOTOMETRY */ + }, + { /* Secondary camera */ + {0, -1, -1, V4L2_CID_CAMERA_BRIGHTNESS, -1}, /* Brightness */ + {0, -1, -1, V4L2_CID_CONTRAST, -1}, /* Contrast */ + {0, -1, -1, V4L2_CID_ZOOM_ABSOLUTE, -1}, /* Digital zoom */ + {0, -1, -1, -1, -1}, /* Optical zoom */ + {0, -1, -1, V4L2_CID_WHITE_BALANCE_PRESET, -1},/* White balance */ + {0, -1, -1, V4L2_CID_COLORFX, -1}, /* Colortone */ + {0, -1, -1, V4L2_CID_CAMERA_SCENE_MODE, -1}, /* program mode */ + {0, -1, -1, -1, -1}, /* Flip */ + {0, -1, -1, -1, -1}, /* PARTCOLOR_SRC */ + {0, -1, -1, -1, -1}, /* PARTCOLOR_DST */ + {0, -1, -1, -1, -1}, /* PARTCOLOR_MODE */ + {0, -1, -1, V4L2_CID_CAM_STABILIZE, -1}, /* ANTI_HANDSHAKE */ + {0, -1, -1, V4L2_CID_CAM_DR, -1}, /* WIDE_DYNAMIC_RANGE */ + {0, -1, -1, V4L2_CID_SATURATION, -1}, /* SATURATION */ + {0, -1, -1, V4L2_CID_SHARPNESS, -1}, /* SHARPNESS */ + {0, -1, -1, V4L2_CID_CAMERA_ISO, -1}, /* ISO */ + {0, -1, -1, V4L2_CID_CAMERA_METERING, -1}, /* PHOTOMETRY */ + }, +}; + +static char _camerasrc_misc_func_list[CAMERASRC_DEV_ID_EXTENSION][CAMERASRC_OP_REGISTER_VALUE][CAMERASRC_COL_NUM][CAMERASRC_MISC_FUNC_NUM] = +{ + {/*Primary*/ + /*Raw, JPG*/ + {{0x0,0x1}, {0x0,0x0}}, /*Preview*/ + {{0x0,0x1}, {0x0,0x0}}, /*Capture*/ + {{0x0,0x1}, {0x0,0x0}}, /*Video*/ + }, + {/*Secondary*/ + {{0x0,0x0}, {0x0,0x0}}, /*Preview*/ + {{0x0,0x0}, {0x0,0x0}}, /*Capture*/ + {{0x0,0x0}, {0x0,0x0}}, /*Video*/ + }/*{{Signal,Skip}, {Signal,Skip}}*/ +}; + +static int _camerasrc_af_support[CAMERASRC_DEV_ID_NUM] = {1, 0, 0, 0}; + +#ifdef __cplusplus +} +#endif + +#endif /*__CAMERASRC_INTERNAL_H__*/ diff --git a/camerasrc/src/include/camerasrc.h b/camerasrc/src/include/camerasrc.h new file mode 100644 index 0000000..2917f29 --- /dev/null +++ b/camerasrc/src/include/camerasrc.h @@ -0,0 +1,1488 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __CAMERASRC_H__ +#define __CAMERASRC_H__ + +#include <stdint.h> /* to use uint64_t */ +#include <camerasrc-error.h> +#include <mm_ta.h> +#ifdef __cplusplus +extern "C" { +#endif + +/* GENERAL DEFINITIONS */ +/** + * Type definition of av camera src handle. + */ +typedef void *camsrc_handle_t; + + +/* ENUMERATION DEFINITIONS */ +/*! @enum camerasrc_state_t + * @brief Enumeration type for state transition + */ +typedef enum { + CAMERASRC_STATE_NONE = 0, + CAMERASRC_STATE_CREATED, + CAMERASRC_STATE_REALIZED, + CAMERASRC_STATE_READY, + CAMERASRC_STATE_PREVIEW, + CAMERASRC_STATE_STILL, + CAMERASRC_STATE_VIDEO, + CAMERASRC_STATE_UNREALIZED, + CAMERASRC_STATE_DESTROYED, + CAMERASRC_STATE_AF_IN_PROGRESS, +}camerasrc_state_t; + +/*! @enum camerasrc_dev_id_t + * @brief Enumeration type for camera device ID + * + * Devices will be managed by this IDs. (Independent with device index of V4L2) + */ +typedef enum { + CAMERASRC_DEV_ID_PRIMARY, /**< Higher resolution camera*/ + CAMERASRC_DEV_ID_SECONDARY, /**< Lower resolution camera*/ + CAMERASRC_DEV_ID_EXTENSION, /**< reserved for extension*/ + CAMERASRC_DEV_ID_UNKNOWN, /**< reserved for extension*/ + CAMERASRC_DEV_ID_NUM, /**< Number of IDs*/ +}camerasrc_dev_id_t; + +typedef enum { + CAMERASRC_COLOR_VIOLET = 0, + CAMERASRC_COLOR_PURPLE, + CAMERASRC_COLOR_MAGENTA_1, + CAMERASRC_COLOR_MAGENTA_2, + CAMERASRC_COLOR_RED_1, + CAMERASRC_COLOR_RED_2, + CAMERASRC_COLOR_BROWN, + CAMERASRC_COLOR_YELLOW, + CAMERASRC_COLOR_GREEN_1, + CAMERASRC_COLOR_GREEN_2, + CAMERASRC_COLOR_GREEN_3, + CAMERASRC_COLOR_GREEN_4, + CAMERASRC_COLOR_COBALT_BLUE, + CAMERASRC_COLOR_CYAN, + CAMERASRC_COLOR_BLUE_1, + CAMERASRC_COLOR_BLUE_2, + CAMERASRC_COLOR_GRAY, + CAMERASRC_COLOR_NUM, +}camerasrc_color_t; + +typedef enum { + CAMERASRC_PARTCOLOR_MODE_NONE = 0, + CAMERASRC_PARTCOLOR_MODE_SWAP, + CAMERASRC_PARTCOLOR_MODE_ACCENT, + CAMERASRC_PARTCOLOR_MODE_NUM, +}camerasrc_partcolor_mode_t; + +/*! @enum camerasrc_ctrl_t + * @brief Enumeration type for camera controls + * + * Special control entries for camera effects + * + * @remark Strobo can be controlled by this entry and ::camerasrc_set_strobo_status + */ +typedef enum { + CAMERASRC_CTRL_BRIGHTNESS = 0, /**< Brightness control entry*/ + CAMERASRC_CTRL_CONTRAST, /**< Contrast control entry*/ + CAMERASRC_CTRL_DIGITAL_ZOOM, /**< Digital zoom control entry*/ + CAMERASRC_CTRL_OPTICAL_ZOOM, /**< Optical zoom control entry*/ + CAMERASRC_CTRL_WHITE_BALANCE, /**< White balance control entry*/ + CAMERASRC_CTRL_COLOR_TONE, /**< Color tone control entry*/ + CAMERASRC_CTRL_PROGRAM_MODE, /**< Program mode control entry*/ + CAMERASRC_CTRL_FLIP, /**< Flip control entry*/ + CAMERASRC_CTRL_PARTCOLOR_SRC, /**< Partcolor effect source */ + CAMERASRC_CTRL_PARTCOLOR_DST, /**< Partcolor effect destination */ + CAMERASRC_CTRL_PARTCOLOR_MODE, /**< Partcolor effect mode */ + CAMERASRC_CTRL_ANTI_HANDSHAKE, /**< Anti-handshake control, 0:OFF / 1:ON / 2:AUTO / 3:MOVIE */ + CAMERASRC_CTRL_WIDE_DYNAMIC_RANGE, /**< wide dynamic control, 0:OFF / 1:ON / 2:AUTO */ + CAMERASRC_CTRL_SATURATION, /**< Saturation value control */ + CAMERASRC_CTRL_SHARPNESS, /**< Sharpness value control */ + CAMERASRC_CTRL_ISO, /**< Sensor sensitivity*/ + CAMERASRC_CTRL_PHOTOMETRY, /**< Exposure mode*/ + CAMERASRC_CTRL_NUM, /**< Number of Controls*/ +}camerasrc_ctrl_t; + +/*! @enum camerasrc_af_mode_t + * @brief AF operation mode + */ +typedef enum { + CAMERASRC_AF_MODE_AUTO = 0, /**< Auto Focus */ + CAMERASRC_AF_MODE_MANUAL, /**< Manual Focus */ + CAMERASRC_AF_MODE_PAN, /**< Pan Focus */ + CAMERASRC_AF_MODE_TOUCH_AUTO, /**< Touch Auto Focus */ + CAMERASRC_AF_MODE_CONTINUOUS, /**< Continuous Focus */ + CAMERASRC_AF_MODE_NUM, /**< Number of AF modes */ +}camerasrc_af_mode_t; + +/*! @enum camerasrc_af_scan_range_t + * @brief AF scan range + * AF scan range + */ +typedef enum { + CAMERASRC_AF_RANGE_NORMAL = 0, /**< Scan autofocus in normal range */ + CAMERASRC_AF_RANGE_MACRO, /**< Scan autofocus in macro range(close distance) */ + CAMERASRC_AF_RANGE_FULL, /**< Scan autofocus in full range(all range scan, limited by dev spec) */ + CAMERASRC_AF_RANGE_NUM, /**< Number of AF range types */ +}camerasrc_af_scan_range_t; + +/*! @enum camerasrc_resol_name_t + * @brief Enumeration type of resolution settings based on traditional resolution name + * Means pixel order of contents. + * @remark In the Grandprix, only YUV422P & RGGB8 is used + */ +typedef enum { + CAMERASRC_RESOL_QQCIF = 0, /**< 88 x 72 */ + CAMERASRC_RESOL_QQVGA, /**< 160 x 120 */ + CAMERASRC_RESOL_QCIF, /**< 176 x 144 */ + CAMERASRC_RESOL_QVGA, /**< 320 x 240 */ + CAMERASRC_RESOL_CIF, /**< 352 x 288 */ + CAMERASRC_RESOL_VGA, /**< 640 x 480 */ + CAMERASRC_RESOL_WVGA, /**< 800 x 480 */ + CAMERASRC_RESOL_SVGA, /**< 800 x 600 */ + CAMERASRC_RESOL_WSXGA, /**< 1280 x 960 (1M) */ + CAMERASRC_RESOL_UXGA, /**< 1600 x 1200 (2M) */ + CAMERASRC_RESOL_QXGA, /**< 2048 x 1536 (3M) */ + CAMERASRC_RESOL_WQSXGA, /**< 2560 x 1920 (5M) */ + CAMERASRC_RESOL_720P, /**< 1280 x 720 (720P) */ + CAMERASRC_RESOL_WQVGA, /**< 400 x 240 */ + CAMERASRC_RESOL_RQVGA, /**< 240 x 320 */ + CAMERASRC_RESOL_RWQVGA, /**< 240 x 400 */ + CAMERASRC_RESOL_QVGA_60FPS, /**< 320 x 240 60FPS(Slow motion I) */ + CAMERASRC_RESOL_QVGA_120FPS, /**< 320 x 240 60FPS(Slow motion II) */ + CAMERASRC_RESOL_NUM, +}camerasrc_resol_name_t; + +/*! @enum camerasrc_pix_format_t + * @brief Means order of pixel of contents + * Means pixel order of contents. + * @remark In the Grandprix, only YUV422P & RGGB8 is used + */ +typedef enum { + CAMERASRC_PIX_NONE = -1, /**< Default value or Not supported */ + CAMERASRC_PIX_YUV422P = 0, /**< Pixel format like YYYYYYYYUUUUVVVV*/ + CAMERASRC_PIX_YUV420P, /**< Pixel format like YYYYYYYYUUVV*/ + CAMERASRC_PIX_YUV420, /**< Pixel format like YYYYYYYYUVUV*/ + CAMERASRC_PIX_SN12, /**< YUV420 (interleaved, non-linear) */ + CAMERASRC_PIX_ST12, /**< YUV420 (interleaved, tiled, non-linear) */ + CAMERASRC_PIX_YUY2, /**< YUV 4:2:2 as for UYVY but with different component ordering within the u_int32 macropixel */ + CAMERASRC_PIX_RGGB8, /**< Raw RGB Pixel format like CCD order, a pixel consists of 8 bits, Actually means JPEG + JPEG image output */ + CAMERASRC_PIX_RGGB10, /**< Raw RGB Pixel format like CCD order, a pixel consists of 10 bits, Actually means JPEG + YUV image output */ + CAMERASRC_PIX_RGB565, /**< Raw RGB Pixel format like CCD order, a pixel consists of 10 bits, Actually means JPEG + YUV image output */ + CAMERASRC_PIX_UYVY, /**< YUV 4:2:2 */ + CAMERASRC_PIX_NV12, /**< YUV 4:2:0, 8-bit Y plane followed by an interleaved U/V plane with 2x2 subsampling */ + CAMERASRC_PIX_INTERLEAVED, /**< JPEG/YUYV interleaved data format for zero shutter lag */ + CAMERASRC_PIX_NUM, /**< Number of pixel formats*/ +}camerasrc_pix_format_t; + +/*! @enum camerasrc_colorspace_t + * @brief Means stored order or compressed status of image. + * Means stored order or compressed status of image. supplements of camerasrc_pix_format_t + * + * @note RAW means RGB/YUV pixel data, JPEG means compressed JPG file with marker information(header) + */ +typedef enum { + CAMERASRC_COL_NONE = -1, /**< Default value or Not supported */ + CAMERASRC_COL_RAW, /**< Non-compressed RGB/YUV pixel data*/ + CAMERASRC_COL_JPEG, /**< Compressed jpg data*/ + CAMERASRC_COL_NUM, /**< Number of colorspace data*/ +}camerasrc_colorspace_t; + +/*! @enum camerasrc_auto_focus_status_t + * @brief AF status + * AF status + */ +typedef enum { + CAMERASRC_AUTO_FOCUS_STATUS_RELEASED, /**< AF status released.*/ + CAMERASRC_AUTO_FOCUS_STATUS_ONGOING, /**< AF in progress*/ + CAMERASRC_AUTO_FOCUS_STATUS_NUM, /**< Number of AF status*/ +}camerasrc_auto_focus_status_t; + +/*! @enum camerasrc_auto_focus_cmd_t + * @brief AF status + * AF status + */ +typedef enum { + CAMERASRC_AUTO_FOCUS_CMD_NULL, /**< Null command.*/ + CAMERASRC_AUTO_FOCUS_CMD_START, /**< Start AF.*/ + CAMERASRC_AUTO_FOCUS_CMD_STOP, /**< Stop AF.*/ + CAMERASRC_AUTO_FOCUS_CMD_KILL, /**< Kill AF thread.*/ + CAMERASRC_AUTO_FOCUS_CMD_NUM, /**< Number of AF command*/ +}camerasrc_auto_focus_cmd_t; + +/*! @enum camerasrc_auto_focus_result_t + * @brief AF status + * AF status + */ +typedef enum { + CAMERASRC_AUTO_FOCUS_RESULT_FOCUSED = 2, /**< Focused.*/ + CAMERASRC_AUTO_FOCUS_RESULT_FAILED, /**< AF failed.*/ + CAMERASRC_AUTO_FOCUS_RESULT_NUM, /**< Number of AF result*/ +}camerasrc_auto_focus_result_t; + +/*! @enum camerasrc_ae_lock_t + * @brief + */ +typedef enum { + CAMERASRC_AE_LOCK = 0, + CAMERASRC_AE_UNLOCK, + CAMERASRC_AE_NUM, +}camerasrc_ae_lock_t; + +/*! @enum camerasrc_io_method_t + * @brief + */ +typedef enum { + CAMERASRC_IO_METHOD_READ= 0, + CAMERASRC_IO_METHOD_MMAP, + CAMERASRC_IO_METHOD_USRPTR, + CAMERASRC_IO_METHOD_NUM, +}camerasrc_io_method_t; + +/*! @enum camerasrc_buffer_queued_status + * @brief + */ +typedef enum { + CAMERASRC_BUFFER_QUEUED = 0, + CAMERASRC_BUFFER_DEQUEUED = 1, +}camerasrc_buffer_queued_status; + + +/* STRUCTURE DEFINITIONS */ + +typedef struct _camerasrc_rect_t { + int x; + int y; + int width; + int height; +} camerasrc_rect_t; + +/*! @struct camsrc_frac_t + * @brief Time per frame or frame per second will be expressed by this structure + * Time per frame or frame per second will be expressed by this structure + */ +typedef struct _camerasrc_frac_t { + int numerator; /**< Upper number of fraction*/ + int denominator; /**< Lower number of fraction*/ +} camerasrc_frac_t; + +/*! @struct camerasrc_buffer_t + * @brief data buffer + * Image data buffer + */ +typedef struct _camerasrc_buffer_t { + unsigned int length; /**< Size of stored data*/ + unsigned char* start; /**< Start address of data*/ + camerasrc_buffer_queued_status queued_status; /**< Queued or Dequeued status */ +} camerasrc_buffer_t; + +/*! @struct camerasrc_usr_buf_t + * @brief data buffer set to present usrptr buffer to camsrctem + * Image data buffer set + */ +typedef struct { + camerasrc_buffer_t* present_buffer; + unsigned int num_buffer; +} camerasrc_usr_buf_t; + +/*! @struct camerasrc_dimension_t + * @brief For non-regular size resolution + * width and height can be set independently + */ +typedef struct _camerasrc_dimension_t { + int width; + int height; +} camerasrc_dimension_t; + +/*! @union camerasrc_size_t + * @brief Size can be expressed by resolution name(predefined) and dimension(x, y) + */ +typedef union _camerasrc_size_t { + camerasrc_resol_name_t res; /**< Predefined resolution name */ + camerasrc_dimension_t dim; /**< Dimensional expression */ +} camerasrc_size_t; + +/*! @struct camerasrc_format_t + * @brief Format description structure + * in/output format description structure just like v4l2_format + */ +typedef struct _camerasrc_format_t { + camerasrc_size_t img_size; + camerasrc_size_t thumb_size; /**< Thumbnail size. Only effective with CAMERASRC_PIX_RGGB8 or CAMERASRC_PIX_RGGB10 */ + camerasrc_pix_format_t pix_format; /**< pixel order format*/ + int num_planes; /**< bytes per a line*/ + int bytesperline; /**< bytes per a line*/ + int sizeimage; /**< size of whole image*/ + camerasrc_colorspace_t colorspace; /**< stored status of image*/ + unsigned int quality; /**< jpeg compress ratio*/ + unsigned int is_highquality_mode; /**< picture quality is high or normal */ + int rotation; /**< Rotation angle of camera input */ +} camerasrc_format_t; + +typedef struct _camerasrc_ctrl_query_t { + int support; /**<1: support, 0: Not support, -1: extra support(Non v4l2)*/ + int max; /**<Integer max value(includes enums)*/ + int min; /**<Integer min value(includes enums)*/ +}camerasrc_ctrl_query_t; + +typedef struct _camerasrc_exif_t { + /* Dynamic value */ + unsigned int exposure_time_numerator; /**< Exposure time, given in seconds */ + unsigned int exposure_time_denominator; + int shutter_speed_numerator; /**< Shutter speed, given in APEX(Additive System Photographic Exposure) */ + int shutter_speed_denominator; + int brigtness_numerator; /**< Value of brightness, before firing flash, given in APEX value */ + int brightness_denominator; + unsigned short int iso; /**< Sensitivity value of sensor */ + unsigned short int flash; /**< Whether flash is fired(1) or not(0) */ + int metering_mode; /**< metering mode in EXIF 2.2 */ + int exif_image_width; /**< Size of image */ + int exif_image_height; + int exposure_bias_in_APEX; /**< Exposure bias in APEX standard */ + int software_used; /**< Firmware S/W version */ + int focal_len_numerator; /**< Lens focal length (f = 4.5mm) */ + int focal_len_denominator; + int aperture_f_num_numerator; /**< Aperture value (f_num = 2.8) */ + int aperture_f_num_denominator; + int aperture_in_APEX; /**< Aperture value in APEX standard */ + int max_lens_aperture_in_APEX; /**< Max aperture value in APEX standard */ + + /* Fixed value */ + int component_configuration; /**< color components arrangement (YCbCr = 1230) */ + int colorspace; /**< colorspace information (sRGB=1) */ +}camerasrc_exif_t; + +typedef struct _camerasrc_frame_data_t { + int index; + unsigned int phyAddrY; + unsigned int phyAddrCbCr; + unsigned int virAddrY; + unsigned int virAddrCbCr; +}camerasrc_frame_data_t; + +/* JPEG/YUV interleaved data */ +#define INTERLEAVED_JPEG_MAX_SIZE (1024*1024*6) /* 6 Mbyte */ + +/* Fixed focal length and aperture f-number */ +#define CAMERASRC_PRIMARY_FOCAL_LEGNTH_NUM 397 +#define CAMERASRC_PRIMARY_FOCAL_LEGNTH_DENOM 100 +#define CAMERASRC_PRIMARY_F_NUMBER_NUM 265 +#define CAMERASRC_PRIMARY_F_NUMBER_DENOM 100 +#define CAMERASRC_SECONDARY_FOCAL_LEGNTH_NUM 273 +#define CAMERASRC_SECONDARY_FOCAL_LEGNTH_DENOM 100 +#define CAMERASRC_SECONDARY_F_NUMBER_NUM 28 +#define CAMERASRC_SECONDARY_F_NUMBER_DENOM 10 + +/* For Query functionalities + For Querying capabilities */ +/*! Use static size of structures for querying because of performance + */ + +#define MAX_NUM_FMT_DESC 32 +#define MAX_NUM_RESOLUTION 32 +#define MAX_NUM_AVAILABLE_TPF 16 +#define MAX_NUM_AVAILABLE_FPS 16 +#define MAX_NUM_CTRL_LIST_INFO 64 +#define MAX_NUM_CTRL_MENU 64 +#define MAX_SZ_CTRL_NAME_STRING 32 +#define MAX_SZ_DEV_NAME_STRING 32 + +enum{ + CAMERASRC_FCC_USE_NONE = 0x00000001, + CAMERASRC_FCC_USE_REC_PREVIEW = 0x00000010, + CAMERASRC_FCC_USE_CAP_PREVIEW = 0x00000100, + CAMERASRC_FCC_USE_RECORDING = 0x00001000, + CAMERASRC_FCC_USE_NORMAL_CAPTURE = 0x00010000, + CAMERASRC_FCC_USE_CONT_CAPTURE = 0x00100000, + CAMERASRC_FCC_USE_NUM = 6, +}; + +/*! @struct camerasrc_tpf_frac_t + * @brief For timeperframe as fraction type + * Elapse time consumed by one frame, reverse of FPS + */ +typedef struct { + int num; + int den; +}camerasrc_tpf_frac_t; + +/*! @struct camerasrc_resolution_t + * @brief For querying supported resolutions + */ +typedef struct { + int w; + int h; + + /* Available time per frame(tpf) as each pixelformat */ + int num_avail_tpf; + camerasrc_tpf_frac_t tpf[MAX_NUM_AVAILABLE_TPF]; +} camerasrc_resolution_t; + +/*! @struct camerasrc_fmt_desc_t + * @brief For querying supported format type + */ +typedef struct { + /* fourcc name of each pixelformat */ + unsigned int fcc; + int fcc_use; + + /* Available resolutions as each pixelformat */ + int num_resolution; + camerasrc_resolution_t resolutions[MAX_NUM_RESOLUTION]; +} camerasrc_fmt_desc_t; + +/*! @struct camerasrc_caps_info_t + * @brief For querying image input capabilities + */ +typedef struct { + char dev_name[MAX_SZ_DEV_NAME_STRING]; + camerasrc_dev_id_t input_id; + int num_fmt_desc; + camerasrc_fmt_desc_t fmt_desc[MAX_NUM_FMT_DESC]; + + int num_preview_resolution; + int preview_resolution_width[MAX_NUM_RESOLUTION]; + int preview_resolution_height[MAX_NUM_RESOLUTION]; + + int num_capture_resolution; + int capture_resolution_width[MAX_NUM_RESOLUTION]; + int capture_resolution_height[MAX_NUM_RESOLUTION]; + + int num_preview_fmt; + unsigned int preview_fmt[MAX_NUM_FMT_DESC]; + + int num_capture_fmt; + unsigned int capture_fmt[MAX_NUM_FMT_DESC]; + + int num_fps; + camerasrc_frac_t fps[MAX_NUM_AVAILABLE_FPS]; +} camerasrc_caps_info_t; + +/* For Querying controls */ +enum { + CTRL_TYPE_RANGE = 0, /**< Integer, range type */ + CTRL_TYPE_BOOL, /**< Boolean type, 1 equals positive and 0 is negative */ + CTRL_TYPE_ARRAY, /**< Array type, also called menu type. each integer(enumeration) value can be set */ + CTRL_TYPE_UNKNOWN, /**< Unknown type, for error control */ + CTRL_TYPE_NUM, +}; + +/*! @struct camerasrc_ctrl_menu_t + * @brief For querying menu of specified controls + */ +typedef struct { + int menu_index; /**< What number is used for accessing this menu */ + char menu_name[MAX_SZ_CTRL_NAME_STRING]; /**< name of each menu */ +}camerasrc_ctrl_menu_t; + +/*! @struct camerasrc_ctrl_info_t + * @brief For querying controls detail + */ +typedef struct { + camerasrc_ctrl_t camsrc_ctrl_id; /**< camsrc camera control ID for controlling this */ + int v4l2_ctrl_id; /**< v4l2 ctrl id, user not need to use this. see @struct camerasrc_ctrl_t */ + int ctrl_type; /**< Type of this control */ + char ctrl_name[MAX_SZ_CTRL_NAME_STRING]; /**< Name of this control */ + int min; /**< minimum value */ + int max; /**< maximum value */ + int step; /**< unit of the values */ + int default_val; /**< Default value of the array or range */ + int num_ctrl_menu; /**< In the case of array type control, number of supported menu information */ + camerasrc_ctrl_menu_t ctrl_menu[MAX_NUM_CTRL_MENU]; /**< @struct camerasrc_ctrl_menu_t for detailed each menu information*/ +} camerasrc_ctrl_info_t; + +/*! @struct camerasrc_ctrl_list_info_t + * @brief For querying controls + */ +typedef struct { + int num_ctrl_list_info; /**< Number of supported controls */ + camerasrc_ctrl_info_t ctrl_info[MAX_NUM_CTRL_LIST_INFO]; /**< @struct camerasrc_ctrl_info_t for each control information */ +} camerasrc_ctrl_list_info_t; + + +/* capabilities field */ +#define CAMERASRC_STROBE_CAP_NONE 0x0000 /* No strobe supported */ +#define CAMERASRC_STROBE_CAP_OFF 0x0001 /* Always flash off mode */ +#define CAMERASRC_STROBE_CAP_ON 0x0002 /* Always use flash light mode */ +#define CAMERASRC_STROBE_CAP_AUTO 0x0004 /* Flashlight works automatic */ +#define CAMERASRC_STROBE_CAP_REDEYE 0x0008 /* Red-eye reduction */ +#define CAMERASRC_STROBE_CAP_SLOWSYNC 0x0010 /* Slow sync */ +#define CAMERASRC_STROBE_CAP_FRONT_CURTAIN 0x0020 /* Front curtain */ +#define CAMERASRC_STROBE_CAP_REAR_CURTAIN 0x0040 /* Rear curtain */ +#define CAMERASRC_STROBE_CAP_PERMANENT 0x0080 /* keep turned on until turning off */ +#define CAMERASRC_STROBE_CAP_EXTERNAL 0x0100 /* use external strobe */ + +typedef struct _camerasrc_extra_info_t{ + unsigned int strobe_caps; /**< Use above caps field */ + unsigned int detection_caps; /**< Just boolean */ + unsigned int reserved[4]; +} camerasrc_extra_info_t; +/* END For Query functionalities */ + +/*! @def CAMERASRC_SET_SIZE_BY_DIMENSION + * @brief Utility definitions for setting non-regular size + */ +#define CAMERASRC_SET_SIZE_BY_DIMENSION(format, img_width, img_height) { \ + format.img_size.dim.width = img_width; \ + format.img_size.dim.height = img_height; \ +} + + +/* CALLBACK DEFINITIONS */ +/*! @typedef camerasrc_callback_t + * @brief Called back when auto-focusing returns + * This callback will be called when the lens properly auto-focused + */ +typedef int (*camerasrc_callback_t) (camsrc_handle_t handle, int state, void* usr_data); + +/* Static variables */ +/** + * Label for camera control. This static variable has a label for each of camerasrc_ctrl_t enumeration. + * When enumeration of camerasrc_ctrl_t is increased, this variable should be increased, too. + * This string could be used as a key by user. + * Reference : camerasrc_ctrl_t, _camerasrc_ctrl_list + */ + +static char *camerasrc_ctrl_label[CAMERASRC_CTRL_NUM] = +{ + "brightness", /**< label for CAMERASRC_CTRL_BRIGHTNESS */ + "contrast", /**< label for CAMERASRC_CTRL_CONTRAST */ + "digital zoom", /**< label for CAMERASRC_CTRL_DIGITAL_ZOOM */ + "optical zoom", /**< label for CAMERASRC_CTRL_OPTICAL_ZOOM */ + "white balance", /**< label for CAMERASRC_CTRL_WHITE_BALANCE */ + "color tone", /**< label for CAMERASRC_CTRL_COLOR_TONE */ + "program mode", /**< label for CAMERASRC_CTRL_PROGRAM_MODE */ + "flip", /**< label for CAMERASRC_CTRL_FLIP */ + "partcolor src", /**< label for CAMERASRC_CTRL_PARTCOLOR_SRC */ + "partcolor dst", /**< label for CAMERASRC_CTRL_PARTCOLOR_DST */ + "partcolor mode", /**< label for CAMERASRC_CTRL_PARTCOLOR_MODE */ + "anti handshake", /**< label for CAMERASRC_CTRL_ANTI_HANDSHAKE */ + "wide dynamic range", /**< label for CAMERASRC_CTRL_WIDE_DYNAMIC_RANGE */ + "saturation", /**< label for CAMERASRC_CTRL_SATURATION */ + "sharpness", /**< label for CAMERASRC_CTRL_SHARPNESS */ + "iso", /**< label for CAMERASRC_CTRL_ISO */ + "photometry", /**< label for CAMERASRC_CTRL_PHOTOMETRY */ +}; + +/* FUNCTION DEFINITIONS */ + +/**** M A I N O P E R A T I O N ****/ + +/** + * allocate the handle, set initial state & settings + * + * @param[in] phandle ::camsrc_handle_t camerasrc context handle to be created + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t code + * @see camerasrc_destroy + * @note State transition : [CAMERASRC_STATE_NONE] => [CAMERASRC_STATE_CREATED] + * Phase description : Non-running phase + */ +int camerasrc_create(camsrc_handle_t *phandle); + +/** + * proceed fd close, other finalization routines + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t code + * + * @see <camerasrc_create> + * + * @note State transition : [CAMERASRC_STATE_UNREALIZED] => [CAMERASRC_STATE_DESTROYED] + * Phase description : Non-running phase + */ +int camerasrc_destroy(camsrc_handle_t handle); + +/** + * free device context handle, other finalization routines + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t code + * @see camerasrc_create + * @note State transition : [CAMERASRC_STATE_UNREALIZED] => [CAMERASRC_STATE_DESTROYED] + * Phase description : Non-running phase + */ +int camerasrc_close_device(camsrc_handle_t handle); + +/** + * Get the state of camerasrc context handle + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] state ::camerasrc_state_t camerasrc context current state + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t code + * + */ +int camerasrc_get_state(camsrc_handle_t handle, camerasrc_state_t* state); + +/** + * Allocate the device context handle, open device node and do the miscellaneous settings + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success on ::camerasrc_handle_t or returns NULL code, and displays debug message + * @see camerasrc_unrealize + * @note State transition : [CAMERASRC_STATE_CREATED] => [CAMERASRC_STATE_REALIZED] + * Phase description : Non-running phase + * device name can be dependent on kernel module + */ +int camerasrc_realize(camsrc_handle_t handle); + +/** + * Deallocate the device structure of buffers, close device + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success on ::camerasrc_handle_t or returns NULL code, and displays debug message + * @see camerasrc_realize + * @note State transition : [CAMERASRC_STATE_READY] => [CAMERASRC_STATE_UNREALIZED] + * Phase description : Transit to Non-running phase + */ +int camerasrc_unrealize(camsrc_handle_t handle); + +/** + * Prepare Handle to be ready to capture + * Can change settings like below at this state + * - camera device ID setting + * - color format setting + * - image size setting + * - image storing method + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success on ::camerasrc_handle_t or returns NULL code, and displays debug message + * @see camerasrc_stop + * @note State transition : [CAMERASRC_STATE_REALIZED] => [CAMERASRC_STATE_READY] + * Phase description : Running phase + */ +int camerasrc_start(camsrc_handle_t handle); + +/** + * Present user buffer to camerasrc and force to use that buffer. + * After calling this API, all core routine of camerasrc camera will use + * User pointer method for managing buffers. + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] present_buf ::camerasrc_usr_buf_t Buffer set to present to camerasrc + * @param[in] io_method ::camerasrc_io_method_t Enum type represent to IO method + * @return Success on ::camsrc_handle_t or returns NULL code, and displays debug message + * @see camerasrc_io_method_t + * + */ +int camerasrc_present_usr_buffer(camsrc_handle_t handle, camerasrc_usr_buf_t* present_buf, camerasrc_io_method_t io_method); + +/** + * Get total number of buffer which managed in camerasrc currently. + * If this called, it will return default number of buffer in MMAP mode. + * but use this API after calling ::camerasrc_present_usr_buffer , It will + * return User specfied buffer number. + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] num_buffer Number of buffer that's managed in camerasrc currently + * @return Success on ::camsrc_handle_t or returns NULL code, and displays debug message + * @see camerasrc_io_method_t + * + */ +int camerasrc_get_num_buffer(camsrc_handle_t handle, unsigned int* num_buffer); + +/** + * Get Input/Output method which is used when access camera driver + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] io_method ::camerasrc_io_method_t method enum value + * @return Success on ::camsrc_handle_t or returns NULL code, and displays debug message + * @see camerasrc_io_method_t + * + */ +int camerasrc_get_io_method(camsrc_handle_t handle, camerasrc_io_method_t* io_method); + +/** + * Inner ring buffer start refreshing. refresh process occurs asynchronously, and + * ::camerasrc_wait_frame_available function can anounce when it is available. + * + * Camera is grabbing High quality, maybe low speed frame(dependent on device) + * - Cant approach the [AF] state + * - preview frames arent always automatically fed. If not, must request repeatedly + * - If device supports continuous focusing, it can be enabled at this state in case + * of multishot. + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_READY] => [CAMERASRC_STATE_STILL] + * Phase description : Running phase + */ +int camerasrc_start_still_stream(camsrc_handle_t handle); + +/** + * Inner ring buffer start refreshing. refresh process occurs asynchronously, and + * ::camerasrc_wait_frame_available function can anounce when it is available. + * + * Camera is grabbing low quality, high speed frame + * - Can attempt the [AF] state only at this state + * - preview frames are always automatically fed + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_READY] => [CAMERASRC_STATE_PREVIEW] + * Phase description : Running phase + */ +int camerasrc_start_preview_stream(camsrc_handle_t handle); + +/** + * Stop frame refreshing. Ring buffers don't be refreshed any more + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success on ::camerasrc_handle_t or returns NULL code, and displays debug message + * @see camerasrc_stop + * @note State transition : [CAMERASRC_STATE_STILL/PREVIEW/VIDEO] => [CAMERASRC_STATE_READY] + * Phase description : Running phase + */ +int camerasrc_stop_stream(camsrc_handle_t handle); + +/** + * Query image buffer size. buffer allocation guide function. + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] main_img_size main image maximum size + * @param[out] thm_img_size thumb nail image maximum size + * @return Success on ::camsrc_handle_t or returns NULL code, and displays debug message + * + */ +int camerasrc_query_img_buf_size(camsrc_handle_t handle, unsigned int* main_img_size, unsigned int* thm_img_size); + +/** + * non-busy waiting function for image frame available + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] timeout main image maximum size + * @return Success on ::camsrc_handle_t or returns NULL code, and displays debug message + * + */ +int camerasrc_wait_frame_available(camsrc_handle_t handle, long int timeout); + +/** + * Check emp shock status + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] check_val + * @return Success on ::camsrc_handle_t or returns NULL code, and displays debug message + * + */ +int camerasrc_check_esd_shock(camsrc_handle_t *handle, int *check_val); + +/** + * Queue(in user space, almost same with free buffer) buffer to dev's ring buffer + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[in] buffer ::camerasrc_buffer_t buffer + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * + */ +int camerasrc_queue_buffer(camsrc_handle_t handle, int buf_index, camerasrc_buffer_t *buffer); + +/** + * Dequeue(Pop) buffer from v4l2 driver to usr space. + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] buf_index main buffer index number to be dequeued. + * @param[out] buffer main image buffer + * @param[out] thm_buffer thumbnail image buffer + * @return Success on ::camsrc_handle_t or returns NULL code, and displays debug message + * + */ +int camerasrc_dequeue_buffer(camsrc_handle_t handle, int *buf_index, camerasrc_buffer_t *buffer, camerasrc_buffer_t *thm_buffer); + +/** + * Read frame from camera device. + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] buffer ::camerasrc_buffer_t main image buffer to be get. + * @param[out] thm_buffer ::camerasrc_buffer_t thumbnail image buffer to be get. + * @param[out] buffer_index ::int v4l2 buffer index. + * @note if thm_buffer is NULL, thumbnail image will be discarded + * + */ +int camerasrc_read_frame(camsrc_handle_t handle, camerasrc_buffer_t *main_img_buffer, camerasrc_buffer_t *thm_img_buffer, int *buffer_index); + +/** + * Get screennail buffer + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] scrnl_buf ::camerasrc_buffer_t screennail buffer to be gotten + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_get_screennail_buffer(camsrc_handle_t handle, camerasrc_buffer_t *scrnl_buf); + +/** + * Set autofocus callback. ::camerasrc_callback_t type defined function can be set + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[in] cb ::camerasrc_callback_t callback after focusing over + * @param[in] use_data ::void * user data pointer that will be passed to callback + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note Callback function can be set on READY or REALIZED state + * + */ +int camerasrc_set_focused_callback(camsrc_handle_t handle, camerasrc_callback_t cb, void *usr_data); + +/** + * Set autofocusing area. autofocusing will be performed refer this rect of the preview + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] rect ::camerasrc_rect_t rectangle area for auto focusing + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_set_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t* rect); + +/** + * Get autofocusing area. + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] rect ::camerasrc_rect_t rectangle area for auto focusing + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_get_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t* rect); + +/** + * Start auto focusing with ::camerasrc_af_mode. After ::interval time, call the callback + * function with ::camerasrc_af_status value. + * Auto-focus is in progress. Cant return preview state + * before time-out, success, call camerasrc_autofocus_stop + * - If focused, focus status will be locked at preview state + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[in] af_mode Auto focusing operation mode see ::camerasrc_af_mode + * @param[in] interval interval time in millisecond + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_PREVIEW] => [CAMERASRC_STATE_AF_IN_PROGRESS] + * Phase description : Running phase + */ +int camerasrc_start_autofocusing(camsrc_handle_t handle); + +/** + * Stop auto focusing + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_AF_IN_PROGRESS] => [CAMERASRC_STATE_PREVIEW] + * Phase description : Running phase + */ +int camerasrc_stop_autofocusing(camsrc_handle_t handle); + +/** + * Release auto focusing + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_AF_IN_PROGRESS] => [CAMERASRC_STATE_PREVIEW] + * Phase description : Running phase + */ +int camerasrc_release_autofocusing(camsrc_handle_t handle); + +/** + * Initialize auto focusing mode to specified focal length + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] af_mode ::camerasrc_af_mode_t Auto focusing mode + * @param[in] af_range ::camerasrc_af_scan_range_t Auto focusing range + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_init_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t af_mode, camerasrc_af_scan_range_t af_range); + +/** + * Get current auto focusing mode + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] af_mode ::camerasrc_af_mode_t Auto focusing mode + * @param[out] af_range ::camerasrc_af_scan_range_t Auto focusing range + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_get_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t* af_mode, camerasrc_af_scan_range_t* af_range); + +/** + * Get current auto focusing status + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] af_status ::camerasrc_auto_focus_status_t Auto focusing status + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * + */ +int camerasrc_get_autofocusing_status(camsrc_handle_t handle, camerasrc_auto_focus_status_t* af_status); +/**** M I S C E L L A N E O U S O P E R A T I O N ****/ + +/**** I N P U T ( C A M D E V I C E ) O P E R A T I O N ****/ + +/** + * Get input camera ID just like ioctl (fd, VIDIOC_G_INPUT, &index) + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[out] id Camera ID currently set + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_PHASE_RUNNING + */ +int camerasrc_get_input(camsrc_handle_t handle, camerasrc_dev_id_t* camera_id); + +/** + * Set input camera ID just like ioctl (fd, VIDIOC_S_INPUT, &index) + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[out] camera_id Camera ID currently set + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_STATE_READY + * If you use set_input(), handle will be initiated. + */ +int camerasrc_set_input(camsrc_handle_t handle, camerasrc_dev_id_t camera_id); + + +/**** E F F E C T C O N T R O L O P E R A T I O N ****/ + +/** + * Check support controls with ::camerasrc_ctrl_t ID + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] ctrl_id control ID to be checked + * @param[out] ctrl_info control information to be got + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_query_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t* ctrl_info); + +/** + * Check support controls with ::camerasrc_ctrl_t ID + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] ctrl_id control ID to be checked + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_support_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id); + +/** + * Start facedetection + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_AF_IN_PROGRESS] => [CAMERASRC_STATE_PREVIEW] + * Phase description : Running phase + */ +int camerasrc_start_facedetection(camsrc_handle_t handle); + +/** + * Stop face detection + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_AF_IN_PROGRESS] => [CAMERASRC_STATE_PREVIEW] + * Phase description : Running phase + */ +int camerasrc_stop_facedetection(camsrc_handle_t handle); + +/** + * Get face detection status + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[out] is_detecting whether it is detecting or not + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note State transition : [CAMERASRC_STATE_AF_IN_PROGRESS] => [CAMERASRC_STATE_PREVIEW] + * Phase description : Running phase + */ +int camerasrc_get_facedetection(camsrc_handle_t handle, int* is_detecting); + +/** + * Control miscellaneous settings through ::camerasrc_ctrl_t IDs + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] ctrl_id control ID to be checked + * @param[in] value value to be set + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_STATE_READY + */ +int camerasrc_set_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int value); + +/** + * Get the value of miscellaneous settings through ::camerasrc_ctrl_t IDs + * + * @param[in] handle ::camsrc_handle_t camerasrc context handle + * @param[in] ctrl_id control ID to be checked + * @param[out] value value to be stored + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_STATE_READY + */ +int camerasrc_get_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int* value); + +/**** O U T P U T C O N T R O L O P E R A T I O N ****/ + +/** + * Control frame refresh rate setting + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[in] frac ::camsrc_frac_t time per frame + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_STATE_READY + */ +int camerasrc_set_timeperframe(camsrc_handle_t handle, camerasrc_frac_t* frac); + +/** + * Set output format of camera device just like ioctl VIDIOC_S_FMT + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[in] fmt ::camerasrc_format_t output format description to be set + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_STATE_READY. + * device dependent function. + */ +int camerasrc_set_format(camsrc_handle_t handle, camerasrc_format_t* fmt); + +/** + * Get output format of camera device just like ioctl VIDIOC_G_FMT + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[in] fmt ::camerasrc_format_t output format description to be set + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_PHASE_RUNNING + */ +int camerasrc_get_format(camsrc_handle_t handle, camerasrc_format_t* fmt); + +/** + * Try output format of camera device just like ioctl VIDIOC_TRY_FMT + * In this function, it doesn't change any format, only just try. just test + * the combinations of format setting + * + * @param[in] handle ::camerasrc_handle_t camerasrc context handle + * @param[in] fmt ::camerasrc_format_t output format description to be set + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + * @note This function is only effective at CAMERASRC_STATE_READY. + * device dependent function. + */ +int camerasrc_try_format(camsrc_handle_t handle, camerasrc_format_t* fmt); + +/** + * Get virtual/physical address of data frame + * + * @param[in] handle ::camsrc_handle_t handle + * @param[in] ae_lock ::camerasrc_ae_lock_t Auto exposure lock/unlock + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_get_frame_data(camsrc_handle_t handle, camerasrc_frame_data_t * data); + +/**** S H U T T E R S P E E D & A P E R T U R E M O D U L A T I O N ****/ +/** + * Get exif string to be combined with jpg image from camerasrc + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] exif_string exif information string + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_get_exif_info(camsrc_handle_t handle, camerasrc_exif_t* exif_struct); + +/** + * Check whether camera device is opened + * + * @param[in] handle ::camsrc_handle_t handle + * @return 0 when camera is not opened else return non-zero value. + */ + int camerasrc_device_is_open(camsrc_handle_t handle); + +/** + * Set the camera device file decriptor + + * @param[in] handle ::camsrc_handle_t handle + * @param[in] videofd ::file descriptor of camera device + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_set_videofd(camsrc_handle_t handle,int videofd); + +/** + * Set AF behaviour after capturing + + * @param[in] handle ::camsrc_handle_t handle + * @param[in] hold_af ::whether holding af after capturing + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_set_af_hold_after_capture(camsrc_handle_t handle, int hold_af); + +/** + * Set Sensor mode to camera driver + + * @param[in] handle ::camsrc_handle_t handle + * @param[in] sensor_mode ::int mode + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_set_sensor_mode(camsrc_handle_t handle, int mode); + +/** + * Set vflip to camera driver + + * @param[in] handle ::camsrc_handle_t handle + * @param[in] vflip ::int vflip + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_set_vflip(camsrc_handle_t handle, int vflip); + +/** + * Set hflip to camera driver + + * @param[in] handle ::camsrc_handle_t handle + * @param[in] hflip ::int hflip + * @return Success on CAMERASRC_ERR_NONE or returns with ::camerasrc_error_t error code + */ +int camerasrc_set_hflip(camsrc_handle_t handle, int hflip); + +/* W I L L B E D E P R E C A T E D */ + +/*! @enum camerasrc_colortone_t + * @brief Enumeration type for camera colortone + * + * Colortone entries for camera effects. This can be used with CAMERASRC_CTRL_COLOR_TONE + * This values are defined for utility. It's dependent on the device/camera module. + */ +typedef enum { + CAMERASRC_COLORTONE_NONE = 0, + CAMERASRC_COLORTONE_NEGATIVE, + CAMERASRC_COLORTONE_SOLARIZATION_1, + CAMERASRC_COLORTONE_SOLARIZATION_2, + CAMERASRC_COLORTONE_SOLARIZATION_3, + CAMERASRC_COLORTONE_SOLARIZATION_4, + CAMERASRC_COLORTONE_EMBOSS, + CAMERASRC_COLORTONE_OUTLINE, + CAMERASRC_COLORTONE_AQUA, + CAMERASRC_COLORTONE_SEPHIA, + CAMERASRC_COLORTONE_GRAY, + CAMERASRC_COLORTONE_B_N_W, + CAMERASRC_COLORTONE_RED, + CAMERASRC_COLORTONE_GREEN, + CAMERASRC_COLORTONE_BLUE, + CAMERASRC_COLORTONE_ANTIQUE, + CAMERASRC_COLORTONE_SKETCH1, + CAMERASRC_COLORTONE_SKETCH2, + CAMERASRC_COLORTONE_SKETCH3, + CAMERASRC_COLORTONE_SKETCH4, + CAMERASRC_COLORTONE_NUM, +}camerasrc_colortone_t; + +/*! @enum camerasrc_program_mode_t + * @brief Enumeration type for preset program mode + * + * WRITEME + */ +typedef enum { + CAMERASRC_PROGRAM_MODE_NORMAL = 0, + CAMERASRC_PROGRAM_MODE_PORTRAIT, + CAMERASRC_PROGRAM_MODE_LANDSCAPE, + CAMERASRC_PROGRAM_MODE_SPORTS, + CAMERASRC_PROGRAM_MODE_PARTY_N_INDOOR, + CAMERASRC_PROGRAM_MODE_BEACH_N_INDOOR, + CAMERASRC_PROGRAM_MODE_SUNSET, + CAMERASRC_PROGRAM_MODE_DUSK_N_DAWN, + CAMERASRC_PROGRAM_MODE_FALL_COLOR, + CAMERASRC_PROGRAM_MODE_NIGHT_SCENE, + CAMERASRC_PROGRAM_MODE_FIREWORK, + CAMERASRC_PROGRAM_MODE_TEXT, + CAMERASRC_PROGRAM_MODE_SHOW_WINDOW, + CAMERASRC_PROGRAM_MODE_CANDLE_LIGHT, + CAMERASRC_PROGRAM_MODE_BACK_LIGHT, + CAMERASRC_PROGRAM_MODE_NUM, +}camerasrc_program_mode_t; + +/*! @enum camerasrc_whitebalance_t + * @brief Enumeration type for preset whitebalance + * + * WRITEME + */ +typedef enum { + CAMERASRC_WHITEBALANCE_AUTO = 0, + CAMERASRC_WHITEBALANCE_INCANDESCENT, + CAMERASRC_WHITEBALANCE_FLUORESCENT, + CAMERASRC_WHITEBALANCE_DAYLIGHT, + CAMERASRC_WHITEBALANCE_CLOUDY, + CAMERASRC_WHITEBALANCE_SHADE, + CAMERASRC_WHITEBALANCE_HORIZON, + CAMERASRC_WHITEBALANCE_FLASH, + CAMERASRC_WHITEBALANCE_CUSTOM, + CAMERASRC_WHITEBALANCE_NUM, +}camerasrc_whitebalance_t; + +/** + * Enumerations for flip. + */ +typedef enum { + CAMERASRC_FILP_NONE = 0, /**< Not flipped */ + CAMERASRC_FILP_VERTICAL, /**< Flip vertically */ + CAMERASRC_FILP_HORIZONTAL, /**< Flip horizontally */ + CAMERASRC_FILP_NUM, /**< Number of flip status */ +}camerasrc_flip_t; + +/*! @enum camerasrc_strobo_status_t + * @brief strobo status + * strobo status + */ +typedef enum { + CAMERASRC_STROBO_STATUS_BANNED = 0, /**< strobo off*/ + CAMERASRC_STROBO_STATUS_FORCE_ON, /**< strobo on.*/ + CAMERASRC_STROBO_STATUS_AUTO, /**< control strobo automatically*/ + CAMERASRC_STROBO_STATUS_MOVIE_ON, /**< control strobo automatically*/ + CAMERASRC_STROBO_STATUS_NUM, /**< Number of AF status*/ +}camerasrc_strobo_status_t; +/*! @enum camerasrc_strobe_mode_t + * @brief strobe mode + * strobe mode + */ +typedef enum { + CAMERASRC_STROBE_MODE_OFF = 1, /**< off */ + CAMERASRC_STROBE_MODE_AUTO, /**< auto */ + CAMERASRC_STROBE_MODE_ON, /**< on */ + CAMERASRC_STROBE_MODE_PERMANENT, /**< permanent */ + CAMERASRC_STROBE_MODE_NUM, /**< Number of strobe mode */ +}camerasrc_strobe_mode_t; + +/*! @enum camerasrc_ae_mode_t + * @brief Auto exposure mode + * Auto exposure operation mode + */ +typedef enum { + CAMERASRC_AE_MODE_OFF = 0, + CAMERASRC_AE_MODE_ALL, + CAMERASRC_AE_MODE_CENTER_WEIGHTED_AVR_1, + CAMERASRC_AE_MODE_CENTER_WEIGHTED_AVR_2, + CAMERASRC_AE_MODE_CENTER_WEIGHTED_AVR_3, + CAMERASRC_AE_MODE_SPOT_1, + CAMERASRC_AE_MODE_SPOT_2, + CAMERASRC_AE_MODE_CUSTOM_1, + CAMERASRC_AE_MODE_CUSTOM_2, +} camerasrc_ae_mode_t; + +/*! @enum camerasrc_iso_t + * @brief Reserved iso number in definition + * Traditionally predefined ISO values + */ +typedef enum { + CAMERASRC_ISO_AUTO = 0, + CAMERASRC_ISO_50, + CAMERASRC_ISO_100, + CAMERASRC_ISO_200, + CAMERASRC_ISO_400, + CAMERASRC_ISO_800, + CAMERASRC_ISO_1600, + CAMERASRC_ISO_3200, +} camerasrc_iso_t; + +/*! @enum camerasrc_sensor_mode_t + * @brief Sensor mode in driver + * Sensor mode + */ +typedef enum { + CAMERASRC_SENSOR_MODE_CAMERA = 0, + CAMERASRC_SENSOR_MODE_MOVIE, +} camerasrc_sensor_mode_t; + +/*! @def CAMERASRC_SET_SIZE_BY_PRESET_RESOLUTION + * @brief Utility definitions for setting regular size with ::camerasrc_resol_name_t + */ +#define CAMERASRC_SET_SIZE_BY_PRESET_RESOLUTION(format, resolution) { \ + memset(&(format.img_size), 0, sizeof(camerasrc_size_t)); \ + format.img_size.res = resolution; \ +} + +/** + * Set the mode of strobe + * + * @param[in] handle ::camsrc_handle_t handle + * @param[in] mode ::camerasrc_strobe_mode_t mode of strobe + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_set_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t mode); + +/** + * Get the mode of strobe + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] mode ::camerasrc_strobe_mode_t mode of strobe + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_get_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t* mode); + +/** + * Set the mode of auto-exposure processing + * + * @param[in] handle ::camsrc_handle_t handle + * @param[in] ae_mode ::camerasrc_ae_mode_t AE mode to be set + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_set_exposure_mode(camsrc_handle_t handle, camerasrc_ae_mode_t ae_mode); + +/** + * Get the mode of auto-exposure processing + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] ae_mode ::camerasrc_ae_mode_t AE mode to be got + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_get_exposure_mode(camsrc_handle_t handle, camerasrc_ae_mode_t* ae_mode); + +/** + * Set the shutter speed + * + * @param[in] handle ::camsrc_handle_t handle + * @param[in] frac ::camerasrc_frac_t shutter speed to be set + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_set_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t frac); + +/** + * Get the shutter speed + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] frac ::camerasrc_frac_t shutter speed to be got + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_get_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t* frac); + +/** + * Set the exposure value + * + * @param[in] handle ::camsrc_handle_t handle + * @param[in] frac ::camerasrc_frac_t exposure value to be set + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_set_exposure_value(camsrc_handle_t handle, camerasrc_frac_t frac); + +/** + * Get the exposure value + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] frac ::camerasrc_frac_t exposure value to be got + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_get_exposure_value(camsrc_handle_t handle, camerasrc_frac_t* frac); + +/** + * Check whether supports exif embed in jpg or not + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] support_exif ::if supports, returns 1 or 0 + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_support_embed_exif(camsrc_handle_t handle, int* support_exif); + +/** + * Check whether supports jpeg encoding inside camera driver + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] support_jpeg_encoding ::if supports, returns 1. If not, return 0 + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_support_jpeg_encoding(camsrc_handle_t handle, int* support_jpeg_encoding); + + + +/* For Query functionalities */ +/** + * Query basic device info of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] camerasrc_caps_info_t device information structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_read_basic_dev_info(camerasrc_dev_id_t dev_id, camerasrc_caps_info_t* caps_info); + +/** + * Query miscellaneous device info(effect, WB, preset values, etc.) of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] camerasrc_ctrl_list_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_read_misc_dev_info(camerasrc_dev_id_t dev_id, camerasrc_ctrl_list_info_t* ctrl_info); + +/** + * Query extra device info(face detection, strobe, etc.) of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] camerasrc_extra_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_read_extra_dev_info(camerasrc_dev_id_t dev_id, camerasrc_extra_info_t* extra_info); + +/** + * Record miscellaneous device info(effect, WB, preset values, etc.) of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[in] camerasrc_ctrl_list_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_write_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info); + +/** + * Record miscellaneous device info(effect, WB, preset values, etc.) of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[in] camerasrc_ctrl_list_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_write_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_info); + +/** + * Record extra device info(face detection, strobe, etc.) of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] camerasrc_extra_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_write_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info); + +/** + * Query to device driver about basic device info + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] camerasrc_ctrl_list_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_query_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info); + +/** + * Query to device driver about miscellaneous device info(effect, WB, preset values, etc.) of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] camerasrc_ctrl_list_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_query_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info); +int camerasrc_query_misc_dev_ctrl_info(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t* ctrl_info); + +/** + * Query to device driver about extra device info(face detection, strobe, etc.) of device + * + * @param[in] handle ::camsrc_handle_t handle + * @param[out] camerasrc_extra_info_t device capabilities structure + * @return Success(Support) on CAMERASRC_ERR_NONE or returns with ::camerasrc_error error code + */ +int camerasrc_query_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info); + +/** + * Dump functions for debugging + */ +int camerasrc_dump_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info); +int camerasrc_dump_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info); +int camerasrc_dump_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info); +/* END For Query functionalities */ + +#ifdef __cplusplus +} +#endif + +#endif /*__CAMERASRC_H__*/ diff --git a/camerasrc/src/include/gstcamerasrc.h b/camerasrc/src/include/gstcamerasrc.h new file mode 100644 index 0000000..61b3c28 --- /dev/null +++ b/camerasrc/src/include/gstcamerasrc.h @@ -0,0 +1,175 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GSTCAMERASRC_H__ +#define __GSTCAMERASRC_H__ + +#include <gst/gst.h> +#include <gst/base/gstpushsrc.h> + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include <gst/interfaces/colorbalance.h> +#include <gst/interfaces/cameracontrol.h> + +#include "camerasrc.h" + +#ifndef _SPEED_UP_RAW_CAPTURE +/* Disabled now +#define _SPEED_UP_RAW_CAPTURE +*/ +#endif /* _SPEED_UP_RAW_CAPTURE */ + +G_BEGIN_DECLS +#define GST_TYPE_CAMERA_SRC (gst_camerasrc_get_type()) +#define GST_CAMERA_SRC(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj),GST_TYPE_CAMERA_SRC,GstCameraSrc)) +#define GST_CAMERA_SRC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass),GST_TYPE_CAMERA_SRC,GstCameraSrcClass)) +#define GST_IS_CAMERA_SRC(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj),GST_TYPE_CAMERA_SRC)) +#define GST_IS_CAMERA_SRC_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE((klass),GST_TYPE_CAMERA_SRC)) + + +/** + * Quality. + */ +typedef enum { + GST_CAMERASRC_QUALITY_LOW, /**< Low quality */ + GST_CAMERASRC_QUALITY_HIGH, /**< High quality */ +} GstCameraSrcQuality; + +#define MAX_USR_BUFFER_NUM 12 + +typedef struct _GstCameraSrc GstCameraSrc; +typedef struct _GstCameraSrcClass GstCameraSrcClass; +typedef struct _GstCameraBuffer GstCameraBuffer; + +/* global info */ +struct _GstCameraBuffer { + GstBuffer buffer; + int v4l2_buffer_index; + GstCameraSrc *camerasrc; + gboolean is_alloc_data; +}; + +struct _GstCameraSrc +{ + GstPushSrc element; + + /*private*/ + void *v4l2_handle; /**< video4linux2 handle */ + int mode; + int sensor_mode; /**< sensor mode - camera or movie(camcorder) */ + gboolean vflip; /**< flip camera input vertically */ + gboolean hflip; /**< flip camera input horizontally */ + gboolean firsttime; + + int main_buf_sz; + int cap_count_current; /**< current capture count */ + int cap_count_reverse; /**< current capture count (reverse counting) */ + unsigned long cap_next_time; /**< next shot time for capture */ + GQueue *command_list; /**< Command list(Start capture, Stop capture) queue */ + + GCond *cond; + GMutex *mutex; + + /*camera property*/ + int width; /**< Width */ + int height; /**< Height */ + int fps; /**< Video source fps */ + + guint32 fourcc; /**< Four CC */ + int pix_format; /**< Image format of video source */ + int colorspace; /**< Colorspace of video source */ + int high_speed_fps; /**< Video source fps for high speed recording */ + gboolean fps_auto; /**< Auto Video source fps */ + + gboolean req_negotiation; /**< Video source fps for high speed recording */ + int camera_id; + int rotate; /**< Video source rotate */ + gboolean use_rotate_caps; /**< Use or not rotate value in caps */ + int external_videofd; /**< video FD from external module */ + + GCond *buffer_cond; + GMutex *buffer_lock; + gboolean buffer_running; /* with lock */ + gint num_live_buffers; /* with lock */ + guint buffer_count; + gboolean bfirst; /* temp */ +#ifdef _SPEED_UP_RAW_CAPTURE + gboolean cap_stream_diff; /* whether preview and capture streams are different each other */ +#endif + GQueue *pad_alloc_list; + GMutex *pad_alloc_mutex; + gint current_buffer_data_index; + gboolean first_invokation; + + GstBuffer *usr_buffer[MAX_USR_BUFFER_NUM]; + gboolean use_pad_alloc; + guint num_alloc_buf; + + /* Colorbalance , CameraControl interface */ + GList *colors; + GList *camera_controls; + + + /*capture property*/ + guint32 cap_fourcc; /**< gstreamer fourcc value(GST_MAKE_FOURCC format) for raw capturing */ + GstCameraSrcQuality cap_quality; /**< Capture quality */ + int cap_width; /**< Capture width */ + int cap_height; /**< Capture height */ + int cap_interval; /**< Capture interval */ + int cap_count; /**< Capture count */ + int cap_jpg_quality; /**< Capture quality for jpg compress ratio */ + gboolean cap_provide_exif; /**< Is exif provided? */ + + /*etc property*/ + gboolean signal_still_capture; /**< enable still capture signal */ + gboolean hold_af_after_capturing; /**< Whether to hold af after capturing */ + gboolean create_jpeg; + GMutex *jpg_mutex; +}; + +struct _GstCameraSrcClass { + GstPushSrcClass parent_class; + /* signals */ + void (*still_capture) (GstElement *element, GstBuffer *main, GstBuffer *sub, GstBuffer *scrnl); + void (*nego_complete) (GstElement *element); + void (*register_trouble) (GstElement *element); +}; + +typedef enum { + INTERFACE_NONE, + INTERFACE_COLOR_BALANCE, + INTERFACE_CAMERA_CONTROL, +} GstInterfaceType; + + +void gst_camerasrc_set_capture_command(GstCameraSrc* camerasrc, GstCameraControlCaptureCommand cmd); + + +GType gst_camerasrc_get_type(void); + +G_END_DECLS + +#endif /* __GSTCAMERASRC_H__ */ diff --git a/camerasrc/src/include/gstcamerasrccolorbalance.h b/camerasrc/src/include/gstcamerasrccolorbalance.h new file mode 100644 index 0000000..0edeb46 --- /dev/null +++ b/camerasrc/src/include/gstcamerasrccolorbalance.h @@ -0,0 +1,93 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_CAMERASRC_COLOR_BALANCE_H__ +#define __GST_CAMERASRC_COLOR_BALANCE_H__ + +#include <gst/gst.h> +#include <gst/interfaces/colorbalance.h> +#include "gstcamerasrc.h" + +G_BEGIN_DECLS + +#define GST_TYPE_CAMERASRC_COLOR_BALANCE_CHANNEL (gst_camerasrc_color_balance_channel_get_type ()) +#define GST_CAMERASRC_COLOR_BALANCE_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_CAMERASRC_COLOR_BALANCE_CHANNEL, GstCameraSrcColorBalanceChannel)) +#define GST_CAMERASRC_COLOR_BALANCE_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_CAMERASRC_COLOR_BALANCE_CHANNEL, GstCameraSrcColorBalanceChannelClass)) +#define GST_IS_CAMERASRC_COLOR_BALANCE_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_CAMERASRC_COLOR_BALANCE_CHANNEL)) +#define GST_IS_CAMERASRC_COLOR_BALANCE_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_CAMERASRC_COLOR_BALANCE_CHANNEL)) + +typedef struct _GstCameraSrcColorBalanceChannel { + GstColorBalanceChannel parent; + + guint32 id; +} GstCameraSrcColorBalanceChannel; + +typedef struct _GstCameraSrcColorBalanceChannelClass { + GstColorBalanceChannelClass parent; +} GstCameraSrcColorBalanceChannelClass; + +GType gst_camerasrc_color_balance_channel_get_type( void ); + +const GList *gst_camerasrc_color_balance_list_channels( GstCameraSrc* camerasrc ); +void gst_camerasrc_color_balance_set_value( GstCameraSrc* camerasrc, GstColorBalanceChannel* color_channel, gint value ); +gint gst_camerasrc_color_balance_get_value( GstCameraSrc* camerasrc, GstColorBalanceChannel* color_channel ); + +#define GST_IMPLEMENT_CAMERASRC_COLOR_BALANCE_METHODS( Type, interface_as_function ) \ + \ +static const GList* \ +interface_as_function ## _color_balance_list_channels( GstColorBalance* balance ) \ +{ \ + Type *this = (Type*) balance; \ + return gst_camerasrc_color_balance_list_channels( this ); \ +} \ + \ +static void \ +interface_as_function ## _color_balance_set_value( GstColorBalance* balance, \ + GstColorBalanceChannel* color_channel, \ + gint value ) \ +{ \ + Type *this = (Type*) balance; \ + return gst_camerasrc_color_balance_set_value( this, color_channel, value ); \ +} \ + \ +static gint \ +interface_as_function ## _color_balance_get_value( GstColorBalance* balance, \ + GstColorBalanceChannel* color_channel )\ +{ \ + Type *this = (Type*) balance; \ + return gst_camerasrc_color_balance_get_value( this, color_channel ); \ +} \ + \ +void \ +interface_as_function ## _color_balance_interface_init( GstColorBalanceClass* klass ) \ +{ \ + GST_COLOR_BALANCE_TYPE( klass ) = GST_COLOR_BALANCE_HARDWARE; \ + \ + /* default virtual functions */ \ + klass->list_channels = interface_as_function ## _color_balance_list_channels; \ + klass->set_value = interface_as_function ## _color_balance_set_value; \ + klass->get_value = interface_as_function ## _color_balance_get_value; \ +} + +#endif /* __GST_CAMERASRC_COLOR_BALANCE_H__ */ + diff --git a/camerasrc/src/include/gstcamerasrccontrol.h b/camerasrc/src/include/gstcamerasrccontrol.h new file mode 100644 index 0000000..c4ce913 --- /dev/null +++ b/camerasrc/src/include/gstcamerasrccontrol.h @@ -0,0 +1,384 @@ +/* + * camerasrc + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Jeongmo Yang <jm80.yang@samsung.com> + * + * This library is free software; you can redistribute it and/or modify it under + * the terms of the GNU Lesser General Public License as published by the + * Free Software Foundation; either version 2.1 of the License, or (at your option) + * any later version. + * + * This library is distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public + * License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this library; if not, write to the Free Software Foundation, Inc., 51 + * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#ifndef __GST_CAMERASRC_CONTROL_H__ +#define __GST_CAMERASRC_CONTROL_H__ + +#include <gst/gst.h> +#include <gst/interfaces/cameracontrol.h> +#include "gstcamerasrc.h" + +G_BEGIN_DECLS + +#define GST_TYPE_CAMERASRC_CONTROL_CHANNEL (gst_camerasrc_control_channel_get_type ()) +#define GST_CAMERASRC_CONTROL_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GST_TYPE_CAMERASRC_CONTROL_CHANNEL, GstCamerasrcControlChannel)) +#define GST_CAMERASRC_CONTROL_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GST_TYPE_CAMERASRC_CONTROL_CHANNEL, GstCamerasrcControlChannelClass)) +#define GST_IS_CAMERASRC_CONTROL_CHANNEL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GST_TYPE_CAMERASRC_CONTROL_CHANNEL)) +#define GST_IS_CAMERASRC_CONTROL_CHANNEL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GST_TYPE_CAMERASRC_CONTROL_CHANNEL)) + +typedef struct _GstCamerasrcControlChannel { +GstCameraControlChannel parent; +guint32 id; +} GstCamerasrcControlChannel; + +typedef struct _GstCamerasrcControlChannelClass { +GstCameraControlChannelClass parent; +} GstCamerasrcControlChannelClass; + +GType gst_camerasrc_control_channel_get_type( void ); + +const GList*gst_camerasrc_control_list_channels( GstCameraSrc* camera_src ); + +gboolean gst_camerasrc_control_set_value ( GstCameraSrc* camera_src, GstCameraControlChannel* control_channel, gint value ); +gboolean gst_camerasrc_control_get_value ( GstCameraSrc* camera_src, GstCameraControlChannel* control_channel, gint* value ); +gboolean gst_camerasrc_control_set_exposure ( GstCameraSrc* camera_src, gint type, gint value1, gint value2 ); +gboolean gst_camerasrc_control_get_exposure ( GstCameraSrc* camera_src, gint type, gint* value1, gint* value2 ); +gboolean gst_camerasrc_control_set_capture_mode ( GstCameraSrc* camera_src, gint type, gint value ); +gboolean gst_camerasrc_control_get_capture_mode ( GstCameraSrc* camera_src, gint type, gint* value ); +gboolean gst_camerasrc_control_set_strobe ( GstCameraSrc* camera_src, gint type, gint value ); +gboolean gst_camerasrc_control_get_strobe ( GstCameraSrc* camera_src, gint type, gint *value ); +gboolean gst_camerasrc_control_set_detect ( GstCameraSrc* camera_src, gint type, gint value ); +gboolean gst_camerasrc_control_get_detect ( GstCameraSrc* camera_src, gint type, gint* value ); +gboolean gst_camerasrc_control_set_zoom ( GstCameraSrc* camera_src, gint type, gint value ); +gboolean gst_camerasrc_control_get_zoom ( GstCameraSrc* camera_src, gint type, gint* value ); +gboolean gst_camerasrc_control_set_focus ( GstCameraSrc* camera_src, gint mode, gint range ); +gboolean gst_camerasrc_control_get_focus ( GstCameraSrc* camera_src, gint* mode, gint* range ); +gboolean gst_camerasrc_control_start_auto_focus ( GstCameraSrc* camera_src ); +gboolean gst_camerasrc_control_stop_auto_focus ( GstCameraSrc* camera_src ); +gboolean gst_camerasrc_control_set_focus_level ( GstCameraSrc* camera_src, gint manual_level ); +gboolean gst_camerasrc_control_get_focus_level ( GstCameraSrc* camera_src, gint* manual_level ); +gboolean gst_camerasrc_control_set_auto_focus_area( GstCameraSrc* camera_src, GstCameraControlRectType rect ); +gboolean gst_camerasrc_control_get_auto_focus_area( GstCameraSrc* camera_src, GstCameraControlRectType* rect ); +gboolean gst_camerasrc_control_set_wdr ( GstCameraSrc* camera_src, gint value ); +gboolean gst_camerasrc_control_get_wdr ( GstCameraSrc* camera_src, gint* value ); +gboolean gst_camerasrc_control_set_ahs ( GstCameraSrc* camera_src, gint value ); +gboolean gst_camerasrc_control_get_ahs ( GstCameraSrc* camera_src, gint* value ); +gboolean gst_camerasrc_control_set_part_color ( GstCameraSrc* camera_src, gint type, gint value ); +gboolean gst_camerasrc_control_get_part_color ( GstCameraSrc* camera_src, gint type, gint* value ); +gboolean gst_camerasrc_control_get_exif_info ( GstCameraSrc* camera_src, GstCameraControlExifInfo* info ); +gboolean gst_camerasrc_control_get_basic_dev_info ( GstCameraSrc* camera_src, gint dev_id, GstCameraControlCapsInfoType* info ); +gboolean gst_camerasrc_control_get_misc_dev_info ( GstCameraSrc* camera_src, gint dev_id, GstCameraControlCtrlListInfoType* info ); +gboolean gst_camerasrc_control_get_extra_dev_info ( GstCameraSrc* camera_src, gint dev_id, GstCameraControlExtraInfoType* info ); +void gst_camerasrc_control_set_capture_command( GstCameraSrc* camera_src, GstCameraControlCaptureCommand cmd ); + +#define GST_IMPLEMENT_CAMERASRC_CONTROL_METHODS(Type, interface_as_function) \ + \ +static const GList* \ +interface_as_function ## _control_list_channels( GstCameraControl* control ) \ +{ \ + Type* this = (Type*) control; \ + return gst_camerasrc_control_list_channels( this ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_value( GstCameraControl* control, \ + GstCameraControlChannel* control_channel, gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_value( this, control_channel, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_value( GstCameraControl* control, \ + GstCameraControlChannel* control_channel, gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_value( this, control_channel, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_exposure( GstCameraControl* control, \ + gint type, gint value1, gint value2 ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_exposure( this, type, value1, value2 ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_exposure( GstCameraControl* control, \ + gint type, gint* value1, gint* value2 ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_exposure( this, type, value1, value2 ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_capture_mode( GstCameraControl* control, \ + gint type, gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_capture_mode( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_capture_mode( GstCameraControl* control, \ + gint type, gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_capture_mode( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_strobe( GstCameraControl* control, \ + gint type, gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_strobe( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_strobe( GstCameraControl* control, \ + gint type, gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_strobe( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_detect( GstCameraControl* control, \ + gint type, gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_detect( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_detect( GstCameraControl* control, \ + gint type, gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_detect( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_zoom( GstCameraControl* control, \ + gint type, gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_zoom( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_zoom( GstCameraControl* control, \ + gint type, gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_zoom( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_focus( GstCameraControl* control, \ + gint focus_mode, gint focus_range ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_focus( this, focus_mode, focus_range ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_focus( GstCameraControl* control, \ + gint* focus_mode, gint* focus_range ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_focus( this, focus_mode, focus_range ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_start_auto_focus( GstCameraControl* control) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_start_auto_focus( this ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_stop_auto_focus( GstCameraControl* control) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_stop_auto_focus( this ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_focus_level( GstCameraControl* control, \ + gint focus_level ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_focus_level( this, focus_level ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_focus_level( GstCameraControl* control, \ + gint* focus_level ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_focus_level( this, focus_level ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_auto_focus_area( GstCameraControl* control, \ + GstCameraControlRectType rect ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_auto_focus_area( this, rect ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_auto_focus_area( GstCameraControl* control, \ + GstCameraControlRectType* rect ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_auto_focus_area( this, rect ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_wdr( GstCameraControl* control, \ + gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_wdr( this, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_wdr( GstCameraControl* control, \ + gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_wdr( this, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_ahs( GstCameraControl* control, \ + gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_ahs( this, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_ahs( GstCameraControl* control, \ + gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_ahs( this, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_set_part_color( GstCameraControl* control, \ + gint type, gint value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_set_part_color( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_part_color( GstCameraControl* control, \ + gint type, gint* value ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_part_color( this, type, value ); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_exif_info( GstCameraControl* control, \ + GstCameraControlExifInfo* info ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_exif_info( this, info); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_basic_dev_info( GstCameraControl* control, \ + gint dev_id, \ + GstCameraControlCapsInfoType* info ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_basic_dev_info( this, dev_id, info); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_misc_dev_info( GstCameraControl* control, \ + gint dev_id, \ + GstCameraControlCtrlListInfoType* info ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_misc_dev_info( this, dev_id, info); \ +} \ + \ +static gboolean \ +interface_as_function ## _control_get_extra_dev_info( GstCameraControl* control, \ + gint dev_id, \ + GstCameraControlExtraInfoType* info ) \ +{ \ + Type* this = (Type*)control; \ + return gst_camerasrc_control_get_extra_dev_info( this, dev_id, info); \ +} \ + \ +static void \ +interface_as_function ## _control_set_capture_command( GstCameraControl* control, \ + GstCameraControlCaptureCommand cmd ) \ +{ \ + Type* this = (Type*)control; \ + gst_camerasrc_control_set_capture_command( this, cmd ); \ + return; \ +} \ + \ +void \ +interface_as_function ## _control_interface_init( GstCameraControlClass *klass ) \ +{ \ + GST_CAMERA_CONTROL_TYPE( klass ) = GST_CAMERA_CONTROL_HARDWARE; \ + \ + /* default virtual functions */ \ + klass->list_channels = interface_as_function ## _control_list_channels; \ + klass->set_value = interface_as_function ## _control_set_value; \ + klass->get_value = interface_as_function ## _control_get_value; \ + klass->set_exposure = interface_as_function ## _control_set_exposure; \ + klass->get_exposure = interface_as_function ## _control_get_exposure; \ + klass->set_capture_mode = interface_as_function ## _control_set_capture_mode; \ + klass->get_capture_mode = interface_as_function ## _control_get_capture_mode; \ + klass->set_strobe = interface_as_function ## _control_set_strobe; \ + klass->get_strobe = interface_as_function ## _control_get_strobe; \ + klass->set_detect = interface_as_function ## _control_set_detect; \ + klass->get_detect = interface_as_function ## _control_get_detect; \ + klass->set_zoom = interface_as_function ## _control_set_zoom; \ + klass->get_zoom = interface_as_function ## _control_get_zoom; \ + klass->set_focus = interface_as_function ## _control_set_focus; \ + klass->get_focus = interface_as_function ## _control_get_focus; \ + klass->start_auto_focus = interface_as_function ## _control_start_auto_focus; \ + klass->stop_auto_focus = interface_as_function ## _control_stop_auto_focus; \ + klass->set_focus_level = interface_as_function ## _control_set_focus_level; \ + klass->get_focus_level = interface_as_function ## _control_get_focus_level; \ + klass->set_auto_focus_area = interface_as_function ## _control_set_auto_focus_area; \ + klass->get_auto_focus_area = interface_as_function ## _control_get_auto_focus_area; \ + klass->set_wdr = interface_as_function ## _control_set_wdr; \ + klass->get_wdr = interface_as_function ## _control_get_wdr; \ + klass->set_ahs = interface_as_function ## _control_set_ahs; \ + klass->get_ahs = interface_as_function ## _control_get_ahs; \ + klass->set_part_color = interface_as_function ## _control_set_part_color; \ + klass->get_part_color = interface_as_function ## _control_get_part_color; \ + klass->get_exif_info = interface_as_function ## _control_get_exif_info; \ + klass->get_basic_dev_info = interface_as_function ## _control_get_basic_dev_info; \ + klass->get_misc_dev_info = interface_as_function ## _control_get_misc_dev_info; \ + klass->get_extra_dev_info = interface_as_function ## _control_get_extra_dev_info; \ + klass->set_capture_command = interface_as_function ## _control_set_capture_command; \ + \ +} + +#endif /* __GST_CAMERASRC_CONTROL_H__ */ |