4 * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Jeongmo Yang <jm80.yang@samsung.com>
8 * This library is free software; you can redistribute it and/or modify it under
9 * the terms of the GNU Lesser General Public License as published by the
10 * Free Software Foundation; either version 2.1 of the License, or (at your option)
13 * This library is distributed in the hope that it will be useful, but WITHOUT ANY
14 * WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
16 * License for more details.
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this library; if not, write to the Free Software Foundation, Inc., 51
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "camerasrc-common.h"
25 #include "camerasrc-internal.h"
26 #include <semaphore.h>
29 #define ITLV_DATA_INFO_OFFSET 0x1000
30 #define EMBEDDED_OFFSET (2040*2+4)
32 /* extended V4L2 API */
33 #ifndef V4L2_PIX_FMT_INTERLEAVED
34 #define V4L2_PIX_FMT_INTERLEAVED v4l2_fourcc('I', 'T', 'L', 'V')
35 #endif /* V4L2_PIX_FMT_INTERLEAVED */
37 #ifndef V4L2_CID_IS_S_SCENARIO_MODE
38 #define V4L2_CID_IS_S_SCENARIO_MODE (V4L2_CID_FIMC_IS_BASE + 15)
39 #define V4L2_CID_IS_S_FORMAT_SCENARIO (V4L2_CID_FIMC_IS_BASE + 16)
41 IS_MODE_PREVIEW_STILL,
42 IS_MODE_PREVIEW_VIDEO,
43 IS_MODE_CAPTURE_STILL,
44 IS_MODE_CAPTURE_VIDEO,
47 #endif /* V4L2_CID_IS_S_SCENARIO_MODE */
49 #ifndef V4L2_CID_EMBEDDEDDATA_ENABLE
50 #define V4L2_CID_EMBEDDEDDATA_ENABLE (V4L2_CID_PRIVATE_BASE + 130)
51 #endif /* V4L2_CID_EMBEDDEDDATA_ENABLE */
57 #define EXPORT_API __attribute__((__visibility__("default")))
61 if(0 != pthread_mutex_lock(&(p->mutex))) {\
62 camsrc_error("Mutex locking error");\
68 if(0 != pthread_mutex_unlock(&(p->mutex))) {\
69 camsrc_error("Mutex unlocking error");\
74 extern const CAMERASRC_DEV_DEPENDENT_MISC_FUNC *dev_misc_func;
76 /** proto type of internal function **/
77 int _camerasrc_get_JPG_length(camerasrc_handle_t *handle);
78 int _camerasrc_get_thumbnail_JPG_length(camerasrc_handle_t *handle);
79 int _camerasrc_get_thumbnail_JPG_offset(camerasrc_handle_t *handle);
80 int _camerasrc_get_screennail_JPG_length(camerasrc_handle_t *handle);
81 int _camerasrc_get_screennail_JPG_offset(camerasrc_handle_t *handle);
82 int _camerasrc_set_thumbnail_size(camerasrc_handle_t *handle);
83 int _camerasrc_check_emp_shock(camerasrc_handle_t *handle, int *check_val);
84 int _camerasrc_set_jpeg_compress_ratio(camerasrc_handle_t *handle, unsigned int quality);
85 int _camerasrc_ioctl(camerasrc_handle_t *handle, int request, void *arg);
86 int _camerasrc_ioctl_once(camerasrc_handle_t *handle, int request, void *arg);
87 void *_camerasrc_run_autofocusing(camerasrc_handle_t *handle);
88 int _camerasrc_skip_frame(camerasrc_handle_t *handle, long int timeout, int skip_frame);
90 /**** A U T O F O C U S I N G F U N C T I O N S ****/
91 int _camerasrc_set_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect);
92 int _camerasrc_get_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect);
93 int _camerasrc_start_autofocusing(camerasrc_handle_t *handle);
94 int _camerasrc_stop_autofocusing(camerasrc_handle_t *handle);
95 int _camerasrc_release_autofocusing(camerasrc_handle_t *handle);
96 int _camerasrc_destroy_autofocusing(camerasrc_handle_t *handle);
97 int _camerasrc_init_autofocusing_mode(camerasrc_handle_t *handle);
99 int _camerasrc_get_frame_data(camerasrc_handle_t *handle, camerasrc_frame_data_t *data);
100 int _camerasrc_get_exif_info(camerasrc_handle_t *handle, camerasrc_buffer_t *exif_string);
101 int _camerasrc_copy_frame(camerasrc_handle_t *handle, camerasrc_buffer_t *src_buffer, camerasrc_buffer_t *dst_buffer, int isThumbnail);
102 int _camerasrc_query_ctrl_menu(camerasrc_handle_t *handle, struct v4l2_queryctrl queryctrl, camerasrc_ctrl_info_t *ctrl_info);
109 } camerasrc_sync_param_t;
111 int camsrc_create_sync(const camerasrc_sync_param_t *param)
115 sem = sem_open(param->key_path, O_CREAT, 0666, 1);
116 if (sem == SEM_FAILED) {
119 camsrc_error("The semaphore already exist, but caller does not have permission %s", param->key_path);
122 camsrc_error("Insufficient memory");
125 camsrc_error("Too many open files in system");
128 camsrc_critical("Semaphore create fail! (name:%s, errno %d)", param->key_path, errno);
131 return CAMERASRC_ERR_INTERNAL;
134 return CAMERASRC_SUCCESS;
137 int camsrc_remove_sync(const camerasrc_sync_param_t *param)
141 err = sem_unlink(param->key_path);
143 camsrc_critical("Semaphore destroy Fail! (name:%s, errno %d)", param->key_path, errno);
144 return CAMERASRC_ERR_INTERNAL;
147 return CAMERASRC_SUCCESS;
150 int camsrc_lock_sync(const camerasrc_sync_param_t *param)
154 int err = CAMERASRC_SUCCESS;
156 struct timespec wait_time;
158 sem = sem_open(param->key_path, O_CREAT, 0666, 1);
159 if (sem == SEM_FAILED)
161 camsrc_critical("Semaphore open Fail! (name:%s, errno %d)", param->key_path, errno);
162 return CAMERASRC_ERR_INTERNAL;
166 wait_time.tv_sec = (long int)(time(NULL)) + 6;
167 wait_time.tv_nsec = 0;
169 ret = sem_timedwait(sem, &wait_time);
173 camsrc_critical("Lock RETRY LOCK");
177 camsrc_critical("Invalid semaphore");
178 err = CAMERASRC_ERR_INTERNAL;
181 camsrc_critical("EAGAIN");
182 err = CAMERASRC_ERR_INTERNAL;
185 camsrc_critical("sem_wait leached %d seconds timeout.", 6);
186 /* Recovery of sem_wait lock....in abnormal condition */
187 if (0 == sem_getvalue(sem, &sem_value)) {
188 camsrc_critical("%s sem value is %d",param->key_path, sem_value);
189 if (sem_value == 0) {
192 camsrc_critical("sem_post error %s : %d", param->key_path, sem_value);
194 camsrc_critical("lock recovery success...try lock again");
198 camsrc_critical("sem value is not 0. but failed sem_timedwait so retry.. : %s",param->key_path);
203 camsrc_critical("sem_getvalue failed : %s",param->key_path);
205 err = CAMERASRC_ERR_INTERNAL;
213 int camsrc_unlock_sync(const camerasrc_sync_param_t *param)
217 int err = CAMERASRC_SUCCESS;
219 sem = sem_open(param->key_path, O_CREAT, 0666, 1);
220 if (sem == SEM_FAILED) {
221 camsrc_critical("Semaphore open Fail! (name:%s, errno %d)", param->key_path, errno);
222 return CAMERASRC_ERR_INTERNAL;
227 camsrc_critical("UNLOCK FAIL");
228 err = CAMERASRC_ERR_INTERNAL;
237 #if defined(USE_CAMERASRC_FRAME_DUMP)
238 #define WRITE_UNIT 4096
239 static int seq_no = 0;
241 static void write_buffer_into_path(camerasrc_buffer_t *buffer, char *path, char *name)
246 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
248 sprintf(temp_fn, "%s/%s", path, name);
250 fd = open(temp_fn, O_CREAT | O_WRONLY | O_SYNC);
253 strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
254 camsrc_error("OPEN ERR!!!! : %s", err_msg);
257 camsrc_info("Open success, FD = %d, seq = %d", fd, seq_no);
260 int write_remain = buffer->length;
263 while (write_remain > 0) {
264 write_len = write(fd, buffer->start + offset, write_remain<WRITE_UNIT?write_remain:WRITE_UNIT);
266 strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
267 camsrc_error("WRITE ERR!!!! : %s", err_msg);
270 write_remain -= write_len;
272 camsrc_info("%d written, %d left", write_len, write_remain);
280 #define CAMERASRC_SET_CMD(cmd, value) _camerasrc_set_cmd(handle, cmd, (void*)value);
281 #define CAMERASRC_GET_CMD(cmd, value) _camerasrc_get_cmd(handle, cmd, (void*)value);
284 static int _camerasrc_set_cmd(camsrc_handle_t handle, _camsrc_cmd_t cmd, void *value)
286 camerasrc_handle_t *p = NULL;
287 int err = CAMERASRC_ERR_UNKNOWN;
289 camsrc_info("enter");
291 if (handle == NULL) {
292 camsrc_error("handle is null");
293 return CAMERASRC_ERR_NULL_POINTER;
296 p = CAMERASRC_HANDLE(handle);
298 if (dev_misc_func->_set_cmd == NULL) {
299 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
302 err = dev_misc_func->_set_cmd(p, cmd, value);
307 static int _camerasrc_get_cmd(camsrc_handle_t handle, _camsrc_cmd_t cmd, void *value)
309 camerasrc_handle_t *p = NULL;
310 int err = CAMERASRC_ERR_UNKNOWN;
313 camsrc_error("handle is null");
314 return CAMERASRC_ERR_NULL_POINTER;
317 p = CAMERASRC_HANDLE(handle);
319 if(dev_misc_func->_get_cmd == NULL)
320 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
322 err = dev_misc_func->_get_cmd(p, cmd, value);
328 int camerasrc_support_embed_exif(camsrc_handle_t handle, int* support_exif)
330 int err = CAMERASRC_ERR_UNKNOWN;
332 err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_SUPPORT_EMBED_EXIF, support_exif);
333 if(err != CAMERASRC_SUCCESS) *support_exif = -1;
339 int camerasrc_support_jpeg_encoding(camsrc_handle_t handle, int *support_jpeg_encoding)
341 int err = CAMERASRC_ERR_UNKNOWN;
343 err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_SUPPORT_JPEG_ENCODING, support_jpeg_encoding);
344 if (err != CAMERASRC_SUCCESS) {
345 *support_jpeg_encoding = 0;
352 int camerasrc_get_screennail_buffer(camsrc_handle_t handle, camerasrc_buffer_t *scrnl_buf)
354 camerasrc_handle_t *p = NULL;
356 if (handle == NULL) {
357 camsrc_error("handle is null");
358 return CAMERASRC_ERR_NULL_POINTER;
361 if (scrnl_buf == NULL) {
362 camsrc_error("scrnl_buf is null");
363 return CAMERASRC_ERR_INVALID_PARAMETER;
366 p = CAMERASRC_HANDLE(handle);
368 scrnl_buf->start = p->scrnl_buf.start;
369 scrnl_buf->length = p->scrnl_buf.length;
371 camsrc_info("screennail ptr[%p],length[%d]", scrnl_buf->start, scrnl_buf->length);
373 return CAMERASRC_SUCCESS;
377 int camerasrc_start_facedetection(camsrc_handle_t handle)
379 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_FACEDETECTION, _CAMERASRC_FACEDETECTION_START);
383 int camerasrc_stop_facedetection(camsrc_handle_t handle)
385 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_FACEDETECTION, _CAMERASRC_FACEDETECTION_STOP);
389 int camerasrc_get_facedetection(camsrc_handle_t handle, int *is_detecting)
391 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_FACEDETECTION, is_detecting);
395 int camerasrc_set_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t frac)
397 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_SHUTTER_SPEED, &frac);
401 int camerasrc_get_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t *frac)
403 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_SHUTTER_SPEED, frac);
407 int camerasrc_set_exposure_value(camsrc_handle_t handle, camerasrc_frac_t frac)
409 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_EXPOSURE_VALUE, &frac);
413 int camerasrc_get_exposure_value(camsrc_handle_t handle, camerasrc_frac_t *frac)
415 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_EXPOSURE_VALUE, frac);
419 int camerasrc_set_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t mode)
421 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_STROBE_MODE, &mode);
425 int camerasrc_get_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t *mode)
427 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_STROBE_MODE, mode);
431 int camerasrc_set_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int value)
433 _camerasrc_ctrl_t ctrl;
440 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_CTRL, &ctrl);
444 int camerasrc_get_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int *value)
446 int err = CAMERASRC_ERR_UNKNOWN;
447 _camerasrc_ctrl_t ctrl;
453 err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_CTRL, &ctrl);
454 if (err != CAMERASRC_SUCCESS) {
464 int camerasrc_query_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t *ctrl_info)
466 struct v4l2_queryctrl queryctrl;
468 if (ctrl_id < CAMERASRC_CTRL_BRIGHTNESS || ctrl_id >= CAMERASRC_CTRL_NUM) {
469 camsrc_warning("invalid ctrl_id [%d]", ctrl_id);
470 return CAMERASRC_ERR_INVALID_PARAMETER;
475 queryctrl.id = _CAMERASRC_GET_CID(ctrl_id, CAMERASRC_HANDLE(handle)->cur_dev_id);
476 if (queryctrl.id == -1 ) {
477 camsrc_warning("not supported ctrl_id [%d]", ctrl_id);
478 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
481 if (0 == _camerasrc_ioctl( handle, VIDIOC_QUERYCTRL, &queryctrl)) {
482 if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED) {
483 camsrc_info("ID [%8x] disabled", queryctrl.id);
486 ctrl_info->v4l2_ctrl_id = queryctrl.id;
487 ctrl_info->camsrc_ctrl_id = ctrl_id;
489 switch (queryctrl.type) {
490 case V4L2_CTRL_TYPE_INTEGER:
491 ctrl_info->ctrl_type = CTRL_TYPE_RANGE;
493 case V4L2_CTRL_TYPE_BOOLEAN:
494 ctrl_info->ctrl_type = CTRL_TYPE_BOOL;
496 case V4L2_CTRL_TYPE_MENU:
497 ctrl_info->ctrl_type = CTRL_TYPE_ARRAY;
498 _camerasrc_query_ctrl_menu (handle, queryctrl, ctrl_info);
501 ctrl_info->ctrl_type = CTRL_TYPE_UNKNOWN;
505 memcpy(ctrl_info->ctrl_name, queryctrl.name, MAX_SZ_CTRL_NAME_STRING);
506 ctrl_info->min = queryctrl.minimum;
507 ctrl_info->max = queryctrl.maximum;
508 ctrl_info->step = queryctrl.step;
509 ctrl_info->default_val = queryctrl.default_value;
511 camsrc_info("Control name : %s, type %d, min %d, max %d, step %d, default %d",
512 queryctrl.name, queryctrl.type,
513 queryctrl.minimum, queryctrl.maximum,
514 queryctrl.step, queryctrl.default_value);
516 camsrc_error("VIDIOC_QUERYCTRL error");
518 return CAMERASRC_ERR_IO_CONTROL;
521 return CAMERASRC_SUCCESS;
525 int camerasrc_support_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id)
527 return CAMERASRC_SUCCESS;
531 int _camerasrc_get_JPG_length(camerasrc_handle_t *handle)
535 CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_LENGTH, &jpg_length);
541 int _camerasrc_get_thumbnail_JPG_length(camerasrc_handle_t *handle)
545 CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_LENGTH, &jpg_length);
551 int _camerasrc_get_thumbnail_JPG_offset(camerasrc_handle_t *handle)
555 CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_OFFSET, &thumb_offset);
561 int _camerasrc_get_screennail_JPG_length(camerasrc_handle_t *handle)
565 CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_SCRNL_LENGTH, &length);
571 int _camerasrc_get_screennail_JPG_offset(camerasrc_handle_t *handle)
575 CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_SCRNL_OFFSET, &offset);
581 int _camerasrc_set_thumbnail_size(camerasrc_handle_t *handle)
583 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_LENGTH, NULL);
587 int _camerasrc_check_emp_shock(camerasrc_handle_t *handle, int *check_val)
589 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_ESD_CHECK, check_val);
593 int _camerasrc_set_jpeg_compress_ratio(camerasrc_handle_t *handle, unsigned int quality)
595 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_JPEG_COMPRESS_RATIO, &quality);
599 int _camerasrc_ioctl(camerasrc_handle_t *handle, int request, void *arg)
601 if (dev_misc_func->_ioctl == NULL) {
602 #if USE_NOT_SUPPORT_ERR
603 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
605 return CAMERASRC_SUCCESS;
609 return dev_misc_func->_ioctl(handle, request, arg);
613 int _camerasrc_ioctl_once(camerasrc_handle_t *handle, int request, void *arg)
615 if (dev_misc_func->_ioctl_once == NULL) {
616 #if USE_NOT_SUPPORT_ERR
617 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
619 return CAMERASRC_SUCCESS;
623 return dev_misc_func->_ioctl_once(handle, request, arg);
627 void *_camerasrc_run_autofocusing(camerasrc_handle_t *handle)
629 if (dev_misc_func->_run_autofocusing != NULL) {
630 dev_misc_func->_run_autofocusing(handle);
637 int _camerasrc_skip_frame(camerasrc_handle_t *handle, long int timeout, int skip_frame)
639 if (dev_misc_func->_skip_frame == NULL) {
640 #if USE_NOT_SUPPORT_ERR
641 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
643 return CAMERASRC_SUCCESS;
647 return dev_misc_func->_skip_frame(handle, timeout, skip_frame);
650 /**** A U T O F O C U S I N G F U N C T I O N S ****/
651 int _camerasrc_set_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect)
653 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_AREA, rect);
656 int _camerasrc_get_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect)
658 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_AF_AREA, rect);
661 int _camerasrc_start_autofocusing(camerasrc_handle_t *handle)
663 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_START);
666 int _camerasrc_stop_autofocusing(camerasrc_handle_t *handle)
668 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_STOP);
671 int _camerasrc_release_autofocusing(camerasrc_handle_t *handle)
673 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_RELEASE);
676 int _camerasrc_destroy_autofocusing(camerasrc_handle_t *handle)
678 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_DESTROY);
681 int _camerasrc_init_autofocusing_mode(camerasrc_handle_t *handle)
683 return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_INIT);
687 int _camerasrc_get_frame_data(camerasrc_handle_t *handle, camerasrc_frame_data_t *data)
689 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_FRAME_DATA, data);
692 int _camerasrc_get_exif_info(camerasrc_handle_t *handle, camerasrc_buffer_t *exif_string)
694 return CAMERASRC_GET_CMD(_CAMERASRC_CMD_EXIF_INFO, exif_string);
698 int _camerasrc_copy_frame(camerasrc_handle_t *handle, camerasrc_buffer_t *src_buffer, camerasrc_buffer_t *dst_buffer, int isThumbnail)
700 if (dev_misc_func->_copy_frame == NULL) {
701 #if USE_NOT_SUPPORT_ERR
702 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
704 return CAMERASRC_SUCCESS;
708 return dev_misc_func->_copy_frame(handle, src_buffer, dst_buffer, isThumbnail);
713 static int _camerasrc_chk_opened(char *conf_filename)
715 camsrc_info("enter");
717 char buf[CAMERASRC_MAX_FILENAME_LEN] = {'\0',};
718 char proc_buf[CAMERASRC_MAX_FILENAME_LEN] = {'\0',};
725 int err = CAMERASRC_SUCCESS;
727 fd = open(conf_filename, O_RDONLY);
728 if (fd == -1 && errno == ENOENT) {
729 camsrc_info("File not exist!!, first open from this boot. open...");
730 return CAMERASRC_SUCCESS;
731 } else if (fd == -1 && errno != ENOENT) {
732 camsrc_info("File open error. log file open error!");
733 return CAMERASRC_ERR_INTERNAL;
735 camsrc_info("Dev has been opened. start check...");
738 len = read(fd, buf, CAMERASRC_MAX_FILENAME_LEN);
739 sscanf(buf, "%2d:%5d:%64s", &buf_len, &pid, access);
741 camsrc_info("%d : %d : %s", buf_len, pid, access);
743 camsrc_info("Wrong written check file!");
746 return CAMERASRC_ERR_INTERNAL;
749 if (!strcmp(access, CAMERASRC_DEV_RELEASED_STR)) {
750 camsrc_info("Has opened but closed properly!");
753 return CAMERASRC_SUCCESS;
756 if (pid == getpid()) {
757 camsrc_info("Double open!! You can't go. Investigate the PID's FD list");
760 return CAMERASRC_ERR_DEVICE_BUSY;
763 snprintf(proc_buf, CAMERASRC_MAX_FILENAME_LEN, "/proc/%d", pid);
764 err_fd = open(proc_buf, O_RDONLY | O_NONBLOCK, 0);
766 camsrc_info("The proc node [%s] are not exist it's fake node", proc_buf);
767 err = CAMERASRC_SUCCESS;
769 camsrc_info("The proc node [%s] are loaded. almost opened...", proc_buf);
772 err = CAMERASRC_ERR_DEVICE_BUSY;
781 static int __camerasrc_open_device(camerasrc_handle_t *p)
783 #define MAX_DEVICE_COUNT 4
786 int ret = CAMERASRC_ERR_DEVICE_NOT_FOUND;
787 char device_name[MAX_SZ_DEV_NAME_STRING] = {'\0',};
788 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
789 struct v4l2_capability capability;
791 for (i = 0 ; i < MAX_DEVICE_COUNT ; i++) {
792 snprintf(device_name, MAX_SZ_DEV_NAME_STRING, "%s%d", CAMERASRC_DEV_NODE_PREFIX, i);
793 camsrc_info("try to open %s", device_name);
795 p->dev_fd = open(device_name, O_RDWR | O_NONBLOCK, 0);
798 strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
799 camsrc_error("Device open fail [%d][%s]", errno, err_msg);
803 ret = CAMERASRC_ERR_DEVICE_BUSY;
807 ret = CAMERASRC_ERR_DEVICE_NOT_FOUND;
810 ret = CAMERASRC_ERR_DEVICE_OPEN;
818 camsrc_info("opened device fd %d", p->dev_fd);
820 /* open success and check capabilities */
821 ioctl_ret = _camerasrc_ioctl((camerasrc_handle_t *)p, VIDIOC_QUERYCAP, &capability);
822 if (ioctl_ret == CAMERASRC_SUCCESS) {
823 /* succeeded : VIDIOC_QUERYCAP */
824 camsrc_info("capabilities %x", capability.capabilities);
825 if (capability.capabilities & V4L2_CAP_VIDEO_CAPTURE) {
826 camsrc_info("found capture device %s", device_name);
827 return CAMERASRC_SUCCESS;
830 camsrc_warning("VIDIOC_QUERYCAP error %x", ioctl_ret);
838 camsrc_error("failed to find capture device %x", ret);
843 static int _camerasrc_seamless_record_onaccess_open(char *conf_filename, camerasrc_handle_t *p)
845 camsrc_info("enter");
849 int ret = CAMERASRC_SUCCESS;
851 char tot_buf[BUF_LEN];
852 camerasrc_sync_param_t syncparam = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX};
854 camsrc_lock_sync(&syncparam);
856 if (p->dev_fd == -1) {
857 ret = __camerasrc_open_device(p);
858 if (ret != CAMERASRC_SUCCESS) {
859 camsrc_error("open failed %x", ret);
860 camsrc_unlock_sync(&syncparam);
864 p->is_async_open = 0;
866 p->is_async_open = 1;
869 /* Write open status */
870 fd = open(conf_filename, O_RDWR | O_NONBLOCK | O_CREAT, 0666);
872 camsrc_info("failed to open ", conf_filename);
873 /* Release camera device */
876 return CAMERASRC_ERR_INTERNAL;
880 * record like below format
881 * A : (integer) length of this info without this number and semicolon
882 * B : (integer) Process ID of process that open the device
883 * C : (string) Status of camera device. ONACCESS / RELEASED (9 words)
884 * format : "%d:%d:%s", A, B, C
886 len = snprintf(buf, BUF_LEN, "%d:%s", getpid(), CAMERASRC_DEV_ON_ACCESS_STR);
887 len = snprintf(tot_buf, BUF_LEN, "%d:%s", len, buf);
889 len = write(fd, tot_buf, len+1);
894 camsrc_unlock_sync(&syncparam);
896 return CAMERASRC_SUCCESS;
900 static int _camerasrc_seamless_delete_onaccess(char *conf_filename, camerasrc_handle_t *p)
902 camsrc_info("enter");
907 int err = CAMERASRC_ERR_UNKNOWN;
909 char tot_buf[BUF_LEN];
910 camerasrc_sync_param_t param = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX};
911 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
913 camsrc_info("Start delete...");
915 /* TODO : Semaphore lock */
916 camsrc_lock_sync(¶m);
918 if (!(p->is_async_open)) {
922 chk_fd = open(conf_filename, O_WRONLY | O_NONBLOCK);
924 camsrc_info("FD = %d", fd);
925 return CAMERASRC_ERR_INTERNAL;
928 len = snprintf(buf, BUF_LEN, "%d:%s", getpid(), CAMERASRC_DEV_RELEASED_STR);
929 camsrc_info("using string : %s", buf);
931 len = snprintf(tot_buf, BUF_LEN, "%d:%s", len, buf);
932 camsrc_info("write string final : %s", tot_buf);
934 len = write(chk_fd, tot_buf, len);
936 strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
937 camsrc_info("WRITE ERROR!!!!, error = %s, fd = %d", err_msg, chk_fd);
942 camsrc_unlock_sync(¶m);
943 /* TODO : Semaphore unlock */
944 err = CAMERASRC_SUCCESS;
945 camsrc_info("End delete...");
951 static int _camerasrc_initialize_handle(camerasrc_handle_t *handle)
953 camsrc_info("enter");
955 if (handle == NULL) {
956 camsrc_error("handle is null");
957 return CAMERASRC_ERR_NULL_POINTER;
960 /* Initialize handle variables */
961 handle->buffer = NULL;
962 handle->is_async_open = 0;
964 handle->cur_dev_id = CAMERASRC_DEV_ID_UNKNOWN;
965 handle->check_esd = 0;
966 handle->is_preset = 0;
967 handle->resolution = 0;
968 handle->buffer_idx = 0;
969 handle->num_buffers = 0;
970 handle->buffer = NULL;
971 handle->present_buf = NULL;
972 handle->io_method = CAMERASRC_IO_METHOD_MMAP;
973 handle->af_status = CAMERASRC_AUTO_FOCUS_STATUS_RELEASED;
974 handle->af_cmd = CAMERASRC_AUTO_FOCUS_CMD_NULL;
975 handle->cur_af_mode = CAMERASRC_AF_MODE_AUTO;
976 handle->cur_af_range = CAMERASRC_AF_RANGE_NORMAL;
977 handle->af_usr_data = NULL;
978 handle->skip_frame_func = NULL;
979 handle->isAutoexposure = 1;
980 handle->af_cb = NULL;
981 handle->first_frame = 1;
982 handle->af_init_called = 0;
983 handle->hold_af_after_capturing = 0;
985 if (gettimeofday(&handle->set_af_area_time, NULL) != 0) {
986 handle->set_af_area_time.tv_sec = 0;
987 handle->set_af_area_time.tv_usec = 0;
988 camsrc_warning("[init handle] gettimeofday Failed");
991 CLEAR(handle->queued_buf_list);
992 CLEAR(handle->format);
994 return CAMERASRC_SUCCESS;
998 static int _camerasrc_wait_frame_available(camerasrc_handle_t *handle, long int timeout)
1000 camerasrc_handle_t *p = handle;
1005 #if defined (USE_SKIP_FRAME)
1006 int skip_frame = CAMERASRC_JPG_STILL_SKIP_FRAME;
1009 if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) {
1010 /* Wait time FPS time */
1011 if (p->timeperframe.denominator == 0 && p->timeperframe.numerator == 0) {
1012 usleep((int)1000000/30); /* supposed to 1/30 sec */
1014 usleep((int)(1000000 * p->timeperframe.numerator / p->timeperframe.denominator));
1017 camsrc_info("Device emergency closed. wait will return proper time");
1019 return CAMERASRC_SUCCESS;
1023 * @note In preview or video mode, skip_frame_func, signaling_func will be NULL
1024 * If unnecessary, just input them to NULL in start_still/preview/video_stream()
1028 FD_SET(p->dev_fd, &fds);
1031 #if defined (USE_SKIP_FRAME)
1032 if(p->skip_frame_func != NULL) {
1033 camsrc_info("Skip frame function enabled!");
1034 err = p->skip_frame_func(p, timeout, skip_frame);
1039 tv.tv_sec = (long int)timeout/1000;
1040 tv.tv_usec = timeout * 1000 - tv.tv_sec * 1000000;
1042 /* select waiting */
1043 r = select(p->dev_fd + 1, &fds, NULL, NULL, &tv);
1045 if (EINTR == errno) {
1046 return CAMERASRC_SUCCESS;
1048 camsrc_error("select() failed.");
1050 return CAMERASRC_ERR_INTERNAL;
1054 return CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT;
1057 return CAMERASRC_SUCCESS;
1061 struct v4l2_buffer *_camerasrc_get_correct_buf(camerasrc_handle_t *handle, struct v4l2_buffer *queued_buf_list, camerasrc_buffer_t *buffer)
1063 unsigned int num_buffers = 0;
1065 camerasrc_get_num_buffer(handle, &num_buffers);
1067 for (cnt = 0 ; cnt < num_buffers ; cnt++) {
1068 if (queued_buf_list[cnt].m.userptr == (unsigned long)buffer->start) {
1069 return &(queued_buf_list[cnt]);
1077 static int _camerasrc_queue_buffer(camerasrc_handle_t *handle, int buf_index, camerasrc_buffer_t *buffer)
1079 camerasrc_handle_t *p = handle;
1080 struct v4l2_buffer vbuf;
1081 struct v4l2_buffer *pvbuf;
1082 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1084 if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) {
1085 camsrc_info("Device emergency closed. Q will return successfully");
1086 return CAMERASRC_SUCCESS;
1089 if (buf_index >= p->num_buffers) {
1090 camsrc_info("Late buffer won't be queued, buf_index = %d, p->num_buffers = %d", buf_index, p->num_buffers);
1091 return CAMERASRC_SUCCESS;
1096 switch (p->io_method) {
1097 case CAMERASRC_IO_METHOD_MMAP:
1098 if (p->buffer[buf_index].queued_status == CAMERASRC_BUFFER_QUEUED) {
1099 camsrc_info("buffer[index:%d] is already queued. return success.", buf_index);
1100 return CAMERASRC_SUCCESS;
1103 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1104 vbuf.memory = V4L2_MEMORY_MMAP;
1105 vbuf.index = buf_index;
1108 case CAMERASRC_IO_METHOD_USRPTR:
1109 if (&(p->queued_buf_list[buf_index])) {
1110 pvbuf = _camerasrc_get_correct_buf(handle, p->queued_buf_list, buffer);
1113 if (pvbuf == NULL) {
1114 camsrc_error("Wrong address tried to queueing!, It'll be queued as input index..");
1115 pvbuf = &(p->queued_buf_list[buf_index]);
1118 case CAMERASRC_IO_METHOD_READ:
1120 camsrc_error("Device not support that io-method");
1121 #if USE_NOT_SUPPORT_ERR
1122 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1124 return CAMERASRC_SUCCESS;
1128 if (CAMERASRC_STATE(handle) == CAMERASRC_STATE_READY) {
1129 camsrc_warning("Q after ready state will success");
1130 return CAMERASRC_SUCCESS;
1133 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, pvbuf)) {
1134 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1135 camsrc_info("VIDIOC_QBUF failed : %s", err_msg);
1136 return CAMERASRC_ERR_IO_CONTROL;
1140 if (p->io_method == CAMERASRC_IO_METHOD_MMAP) {
1141 p->buffer[buf_index].queued_status = CAMERASRC_BUFFER_QUEUED;
1142 p->queued_buffer_count++;
1146 return CAMERASRC_SUCCESS;
1150 static int _camerasrc_get_proper_index(camerasrc_handle_t *handle, void *data)
1154 for (i = 0; i < handle->num_buffers; i++) {
1155 if (handle->buffer[i].start == data) {
1160 camsrc_info("Index NOT found. new buffer... go to error");
1166 static int _camerasrc_dequeue_buffer(camerasrc_handle_t *handle, int *buf_index, camerasrc_buffer_t *buffer, camerasrc_buffer_t *thm_buffer)
1168 camerasrc_handle_t *p = handle;
1169 int err = CAMERASRC_ERR_UNKNOWN;
1170 struct v4l2_buffer vbuf;
1171 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1173 if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) {
1175 buffer = &p->alter_frame;
1177 camsrc_info("Device emergency closed. DQ return fake frame");
1178 return CAMERASRC_SUCCESS;
1181 switch(p->io_method) {
1182 case CAMERASRC_IO_METHOD_MMAP:
1184 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1185 vbuf.memory = V4L2_MEMORY_MMAP;
1187 case CAMERASRC_IO_METHOD_USRPTR:
1189 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1190 vbuf.memory = V4L2_MEMORY_USERPTR;
1192 case CAMERASRC_IO_METHOD_READ:
1194 camsrc_error("Device not support that io-method");
1195 #if USE_NOT_SUPPORT_ERR
1196 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1198 return CAMERASRC_SUCCESS;
1202 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_DQBUF, &vbuf)) {
1203 switch (p->errnum) {
1205 camsrc_info("VIDIOC_DQBUF [EAGAIN]");
1206 return CAMERASRC_SUCCESS;
1208 /* Could ignore EIO, see spec. */
1210 camsrc_info("VIDIOC_DQBUF [EIO]");
1213 camsrc_info("VIDIOC_DQBUF [EINVAL]");
1214 printf("VIDIOC_DQBUF [EINVAL]");
1215 return CAMERASRC_ERR_INVALID_VALUE;
1217 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1218 camsrc_info("VIDIOC_DQBUF [%s]", err_msg);
1224 if (CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW &&
1225 p->first_frame && _CAMERASRC_SUPPORT_AF(p->cur_dev_id)) {
1226 camsrc_info("AF init at first frame, hold_Af %d", p->hold_af_after_capturing);
1227 if (!(p->af_init_called) || !(p->hold_af_after_capturing)) {
1228 err = _camerasrc_init_autofocusing_mode(p);
1229 if (err != CAMERASRC_SUCCESS) {
1230 camsrc_warning("AF init failed");
1232 p->af_init_called = 1;
1235 camsrc_info("AF init SKIP!");
1241 if (CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW || CAMERASRC_STATE(p) == CAMERASRC_STATE_VIDEO ||
1242 (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL && p->format.colorspace == CAMERASRC_COL_RAW) ||
1243 (CAMERASRC_STATE(p) == CAMERASRC_STATE_AF_IN_PROGRESS && p->format.colorspace == CAMERASRC_COL_RAW)) {
1244 switch(p->io_method) {
1245 case CAMERASRC_IO_METHOD_MMAP:
1246 *buf_index = vbuf.index;
1247 buffer->start = p->buffer[vbuf.index].start;
1249 p->buffer[vbuf.index].queued_status = CAMERASRC_BUFFER_DEQUEUED;
1250 p->queued_buffer_count--;
1253 switch (p->format.pix_format ) {
1254 case CAMERASRC_PIX_YUV422P:
1255 case CAMERASRC_PIX_YUY2:
1256 case CAMERASRC_PIX_UYVY:
1257 case CAMERASRC_PIX_RGB565:
1258 buffer->length = YUV422_SIZE(p);
1260 case CAMERASRC_PIX_YUV420P:
1261 case CAMERASRC_PIX_SN12:
1262 case CAMERASRC_PIX_ST12:
1263 case CAMERASRC_PIX_NV12:
1264 buffer->length = YUV420_SIZE(p);
1266 case CAMERASRC_PIX_INTERLEAVED:
1268 unsigned char *p_size_info = NULL;
1270 if (vbuf.index == 2) {
1271 FILE *fp = fopen("./test2.dump", "w+");
1272 fwrite(buffer->start, p->buffer[vbuf.index].length, 1, fp);
1277 p_size_info = (unsigned char *)(buffer->start + (p->buffer[vbuf.index].length - ITLV_DATA_INFO_OFFSET));
1278 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];
1279 camsrc_info("total %d, addr %x, data size %d",
1280 (int)(p->buffer[vbuf.index].length), buffer->start, buffer->length);
1283 case CAMERASRC_PIX_RGGB10:
1284 case CAMERASRC_PIX_RGGB8:
1286 buffer->length = -1;
1290 buffer->length = vbuf.bytesused;
1293 case CAMERASRC_IO_METHOD_USRPTR:
1298 for (i = 0; i < p->present_buf->num_buffer; ++i) {
1299 #if defined (USE_USERPTR_DEBUG)
1300 camsrc_info("buffers[%d].start: %p", i, p->buffer[i].start);
1301 camsrc_info("buffers[%d].length: %d", i, p->buffer[i].length);
1302 camsrc_info("buf.m.userptr: %p", vbuf.m.userptr);
1303 camsrc_info("buf.length: %d", vbuf.length);
1305 if (vbuf.m.userptr == (unsigned long) p->buffer[i].start) {
1312 camsrc_error("Dequeued buffer not matched to user ptr!");
1313 return CAMERASRC_ERR_IO_CONTROL;
1316 *buf_index = _camerasrc_get_proper_index(p, (void*)vbuf.m.userptr);
1317 buffer->start = (unsigned char*)vbuf.m.userptr;
1318 buffer->length = vbuf.length;
1322 case CAMERASRC_IO_METHOD_READ:
1324 camsrc_error("Device not support that io-method");
1325 #if USE_NOT_SUPPORT_ERR
1326 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1328 return CAMERASRC_SUCCESS;
1332 } else if (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL && p->format.colorspace == CAMERASRC_COL_JPEG) {
1334 switch (p->io_method) {
1335 case CAMERASRC_IO_METHOD_MMAP:
1336 camsrc_info("JPEG frame dequeueing..");
1337 *buf_index = vbuf.index;
1338 buffer->start = p->buffer[vbuf.index].start;
1339 buffer->length = _camerasrc_get_JPG_length(p);
1341 p->buffer[vbuf.index].queued_status = CAMERASRC_BUFFER_DEQUEUED;
1342 p->queued_buffer_count--;
1344 camsrc_info("JPEG frame length = %d", buffer->length);
1345 /* If splitted thumbnail jpeg, it should know about both sizes */
1346 if (thm_buffer != NULL) {
1347 if(p->format.pix_format == CAMERASRC_PIX_RGGB10) {
1348 thm_buffer->start = p->buffer[vbuf.index].start + CAMERASRC_RAW_STILL_THUMBNAIL_OFFSET;
1349 thm_buffer->length = CAMERASRC_YUV_THMBNL_SIZE;
1350 camsrc_info("Thumbnail JPEG frame length = %d", thm_buffer->length);
1352 else if(p->format.pix_format == CAMERASRC_PIX_RGGB8) {
1353 unsigned int thumb_offset = 0, thumb_length = 0;
1355 thumb_offset = _camerasrc_get_thumbnail_JPG_offset(p);
1356 thumb_length = _camerasrc_get_thumbnail_JPG_length(p);
1358 if( thumb_offset == 0 || thumb_length == 0 )
1360 thm_buffer->start = NULL;
1361 thm_buffer->length = 0;
1362 camsrc_info("Get Thumbnail JPEG frame failed.(offset:0x%x,length:%d)", thumb_offset, thumb_length);
1366 thm_buffer->start = p->buffer[vbuf.index].start + thumb_offset;
1367 thm_buffer->length = thumb_length;
1368 camsrc_info("Thumbnail JPEG frame %p (offset 0x%x, length %d)", thm_buffer->start, thumb_offset, thumb_length);
1372 camsrc_error("Unknown image format... ");
1373 #if USE_NOT_SUPPORT_ERR
1374 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1376 return CAMERASRC_SUCCESS;
1381 /* Get screennail buffer */
1382 p->scrnl_buf.start = p->buffer[vbuf.index].start + _camerasrc_get_screennail_JPG_offset(p);
1383 p->scrnl_buf.length = _camerasrc_get_screennail_JPG_length(p);
1386 * In some module(or along firmware), it doesn't support jpg image
1387 * splitted with thumbnail And its size always reported as bytesused field.
1388 * "buffer->length == 0" means it won't support splitted jpg output
1390 camsrc_info("buffer->length = %d, vbuf.bytesused=%d", buffer->length, vbuf.bytesused);
1391 if (buffer->length == 0) {
1392 camsrc_info("it'll be copied as size = %d", vbuf.bytesused);
1393 buffer->length = vbuf.bytesused;
1397 case CAMERASRC_IO_METHOD_USRPTR:
1402 for (i = 0; i < p->present_buf->num_buffer; ++i) {
1403 #if defined (USE_USERPTR_DEBUG)
1404 camsrc_info("buffers[%d].start: %d", i, p->buffer[i].start);
1405 camsrc_info("buffers[%d].length: %d", i, p->buffer[i].length);
1406 camsrc_info("buf.m.userptr: %d", vbuf.m.userptr);
1407 camsrc_info("buf.length: %d", vbuf.length);
1409 if (vbuf.m.userptr == (unsigned long) p->buffer[i].start) {
1416 camsrc_error("Dequeued buffer not matched to user ptr!");
1417 return CAMERASRC_ERR_IO_CONTROL;
1420 camsrc_info("JPEG frame dequeueing..");
1421 *buf_index = vbuf.index;
1422 buffer->start = (unsigned char*)vbuf.m.userptr;
1423 buffer->length = _camerasrc_get_JPG_length(p);
1424 if (buffer->length == 0) {
1425 return CAMERASRC_ERR_INVALID_PARAMETER;
1427 camsrc_info("JPEG frame length = %d", buffer->length);
1429 if (thm_buffer != NULL) {
1430 if (p->format.pix_format == CAMERASRC_PIX_RGGB10) {
1431 /* JPEG + YUV thumbnail */
1432 thm_buffer->start = p->buffer[i].start + CAMERASRC_RAW_STILL_THUMBNAIL_OFFSET;
1433 thm_buffer->length = CAMERASRC_YUV_THMBNL_SIZE;
1434 camsrc_info("Thumbnail JPEG frame length = %d", thm_buffer->length);
1435 } else if(p->format.pix_format == CAMERASRC_PIX_RGGB8) {
1436 /* JPEG + JPEG thumbnail */
1437 thm_buffer->start = p->buffer[i].start + CAMERASRC_JPG_STILL_THUMBNAIL_OFFSET;
1438 thm_buffer->length = _camerasrc_get_thumbnail_JPG_length(p);
1439 if (buffer->length == 0) {
1440 return CAMERASRC_ERR_INVALID_PARAMETER;
1442 camsrc_info("Thumbnail JPEG frame length = %d", thm_buffer->length);
1444 camsrc_error("Unknown image format... ");
1445 #if USE_NOT_SUPPORT_ERR
1446 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1448 return CAMERASRC_SUCCESS;
1454 case CAMERASRC_IO_METHOD_READ:
1456 camsrc_error("Device not support that io-method");
1457 #if USE_NOT_SUPPORT_ERR
1458 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1460 return CAMERASRC_SUCCESS;
1465 camsrc_error("Invalid state transition");
1466 return CAMERASRC_ERR_INVALID_STATE;
1469 return CAMERASRC_SUCCESS;
1472 static int _camerasrc_dump_format(camsrc_handle_t handle);
1474 /**** M A I N O P E R A T I O N ****/
1475 int camerasrc_create(camsrc_handle_t *phandle)
1477 camerasrc_handle_t *p = NULL;
1478 int err = CAMERASRC_ERR_UNKNOWN;
1479 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1481 camsrc_info("enter");
1483 if (phandle == NULL) {
1484 camsrc_error("handle is null");
1485 return CAMERASRC_ERR_NULL_POINTER;
1488 p = (camerasrc_handle_t *)malloc(sizeof(camerasrc_handle_t));
1490 camsrc_error("malloc fail");
1491 return CAMERASRC_ERR_ALLOCATION;
1494 memset(p, '\0', sizeof(camerasrc_handle_t));
1496 /* STATE TO MEANINGFUL STATE */
1497 p->cur_state = CAMERASRC_STATE_NONE;
1498 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_CREATED);
1499 CAMERASRC_SET_PHASE(p, CAMERASRC_PHASE_NON_RUNNING);
1500 camsrc_info("Transit to non-running phase");
1502 /* INIT VARIABLES */
1503 err = _camerasrc_initialize_handle(p);
1504 if(err != CAMERASRC_SUCCESS) {
1505 camsrc_error("Invalid handle");
1506 return CAMERASRC_ERR_INVALID_HANDLE;
1509 err = pthread_mutex_init(&(p->mutex), NULL);
1511 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1512 camsrc_info("Mutex creating status : %s", err_msg);
1515 err = pthread_mutex_init(&(p->af_mutex), NULL);
1517 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1518 camsrc_info("AF Mutex creating status : %s", err_msg);
1521 err = pthread_cond_init(&(p->af_wait_cond), NULL);
1523 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1524 camsrc_info("AF Condition creating status : %s", err_msg);
1527 camsrc_info("Thread creation start..");
1528 err = pthread_create(&p->focusing_thread, NULL, (void*)_camerasrc_run_autofocusing, p);
1530 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1531 camsrc_info("AF Thread creating status : %s", err_msg);
1534 camsrc_info("Thread creation end..");
1536 *phandle = (camsrc_handle_t)p;
1537 err = CAMERASRC_SUCCESS;
1542 int camerasrc_destroy(camsrc_handle_t handle)
1544 camerasrc_handle_t* p = NULL;
1545 int err = CAMERASRC_ERR_UNKNOWN;
1546 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1548 camsrc_info("enter");
1550 if(handle == NULL) {
1551 camsrc_error("handle is null");
1552 return CAMERASRC_ERR_NULL_POINTER;
1555 p = CAMERASRC_HANDLE(handle);
1557 if(CAMERASRC_STATE(p) != CAMERASRC_STATE_UNREALIZED) {
1558 camsrc_warning("Invalid state transition");
1561 /* Remove AF thread */
1562 _camerasrc_destroy_autofocusing(p);
1564 camsrc_info("Thread join wait start..");
1565 err = pthread_join(p->focusing_thread, NULL);
1567 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1568 camsrc_info("AF Thread join status : %s", err_msg);
1571 camsrc_info("Thread join wait end..");
1573 err = pthread_cond_destroy(&p->af_wait_cond);
1575 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1576 camsrc_info("AF Condition destroying error : %s", err_msg);
1579 err = pthread_mutex_destroy(&(p->af_mutex));
1581 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1582 camsrc_info("AF Mutex destroying error : %s", err_msg);
1585 err = pthread_mutex_destroy(&(p->mutex));
1587 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1588 camsrc_info("Mutex destroying error : %s", err_msg);
1593 err = CAMERASRC_SUCCESS;
1598 int camerasrc_close_device(camsrc_handle_t handle)
1600 camerasrc_handle_t* p = NULL;
1601 int err = CAMERASRC_ERR_UNKNOWN;
1603 camsrc_info("enter");
1605 if(handle == NULL) {
1606 camsrc_error("handle is null");
1607 return CAMERASRC_ERR_NULL_POINTER;
1610 p = CAMERASRC_HANDLE(handle);
1612 p->is_async_open = 0;
1614 #if defined(USE_OPEN_CHK)
1615 if(!CAMERASRC_IS_DEV_CLOSED(p)) {
1616 err = _camerasrc_seamless_delete_onaccess(CAMERASRC_OPENED_CHK_FILENAME, p);
1617 if(err != CAMERASRC_SUCCESS) {
1618 return CAMERASRC_ERR_INTERNAL;
1620 p->dev_fd = CAMERASRC_DEV_FD_EMERGENCY_CLOSED;
1623 if(!CAMERASRC_IS_DEV_CLOSED(p)) {
1625 if( !(p->is_async_open) ) {
1629 p->dev_fd = CAMERASRC_DEV_FD_EMERGENCY_CLOSED;
1631 /* prepare "Kagemusha" frame data */
1633 memcpy(p->alter_frame.start, p->buffer[0].start, p->alter_frame.length);
1636 return CAMERASRC_SUCCESS;
1640 int camerasrc_get_state(camsrc_handle_t handle, camerasrc_state_t* state)
1642 camerasrc_handle_t* p = NULL;
1644 if(handle == NULL) {
1645 camsrc_error("handle is null");
1646 return CAMERASRC_ERR_NULL_POINTER;
1649 p = CAMERASRC_HANDLE(handle);
1651 *state = CAMERASRC_STATE(p);
1652 return CAMERASRC_SUCCESS;
1656 int camerasrc_realize(camsrc_handle_t handle)
1658 camerasrc_handle_t* p = NULL;
1659 int ret = CAMERASRC_SUCCESS;
1661 camerasrc_sync_param_t param = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX};
1664 camsrc_info("enter");
1666 if(handle == NULL) {
1667 camsrc_error("handle is null");
1668 return CAMERASRC_ERR_NULL_POINTER;
1671 p = CAMERASRC_HANDLE(handle);
1673 /* STATE OR PHASE CHECKING */
1674 if(CAMERASRC_STATE(p) == CAMERASRC_STATE_REALIZED) {
1675 return CAMERASRC_SUCCESS;
1677 if(CAMERASRC_STATE(p) != CAMERASRC_STATE_CREATED &&
1678 CAMERASRC_STATE(p) != CAMERASRC_STATE_UNREALIZED) {
1679 camsrc_warning("Invalid state transition");
1684 /* CREATE SEMAPHORE */
1685 camsrc_create_sync(¶m);
1687 /* O P E N D E V I C E */
1688 #if defined(USE_OPEN_CHK)
1689 ret = _camerasrc_chk_opened(CAMERASRC_OPENED_CHK_FILENAME);
1690 if (ret == CAMERASRC_SUCCESS) {
1691 ret = _camerasrc_seamless_record_onaccess_open(CAMERASRC_OPENED_CHK_FILENAME, p);
1692 if (ret != CAMERASRC_SUCCESS) {
1693 camsrc_error("_camerasrc_seamless_record_onaccess_open failed %x", ret);
1696 #else /* USE_OPEN_CHK */
1697 if (!CAMERASRC_IS_DEV_CLOSED(p)) {
1698 ret = __camerasrc_open_device(p);
1699 if (ret != CAMERASRC_SUCCESS) {
1700 camsrc_error("camera open failed %x", ret);
1702 p->is_async_open = 0;
1705 p->is_async_open = 1;
1707 #endif /* USE_OPEN_CHK */
1711 if (ret == CAMERASRC_SUCCESS) {
1712 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_REALIZED);
1719 int camerasrc_unrealize(camsrc_handle_t handle)
1721 camerasrc_handle_t* p = NULL;
1722 int err = CAMERASRC_ERR_UNKNOWN;
1724 camsrc_info("enter");
1726 if(handle == NULL) {
1727 camsrc_error("handle is null");
1728 return CAMERASRC_ERR_NULL_POINTER;
1731 p = CAMERASRC_HANDLE(handle);
1733 if(CAMERASRC_STATE(p) == CAMERASRC_STATE_UNREALIZED ||
1734 CAMERASRC_STATE(p) == CAMERASRC_STATE_DESTROYED) {
1735 return CAMERASRC_SUCCESS;
1737 if(CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
1738 camsrc_warning("Invalid state transition");
1741 #if defined(USE_OPEN_CHK)
1742 if(!CAMERASRC_IS_DEV_CLOSED(p)) {
1743 err = _camerasrc_seamless_delete_onaccess(CAMERASRC_OPENED_CHK_FILENAME, p);
1744 if(err != CAMERASRC_SUCCESS) {
1745 return CAMERASRC_ERR_INTERNAL;
1748 #else /* USE_OPEN_CHK */
1749 if(!CAMERASRC_IS_DEV_CLOSED(p)) {
1751 if( !(p->is_async_open) ) {
1755 #endif /* USE_OPEN_CHK */
1760 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_UNREALIZED);
1761 CAMERASRC_SET_PHASE(p, CAMERASRC_PHASE_NON_RUNNING);
1762 camsrc_info("Transit to non-running phase");
1763 err = CAMERASRC_SUCCESS;
1768 int camerasrc_start(camsrc_handle_t handle)
1770 camerasrc_handle_t* p = NULL;
1771 int err = CAMERASRC_ERR_UNKNOWN;
1773 camsrc_info("enter");
1775 if(handle == NULL) {
1776 camsrc_error("handle is null");
1777 return CAMERASRC_ERR_NULL_POINTER;
1780 p = CAMERASRC_HANDLE(handle);
1782 /* STATE OR PHASE CHECKING */
1783 if(CAMERASRC_STATE(p) == CAMERASRC_STATE_READY) {
1784 return CAMERASRC_SUCCESS;
1786 if(CAMERASRC_STATE(p) != CAMERASRC_STATE_REALIZED) {
1787 camsrc_warning("Invalid state transition");
1790 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_READY);
1791 CAMERASRC_SET_PHASE(p, CAMERASRC_PHASE_RUNNING);
1793 camsrc_info("Transit to running phase");
1794 err = CAMERASRC_SUCCESS;
1799 int camerasrc_present_usr_buffer(camsrc_handle_t handle, camerasrc_usr_buf_t *present_buf, camerasrc_io_method_t io_method)
1801 camerasrc_handle_t *p = NULL;
1802 int err = CAMERASRC_ERR_UNKNOWN;
1804 camsrc_info("enter");
1806 if (handle == NULL) {
1807 camsrc_error("handle is null");
1808 return CAMERASRC_ERR_NULL_POINTER;
1811 p = CAMERASRC_HANDLE(handle);
1813 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
1814 camsrc_warning("Invalid state transition");
1818 case CAMERASRC_IO_METHOD_MMAP:
1819 camsrc_info("MMAP mode");
1820 if (present_buf != NULL) {
1821 camsrc_error("present_buf should be NULL in MMAP Mode");
1822 #if USE_NOT_SUPPORT_ERR
1823 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1825 return CAMERASRC_SUCCESS;
1828 p->io_method = CAMERASRC_IO_METHOD_MMAP;
1830 case CAMERASRC_IO_METHOD_USRPTR:
1831 camsrc_info("USRPTR mode");
1832 if (present_buf == NULL) {
1833 camsrc_error("present_buf should NOT be NULL in USRPTR Mode");
1834 return CAMERASRC_ERR_ALLOCATION;
1837 if (present_buf->num_buffer > CAMERASRC_USRPTR_MAX_BUFFER_NUM) {
1838 camsrc_warning("Use up tp MAX %d buffer only", CAMERASRC_USRPTR_MAX_BUFFER_NUM);
1839 present_buf->num_buffer = CAMERASRC_USRPTR_MAX_BUFFER_NUM;
1841 p->present_buf = present_buf;
1842 p->io_method = CAMERASRC_IO_METHOD_USRPTR;
1844 case CAMERASRC_IO_METHOD_READ:
1846 #if USE_NOT_SUPPORT_ERR
1847 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1849 return CAMERASRC_SUCCESS;
1854 err = CAMERASRC_SUCCESS;
1859 int camerasrc_get_num_buffer(camsrc_handle_t handle, unsigned int *num_buffer)
1861 camerasrc_handle_t *p = NULL;
1863 if (handle == NULL) {
1864 camsrc_error("handle is null");
1865 return CAMERASRC_ERR_NULL_POINTER;
1868 p = CAMERASRC_HANDLE(handle);
1870 camerasrc_state_t state = CAMERASRC_STATE_NONE;
1871 camerasrc_get_state(handle, &state);
1874 case CAMERASRC_STATE_NONE:
1875 case CAMERASRC_STATE_CREATED:
1876 case CAMERASRC_STATE_REALIZED:
1877 case CAMERASRC_STATE_READY:
1878 case CAMERASRC_STATE_UNREALIZED:
1879 case CAMERASRC_STATE_DESTROYED:
1880 camsrc_warning("Current buffer number not initialized.");
1883 case CAMERASRC_STATE_PREVIEW:
1884 case CAMERASRC_STATE_STILL:
1885 case CAMERASRC_STATE_VIDEO:
1886 case CAMERASRC_STATE_AF_IN_PROGRESS:
1887 *num_buffer = p->num_buffers;
1890 camsrc_error("Unknown state");
1892 return CAMERASRC_ERR_INVALID_STATE;
1895 return CAMERASRC_SUCCESS;
1899 int camerasrc_get_io_method(camsrc_handle_t handle, camerasrc_io_method_t* io_method)
1901 camerasrc_handle_t *p = NULL;
1903 camsrc_info("enter");
1905 if (handle == NULL) {
1906 camsrc_error("handle is null");
1907 return CAMERASRC_ERR_NULL_POINTER;
1910 p = CAMERASRC_HANDLE(handle);
1912 *io_method = p->io_method;
1914 return CAMERASRC_SUCCESS;
1918 int camerasrc_start_still_stream(camsrc_handle_t handle)
1920 camerasrc_handle_t* p = NULL;
1921 struct v4l2_streamparm vstreamparm;
1922 struct v4l2_format vformat;
1923 struct v4l2_requestbuffers vreq_bufs;
1924 enum v4l2_buf_type vtype;
1926 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1928 camsrc_info("enter");
1930 if (handle == NULL) {
1931 camsrc_error("handle is null");
1932 return CAMERASRC_ERR_NULL_POINTER;
1935 p = CAMERASRC_HANDLE(handle);
1937 if (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL) {
1938 return CAMERASRC_SUCCESS;
1941 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
1942 camsrc_warning("Invalid state transition");
1945 /* S T I L L M O D E S E T T I N G */
1947 * If driver can control thmbnl size, we do that here, if not support, it's OK
1948 * Driver should change jpeg compress ration before start stream
1951 vstreamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1952 __ta__( " Stillshot VIDIOC_G_PARM",
1953 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_G_PARM, &vstreamparm)) {
1954 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1955 camsrc_error("VIDIOC_G_PARAM failed : %s", err_msg);
1956 return CAMERASRC_ERR_IO_CONTROL;
1960 if (p->format.is_highquality_mode == 1) {
1961 camsrc_info("High quality frame will be captured");
1962 vstreamparm.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY;
1963 } else if(p->format.is_highquality_mode == 0) {
1964 camsrc_info("Normal quality frame will be captured");
1965 vstreamparm.parm.capture.capturemode = 0;
1967 camsrc_info("Quality not initialized, or incorrect value. set high quality...");
1968 vstreamparm.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY;
1971 vstreamparm.parm.capture.timeperframe.numerator = p->timeperframe.numerator;
1972 vstreamparm.parm.capture.timeperframe.denominator = p->timeperframe.denominator;
1973 camsrc_info("[FPS] timeperframe.numerator = %d", p->timeperframe.numerator);
1974 camsrc_info("[FPS] timeperframe.denominator = %d", p->timeperframe.denominator);
1975 camsrc_info("[QUA] vstreamparm.parm.capture.capturemode = %d", vstreamparm.parm.capture.capturemode);
1976 __ta__( " Stillshot VIDIOC_S_PARM",
1977 if(CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_PARM, &vstreamparm)) {
1978 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1979 camsrc_error("VIDIOC_S_PARAM failed : %s", err_msg);
1980 return CAMERASRC_ERR_IO_CONTROL;
1984 /* S T I L L F O R M A T S E T T I N G */
1986 _camerasrc_dump_format(p);
1987 vformat.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1988 switch (p->format.pix_format) {
1989 case CAMERASRC_PIX_YUV420P:
1990 camsrc_info("420P capture activated..");
1991 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
1993 case CAMERASRC_PIX_YUV422P:
1994 camsrc_info("422P capture activated..");
1995 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
1997 case CAMERASRC_PIX_SN12:
1998 case CAMERASRC_PIX_NV12:
1999 camsrc_info("NV12(SN12) capture activated..");
2000 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;
2002 case CAMERASRC_PIX_ST12:
2003 camsrc_info("NV12T capture activated..");
2004 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12T;
2006 case CAMERASRC_PIX_YUY2:
2007 camsrc_info("YUY2 capture activated..");
2008 vformat.fmt.pix.pixelformat = CAMERASRC_V4L2_PREVIEW_PIX_FMT_DEFAULT;
2010 /* Kessler capture path */
2011 case CAMERASRC_PIX_RGGB8:
2012 camsrc_info("JPEG+JPEG capture activated..");
2013 vformat.fmt.pix.pixelformat = CAMERASRC_V4L2_JPEG_CAPTURE_PIX_FMT_DEFAULT;
2015 case CAMERASRC_PIX_RGGB10:
2016 camsrc_info("JPEG+YUV capture activated..");
2017 vformat.fmt.pix.pixelformat = CAMERASRC_V4L2_JPG_YUV_CAPTURE_PIX_FMT_DEFAULT;
2020 camsrc_error("Not supported format!");
2024 camsrc_info("JPG unified size capture avtivated!");
2025 vformat.fmt.pix.width = p->format.img_size.dim.width; /*capture width*/
2026 vformat.fmt.pix.height = p->format.img_size.dim.height; /*capture height*/
2027 vformat.fmt.pix_mp.field = V4L2_FIELD_NONE;
2028 __ta__( " Stillshot VIDIOC_S_FMT",
2029 if(CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_FMT, &vformat)) {
2030 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2031 camsrc_error("VIDIOC_S_FMT failed : %s", err_msg);
2032 return CAMERASRC_ERR_IO_CONTROL;
2036 camsrc_info("Stillshot VIDIOC_S_FMT done");
2040 /* M E M O R Y M A P P I N G */
2041 switch (p->io_method) {
2042 case CAMERASRC_IO_METHOD_MMAP:
2043 camsrc_info("MMAP mode");
2045 if (vformat.fmt.pix.pixelformat == CAMERASRC_V4L2_JPEG_CAPTURE_PIX_FMT_DEFAULT ) {
2046 vreq_bufs.count = CAMERASRC_STILL_BUFFER_NUM;
2048 vreq_bufs.count = CAMERASRC_PREVIEW_BUFFER_NUM;
2050 vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2051 vreq_bufs.memory = V4L2_MEMORY_MMAP;
2053 camsrc_info("VIDIOC_REQBUFS count:%d, type:%d, memory:%d",
2054 vreq_bufs.count, vreq_bufs.type, vreq_bufs.memory);
2056 __ta__( " Stillshot VIDIOC_REQBUFS",
2057 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) {
2058 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2059 camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg);
2060 return CAMERASRC_ERR_IO_CONTROL;
2064 camsrc_info("Stillshot VIDIOC_REQBUFS done");
2065 camsrc_assert(vreq_bufs.count >= 1);
2067 p->num_buffers = vreq_bufs.count;
2068 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2071 camsrc_error("calloc() failed");
2072 return CAMERASRC_ERR_ALLOCATION;
2075 __ta__( " Stillshot VIDIOC_QUERYBUF,mmap",
2076 for (p->buffer_idx = 0 ; p->buffer_idx < vreq_bufs.count ; ++(p->buffer_idx)) {
2077 struct v4l2_buffer vbuf;
2080 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2081 vbuf.memory = V4L2_MEMORY_MMAP;
2082 vbuf.index = p->buffer_idx;
2083 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QUERYBUF, &vbuf)) {
2084 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2085 camsrc_error("VIDIOC_QUERYBUF failed : %s", err_msg);
2086 return CAMERASRC_ERR_IO_CONTROL;
2089 p->buffer[p->buffer_idx].length = vbuf.length;
2090 p->buffer[p->buffer_idx].start = mmap(NULL /* start anywhere */,
2092 PROT_READ | PROT_WRITE,
2094 p->dev_fd, vbuf.m.offset);
2095 if (MAP_FAILED == p->buffer[p->buffer_idx].start) {
2096 camsrc_error("mmap failed.");
2097 return CAMERASRC_ERR_ALLOCATION;
2100 camsrc_info("MMAP BUF: addr[%p] size[%d]",
2101 p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2105 camsrc_info("Stillshot VIDIOC_QUERYBUF and mmap done");
2108 case CAMERASRC_IO_METHOD_USRPTR:
2109 camsrc_info("USRPTR mode");
2111 vreq_bufs.count = p->present_buf->num_buffer;
2112 vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2113 vreq_bufs.memory = V4L2_MEMORY_USERPTR;
2114 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) {
2115 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2116 camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg);
2117 return CAMERASRC_ERR_IO_CONTROL;
2120 camsrc_assert(vreq_bufs.count >= 1);
2122 p->num_buffers = vreq_bufs.count;
2123 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2126 camsrc_error("calloc() failed");
2127 return CAMERASRC_ERR_ALLOCATION;
2130 if (!p->present_buf->present_buffer) {
2131 camsrc_error("No Usrptr buffer presented!");
2132 return CAMERASRC_ERR_ALLOCATION;
2135 for (p->buffer_idx = 0; p->buffer_idx < vreq_bufs.count; ++(p->buffer_idx)) {
2136 p->buffer[p->buffer_idx].length = p->present_buf->present_buffer[p->buffer_idx].length;
2137 p->buffer[p->buffer_idx].start = p->present_buf->present_buffer[p->buffer_idx].start;
2139 if (!p->buffer[p->buffer_idx].start) {
2140 camsrc_error("presented usrptr buffer is NULL");
2141 return CAMERASRC_ERR_ALLOCATION;
2144 camsrc_info("USERPTR BUF: addr[%p] size[%d]",
2145 p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2149 case CAMERASRC_IO_METHOD_READ:
2151 camsrc_error("Device not support that io-method");
2152 #if USE_NOT_SUPPORT_ERR
2153 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2155 return CAMERASRC_SUCCESS;
2160 /* calibrate rotation - kernel of c210 could not support V4L2_CID_PHYSICAL_ROTATION */
2161 if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) {
2162 p->format.rotation += 180;
2163 p->format.rotation = p->format.rotation % 360;
2164 camsrc_info("Calibrate rotate : secondary camera +180 degree");
2168 __ta__( " _CAMERASRC_CMD_ROTATION",
2169 CAMERASRC_SET_CMD(_CAMERASRC_CMD_ROTATION, &(p->format.rotation));
2173 __ta__( " _CAMERASRC_CMD_VFLIP",
2174 CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip));
2177 __ta__( " _CAMERASRC_CMD_HFLIP",
2178 CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip));
2181 /* set JPEG quality */
2182 if (p->format.pix_format == CAMERASRC_PIX_RGGB8) {
2183 int err = CAMERASRC_ERR_UNKNOWN;
2184 struct v4l2_control control;
2186 control.id = V4L2_CID_CAM_JPEG_QUALITY;
2187 control.value = p->format.quality;
2188 camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_CAM_JPEG_QUALITY -> %d", control.value);
2189 __ta__( " Stillshot V4L2_CID_CAM_JPEG_QUALITY",
2190 err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control);
2192 if (err != CAMERASRC_SUCCESS) {
2193 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2194 camsrc_error("V4L2_CID_CAMERA_CAPTURE failed : %s", err_msg);
2199 /* A C T U A L S T A R T S T R E A M */
2200 switch(p->io_method) {
2201 case CAMERASRC_IO_METHOD_MMAP:
2202 camsrc_info("MMAP mode");
2204 p->queued_buffer_count = 0;
2205 for (cnt = 0; cnt < p->num_buffers; cnt++) {
2206 struct v4l2_buffer lvbuf;
2209 lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2210 lvbuf.memory = V4L2_MEMORY_MMAP;
2212 __ta__( " Stillshot VIDIOC_QBUF",
2213 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) {
2214 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2215 camsrc_error("VIDIOC_QBUF failed : %s", err_msg);
2216 return CAMERASRC_ERR_IO_CONTROL;
2221 p->buffer[lvbuf.index].queued_status = CAMERASRC_BUFFER_QUEUED;
2222 p->queued_buffer_count++;
2226 camsrc_info("Stillshot VIDIOC_QBUF done");
2228 vtype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2229 __ta__( " Stillshot VIDIOC_STREAMON",
2230 if( CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMON, &vtype)) {
2231 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2232 camsrc_error("VIDIOC_STREAMON failed : %s", err_msg);
2233 return CAMERASRC_ERR_IO_CONTROL;
2236 camsrc_info("Stillshot VIDIOC_STREAMON done");
2239 case CAMERASRC_IO_METHOD_USRPTR:
2240 camsrc_info("USRPTR mode");
2241 for (cnt = 0; cnt < p->present_buf->num_buffer; cnt++) {
2242 struct v4l2_buffer lvbuf;
2245 lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2246 lvbuf.memory = V4L2_MEMORY_USERPTR;
2248 lvbuf.m.userptr = (unsigned long)p->buffer[cnt].start;
2249 lvbuf.length = p->buffer[cnt].length;
2251 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) {
2252 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2253 camsrc_error("VIDIOC_QBUF failed : %s", err_msg);
2254 return CAMERASRC_ERR_IO_CONTROL;
2258 camsrc_info("Stillshot VIDIOC_QBUF done");
2260 vtype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2261 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMON, &vtype)) {
2262 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2263 camsrc_error("VIDIOC_STREAMON failed : %s", err_msg);
2264 return CAMERASRC_ERR_IO_CONTROL;
2266 camsrc_info("Stillshot VIDIOC_STREAMON done");
2269 case CAMERASRC_IO_METHOD_READ:
2271 camsrc_error("Device not support that io-method");
2272 #if USE_NOT_SUPPORT_ERR
2273 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2275 return CAMERASRC_SUCCESS;
2280 /* C210 Legacy V4L2 API for capture */
2281 if (p->format.pix_format == CAMERASRC_PIX_RGGB8) {
2282 int err = CAMERASRC_ERR_UNKNOWN;
2283 struct v4l2_control control;
2285 control.id = V4L2_CID_CAMERA_CAPTURE;
2287 camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_CAMERA_CAPTURE -> 0");
2288 __ta__( " Stillshot V4L2_CID_CAMERA_CAPTURE",
2289 err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control);
2291 if (err != CAMERASRC_SUCCESS) {
2292 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2293 camsrc_error("V4L2_CID_CAMERA_CAPTURE failed : %s", err_msg);
2300 __ta__( " Stillshot skip_frame_func",
2301 if (_CAMERASRC_NEED_MISC_FUNCTION(p->cur_dev_id, CAMERASRC_OP_CAPTURE, p->format.colorspace, CAMERASRC_MISC_SKIP_FRAME)) {
2302 p->skip_frame_func = (camerasrc_skip_frame_func_t)_camerasrc_skip_frame;
2304 p->skip_frame_func = NULL;
2309 #if defined(USE_SKIP_FRAME_AT_RAW_FRAME)
2310 /*< If YUV capture, */
2311 if (!p->format.is_highquality_mode) {
2312 if (p->skip_frame_func != NULL) {
2313 p->skip_frame_func(p, 5000, 3);
2318 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_STILL);
2320 return CAMERASRC_SUCCESS;
2324 int camerasrc_start_preview_stream(camsrc_handle_t handle)
2326 camerasrc_handle_t* p = NULL;
2327 int err = CAMERASRC_ERR_UNKNOWN;
2329 struct v4l2_streamparm vstreamparm;
2330 struct v4l2_format vformat;
2331 struct v4l2_requestbuffers vreq_bufs;
2332 struct v4l2_control control;
2333 enum v4l2_buf_type vtype;
2335 int preview_width = 0;
2336 int preview_height = 0;
2338 int capture_width = 0;
2339 int capture_height = 0;
2341 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
2343 camsrc_info("enter");
2345 if (handle == NULL) {
2346 camsrc_error("handle is null");
2347 return CAMERASRC_ERR_NULL_POINTER;
2350 p = CAMERASRC_HANDLE(handle);
2352 /* STATE OR PHASE CHECKING */
2353 if(CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW) {
2354 return CAMERASRC_SUCCESS;
2356 if(CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
2357 camsrc_warning("Invalid state transition");
2360 /* P R E V I E W M O D E S E T T I N G */
2362 vstreamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2363 __ta__( " VIDIOC_G_PARM",
2364 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_G_PARM, &vstreamparm)) {
2365 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2366 camsrc_error("VIDIOC_G_PARAM failed : %s", err_msg);
2367 return CAMERASRC_ERR_IO_CONTROL;
2371 vstreamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2373 if ((vstreamparm.parm.capture.timeperframe.numerator != p->timeperframe.numerator) ||
2374 (vstreamparm.parm.capture.timeperframe.denominator != p->timeperframe.denominator) ||
2375 ((p->format.is_highquality_mode == 1) &&(vstreamparm.parm.capture.capturemode != V4L2_MODE_HIGHQUALITY)) ||
2376 ((p->format.is_highquality_mode == 0) &&(vstreamparm.parm.capture.capturemode != 0))) {
2377 if (p->format.is_highquality_mode == 1) {
2378 camsrc_info("High quality frame will be captured");
2379 vstreamparm.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY;
2380 } else if (p->format.is_highquality_mode == 0) {
2381 camsrc_info("Normal quality frame will be captured");
2382 vstreamparm.parm.capture.capturemode = 0;
2384 camsrc_info("Quality not initialized, or incorrect value. set normal quality...");
2385 vstreamparm.parm.capture.capturemode = 0;
2388 vstreamparm.parm.capture.timeperframe.numerator = p->timeperframe.numerator;
2389 vstreamparm.parm.capture.timeperframe.denominator = p->timeperframe.denominator;
2391 camsrc_info("[FPS] timeperframe.numerator = %d", p->timeperframe.numerator);
2392 camsrc_info("[FPS] timeperframe.denominator = %d", p->timeperframe.denominator);
2393 camsrc_info("[QUA] vstreamparm.parm.capture.capturemode = %d", vstreamparm.parm.capture.capturemode);
2395 __ta__( " VIDIOC_S_PARM",
2396 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_PARM, &vstreamparm)) {
2397 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2398 camsrc_error("VIDIOC_S_PARAM failed : %s", err_msg);
2399 return CAMERASRC_ERR_IO_CONTROL;
2404 /* P R E V I E W F O R M A T S E T T I N G */
2405 if (!(p->format.pix_format == CAMERASRC_PIX_YUV422P || p->format.pix_format == CAMERASRC_PIX_YUV420P ||
2406 p->format.pix_format == CAMERASRC_PIX_SN12 || p->format.pix_format == CAMERASRC_PIX_ST12 ||
2407 p->format.pix_format == CAMERASRC_PIX_NV12 || p->format.pix_format == CAMERASRC_PIX_YUY2 ||
2408 p->format.pix_format == CAMERASRC_PIX_UYVY || p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) ) {
2409 camsrc_error("Invalid output format.");
2410 return CAMERASRC_ERR_INVALID_FORMAT;
2413 if (p->format.colorspace != CAMERASRC_COL_RAW) {
2414 camsrc_error("Invalid store method.");
2415 return CAMERASRC_ERR_INVALID_PARAMETER;
2418 err = _camerasrc_dump_format(handle);
2419 if (err != CAMERASRC_SUCCESS) {
2420 camsrc_error("Format dump error");
2424 preview_width = p->format.img_size.dim.width;
2425 preview_height = p->format.img_size.dim.height;
2428 vformat.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2429 vformat.fmt.pix.width = preview_width;
2430 vformat.fmt.pix.height = preview_height;
2431 vformat.fmt.pix.field = V4L2_FIELD_NONE;
2433 switch (p->format.pix_format) {
2434 case CAMERASRC_PIX_YUV422P:
2435 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
2436 vformat.fmt.pix.bytesperline = preview_width << 1;
2437 vformat.fmt.pix.sizeimage = (preview_width * preview_height) << 1;
2439 case CAMERASRC_PIX_YUY2:
2440 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
2441 vformat.fmt.pix.bytesperline = preview_width << 1;
2442 vformat.fmt.pix.sizeimage = (preview_width * preview_height) << 1;
2444 case CAMERASRC_PIX_UYVY:
2445 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
2446 vformat.fmt.pix.bytesperline = preview_width << 1;
2447 vformat.fmt.pix.sizeimage = (preview_width * preview_height) << 1;
2449 case CAMERASRC_PIX_YUV420P:
2450 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
2451 vformat.fmt.pix.bytesperline = (preview_width * 3) >> 1;
2452 vformat.fmt.pix.sizeimage = (preview_width * preview_height * 3) >> 1;
2454 case CAMERASRC_PIX_NV12:
2455 case CAMERASRC_PIX_SN12:
2456 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12;
2457 vformat.fmt.pix.bytesperline = (preview_width * 3) >> 1;
2458 vformat.fmt.pix.sizeimage = (preview_width * preview_height * 3) >> 1;
2460 case CAMERASRC_PIX_ST12:
2461 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12T;
2462 vformat.fmt.pix.bytesperline = (preview_width * 3) >> 1;
2463 vformat.fmt.pix.sizeimage = (preview_width * preview_height * 3) >> 1;
2465 case CAMERASRC_PIX_INTERLEAVED: /* JPEG + YUYV */
2466 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_INTERLEAVED;
2467 vformat.fmt.pix.priv = V4L2_PIX_FMT_MODE_PREVIEW;
2468 vformat.fmt.pix.field = IS_MODE_PREVIEW_STILL;
2469 /* TODO: Set JPEG size */
2473 camsrc_error("Invalid output format.");
2477 camsrc_info("===========================================");
2478 camsrc_info("| Request output width = %d", vformat.fmt.pix.width);
2479 camsrc_info("| Request output height = %d", vformat.fmt.pix.height);
2480 camsrc_info("| Request output field = %d", vformat.fmt.pix.field);
2481 camsrc_info("| Request output pixel format = %d", vformat.fmt.pix.pixelformat);
2482 camsrc_info("| Request output bytesperline = %d", vformat.fmt.pix.bytesperline);
2483 camsrc_info("| Request output image size = %d", vformat.fmt.pix.sizeimage);
2484 camsrc_info("===========================================");
2486 __ta__( " VIDIOC_S_FMT",
2487 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_S_FMT, &vformat)) {
2488 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2489 camsrc_error("VIDIOC_S_FMT failed : %s", err_msg);
2490 return CAMERASRC_ERR_IO_CONTROL;
2494 control.id = V4L2_CID_CACHEABLE;
2495 if (p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) {
2500 camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_CACHEABLE -> %d", control.value);
2501 __ta__( " VIDIOC_S_CTRL: V4L2_CID_CACHEABLE",
2502 err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control);
2504 if (err != CAMERASRC_SUCCESS) {
2505 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2506 camsrc_error("V4L2_CID_CACHEABLE failed : %s", err_msg);
2510 control.id = V4L2_CID_EMBEDDEDDATA_ENABLE;
2511 if (p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) {
2516 camsrc_info("[VIDIOC_S_CTRL] V4L2_CID_EMBEDDEDDATA_ENABLE -> %d", control.value);
2517 __ta__( " VIDIOC_S_CTRL: V4L2_CID_EMBEDDEDDATA_ENABLE",
2518 err = _camerasrc_ioctl(p, VIDIOC_S_CTRL, &control);
2520 if (err != CAMERASRC_SUCCESS) {
2521 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2522 camsrc_error("V4L2_CID_EMBEDDEDDATA_ENABLE failed : %s", err_msg);
2526 /* Prepare alter format frame */
2527 __ta__( " camerasrc_query_img_buf_size",
2528 camerasrc_query_img_buf_size(p, &(p->alter_frame.length), NULL);
2530 p->alter_frame.start = (unsigned char*) malloc(p->alter_frame.length);
2531 if (p->alter_frame.start == NULL) {
2532 camsrc_error("alter_frame alloc failed.");
2533 return CAMERASRC_ERR_ALLOCATION;
2536 /* M E M O R Y M A P P I N G */
2538 switch(p->io_method) {
2539 case CAMERASRC_IO_METHOD_MMAP:
2540 camsrc_info("MMAP mode");
2541 vreq_bufs.count = CAMERASRC_PREVIEW_BUFFER_NUM;
2542 vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2543 vreq_bufs.memory = V4L2_MEMORY_MMAP;
2544 camsrc_info("MMAP mode (bufs.count:%d)", vreq_bufs.count);
2545 __ta__( " VIDIOC_REQBUFS",
2546 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) {
2547 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2548 camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg);
2549 return CAMERASRC_ERR_IO_CONTROL;
2552 camsrc_assert(vreq_bufs.count >= 1);
2554 p->num_buffers = vreq_bufs.count;
2555 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2557 camsrc_error("calloc() failed");
2558 return CAMERASRC_ERR_ALLOCATION;
2561 for (p->buffer_idx = 0; p->buffer_idx < vreq_bufs.count; ++(p->buffer_idx)) {
2562 struct v4l2_buffer vbuf;
2564 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2565 vbuf.memory = V4L2_MEMORY_MMAP;
2566 vbuf.index = p->buffer_idx;
2568 __ta__( " VIDIOC_QUERYBUF",
2569 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QUERYBUF, &vbuf)) {
2570 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2571 camsrc_error("VIDIOC_QUERYBUF failed : %s", err_msg);
2572 return CAMERASRC_ERR_IO_CONTROL;
2577 p->buffer[p->buffer_idx].length = vbuf.length;
2578 p->buffer[p->buffer_idx].start = mmap(NULL /* start anywhere */,
2580 PROT_READ | PROT_WRITE,
2582 p->dev_fd, vbuf.m.offset);
2584 if (MAP_FAILED == p->buffer[p->buffer_idx].start) {
2585 camsrc_error("mmap failed.");
2586 return CAMERASRC_ERR_ALLOCATION;
2589 GST_INFO("buffer index %d, addr %x, length %d",
2590 p->buffer_idx, p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2592 switch (p->format.pix_format) {
2593 case CAMERASRC_PIX_YUV422P:
2594 case CAMERASRC_PIX_YUY2:
2595 case CAMERASRC_PIX_UYVY:
2596 if (p->buffer[p->buffer_idx].length < p->format.img_size.dim.width * p->format.img_size.dim.height * 2) {
2597 camsrc_error("format[%d] device insufficient memory.", p->format.pix_format);
2600 case CAMERASRC_PIX_YUV420P:
2601 case CAMERASRC_PIX_NV12:
2602 if (p->buffer[p->buffer_idx].length < (p->format.img_size.dim.width * p->format.img_size.dim.height * 3 / 2)) {
2603 camsrc_error("format[%d] device insufficient memory.", p->format.pix_format);
2606 case CAMERASRC_PIX_SN12:
2607 case CAMERASRC_PIX_ST12:
2608 if (p->buffer[p->buffer_idx].length < (p->format.img_size.dim.width * p->format.img_size.dim.height)) {
2609 camsrc_error("SN12,ST12: device insufficient memory.");
2612 case CAMERASRC_PIX_INTERLEAVED:
2613 if (p->buffer[p->buffer_idx].length < (p->format.img_size.dim.width * p->format.img_size.dim.height)) {
2614 camsrc_error("INTERLEAVED: device insufficient memory.");
2618 camsrc_error("Not supported format[%d]", p->format.pix_format);
2622 camsrc_info("MMAP BUF: addr[%p] size[%d]",
2623 p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2626 case CAMERASRC_IO_METHOD_USRPTR:
2627 camsrc_info("USRPTR mode");
2629 vreq_bufs.count = p->present_buf->num_buffer;
2630 vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2631 vreq_bufs.memory = V4L2_MEMORY_USERPTR;
2632 __ta__( " VIDIOC_REQBUFS",
2633 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) {
2634 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2635 camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg);
2636 return CAMERASRC_ERR_IO_CONTROL;
2639 camsrc_assert(vreq_bufs.count >= 1);
2641 p->num_buffers = vreq_bufs.count;
2642 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2645 camsrc_error("calloc() failed");
2646 return CAMERASRC_ERR_ALLOCATION;
2649 if(!p->present_buf->present_buffer) {
2650 camsrc_error("No Usrptr buffer presented!");
2651 return CAMERASRC_ERR_ALLOCATION;
2654 for (p->buffer_idx = 0; p->buffer_idx < vreq_bufs.count; ++(p->buffer_idx)) {
2655 p->buffer[p->buffer_idx].length = p->present_buf->present_buffer[p->buffer_idx].length;
2656 p->buffer[p->buffer_idx].start = p->present_buf->present_buffer[p->buffer_idx].start;
2658 if (!p->buffer[p->buffer_idx].start) {
2659 camsrc_error("presented usrptr buffer is NULL");
2660 return CAMERASRC_ERR_ALLOCATION;
2663 camsrc_info("USERPTR BUF: addr[%p] size[%d]",
2664 p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2667 case CAMERASRC_IO_METHOD_READ:
2669 camsrc_error("Device not support that io-method");
2670 #if USE_NOT_SUPPORT_ERR
2671 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2673 return CAMERASRC_SUCCESS;
2678 /* A C T U A L S T A R T S T R E A M */
2679 switch(p->io_method) {
2680 case CAMERASRC_IO_METHOD_MMAP:
2681 camsrc_info("MMAP mode");
2683 p->queued_buffer_count = 0;
2684 for (cnt = 0; cnt < p->num_buffers; cnt++) {
2685 struct v4l2_buffer lvbuf;
2688 lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2689 lvbuf.memory = V4L2_MEMORY_MMAP;
2691 __ta__( " VIDIOC_QBUF",
2692 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) {
2693 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2694 camsrc_error("VIDIOC_QBUF failed : %s", err_msg);
2695 return CAMERASRC_ERR_IO_CONTROL;
2700 p->buffer[lvbuf.index].queued_status = CAMERASRC_BUFFER_QUEUED;
2701 p->queued_buffer_count++;
2705 case CAMERASRC_IO_METHOD_USRPTR:
2706 camsrc_info("USRPTR mode");
2708 for (cnt = 0; cnt < p->present_buf->num_buffer; cnt++) {
2709 struct v4l2_buffer lvbuf;
2712 lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2713 lvbuf.memory = V4L2_MEMORY_USERPTR;
2715 lvbuf.m.userptr = (unsigned long)p->buffer[cnt].start;
2716 lvbuf.length = p->buffer[cnt].length;
2717 __ta__( " VIDIOC_QBUF",
2718 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_QBUF, &lvbuf)) {
2719 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2720 camsrc_error("VIDIOC_QBUF failed : %s", err_msg);
2721 return CAMERASRC_ERR_IO_CONTROL;
2725 camsrc_info("QBUF Address [%d] %p", lvbuf.index, (void*)lvbuf.m.userptr);
2727 memcpy(&(p->queued_buf_list[cnt]), &lvbuf, sizeof(struct v4l2_buffer));
2730 case CAMERASRC_IO_METHOD_READ:
2732 camsrc_error("Device not support that io-method");
2733 #if USE_NOT_SUPPORT_ERR
2734 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2736 return CAMERASRC_SUCCESS;
2741 /* calibrate rotation - kernel of c210 could not support V4L2_CID_PHYSICAL_ROTATION */
2742 if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY) {
2743 p->format.rotation += 180;
2744 p->format.rotation = p->format.rotation % 360;
2745 camsrc_info("Calibrate rotate : secondary camera +180 degree");
2749 __ta__( " _CAMERASRC_CMD_ROTATION",
2750 CAMERASRC_SET_CMD(_CAMERASRC_CMD_ROTATION, &(p->format.rotation));
2753 /* Sensor mode Set */
2754 __ta__( " _CAMERASRC_CMD_SENSOR_MODE",
2755 CAMERASRC_SET_CMD(_CAMERASRC_CMD_SENSOR_MODE, &(p->sensor_mode));
2759 __ta__( " _CAMERASRC_CMD_VFLIP",
2760 CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip));
2762 __ta__( " _CAMERASRC_CMD_HFLIP",
2763 CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip));
2766 vtype = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2767 __ta__( " VIDIOC_STREAMON",
2768 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMON, &vtype)) {
2769 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2770 camsrc_error("VIDIOC_STREAMON failed : %s", err_msg);
2771 return CAMERASRC_ERR_IO_CONTROL;
2775 /* For noti that it is first frame DQ */
2779 if (_CAMERASRC_NEED_MISC_FUNCTION(p->cur_dev_id, CAMERASRC_OP_PREVIEW, p->format.colorspace, CAMERASRC_MISC_SKIP_FRAME)) {
2780 p->skip_frame_func = (camerasrc_skip_frame_func_t)_camerasrc_skip_frame;
2782 p->skip_frame_func = NULL;
2786 #if defined(USE_SKIP_FRAME_AT_RAW_FRAME)
2787 if(p->skip_frame_func != NULL)
2788 p->skip_frame_func(p, 5000, 3);
2791 for (cnt = 0; cnt < p->num_buffers; cnt++) {
2792 camsrc_info("MMAP/USRPTR BUF: addr[%p] size[%d]", p->buffer[cnt].start, p->buffer[cnt].length);
2795 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW);
2797 return CAMERASRC_SUCCESS;
2801 int camerasrc_query_img_buf_size(camsrc_handle_t handle, unsigned int* main_img_size, unsigned int* thm_img_size)
2803 camerasrc_handle_t* p = NULL;
2805 camsrc_info("enter");
2807 if (handle == NULL) {
2808 camsrc_error("handle is null");
2809 return CAMERASRC_ERR_NULL_POINTER;
2812 p = CAMERASRC_HANDLE(handle);
2814 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL &&
2815 CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW &&
2816 CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO) {
2817 camsrc_warning("Invalid state transition");
2820 camsrc_info("Start to set format");
2822 if (p->format.colorspace == CAMERASRC_COL_RAW &&
2823 (p->format.pix_format == CAMERASRC_PIX_YUV422P ||
2824 p->format.pix_format == CAMERASRC_PIX_YUY2 ||
2825 p->format.pix_format == CAMERASRC_PIX_UYVY ||
2826 p->format.pix_format == CAMERASRC_PIX_INTERLEAVED)) {
2827 *main_img_size = p->format.img_size.dim.width * p->format.img_size.dim.height * 2;
2828 if (thm_img_size != NULL) {
2831 camsrc_info("422 RAW!! WIDTH = %d, HEIGHT=%d, SIZE = %d",
2832 p->format.img_size.dim.width, p->format.img_size.dim.height, *main_img_size);
2833 } else if (p->format.colorspace == CAMERASRC_COL_RAW &&
2834 (p->format.pix_format == CAMERASRC_PIX_YUV420P ||
2835 p->format.pix_format == CAMERASRC_PIX_SN12 ||
2836 p->format.pix_format == CAMERASRC_PIX_ST12 ||
2837 p->format.pix_format == CAMERASRC_PIX_NV12)) {
2838 /*Kessler preview path*/
2839 *main_img_size = p->format.img_size.dim.width * p->format.img_size.dim.height * 3 / 2;
2840 if (thm_img_size != NULL) {
2843 camsrc_info("420 RAW!! WIDTH = %d, HEIGHT=%d, SIZE = %d",
2844 p->format.img_size.dim.width, p->format.img_size.dim.height, *main_img_size);
2845 } else if (p->format.colorspace == CAMERASRC_COL_JPEG) {
2846 if (p->format.pix_format == CAMERASRC_PIX_RGGB10) {
2847 camsrc_info("JPG + YUV Mode enabled.");
2848 *main_img_size = CAMERASRC_JPG_STILL_H_SYNC * CAMERASRC_JPG_STILL_V_SYNC;
2849 if (thm_img_size != NULL) {
2850 *thm_img_size = 320 * 240 * 2;
2852 } else if (p->format.pix_format == CAMERASRC_PIX_RGGB8) {
2853 /*Kessler capture path*/
2854 camsrc_info("JPG + JPG Mode enabled.");
2855 *main_img_size = CAMERASRC_JPG_STILL_H_SYNC * CAMERASRC_JPG_STILL_V_SYNC;
2856 if (thm_img_size != NULL) {
2857 *thm_img_size = CAMERASRC_JPG_STILL_H_SYNC * CAMERASRC_JPG_STILL_V_SYNC - CAMERASRC_JPG_STILL_THUMBNAIL_OFFSET;
2860 camsrc_error("Unknown image format...");
2861 #if USE_NOT_SUPPORT_ERR
2862 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2864 return CAMERASRC_SUCCESS;
2868 camsrc_info("JPEG!! WIDTH = %d, HEIGHT=%d, SIZE = %d",
2869 p->format.img_size.dim.width, p->format.img_size.dim.height, *main_img_size);
2871 camsrc_error("Unknown format set. can't go any more");
2875 camsrc_info("leave..");
2877 return CAMERASRC_SUCCESS;
2881 int camerasrc_stop_stream(camsrc_handle_t handle)
2883 camerasrc_handle_t *p = NULL;
2884 enum v4l2_buf_type type;
2887 camerasrc_auto_focus_status_t af_status = 0;
2888 struct v4l2_requestbuffers vreq_bufs;
2889 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
2891 camsrc_info("enter");
2893 if(handle == NULL) {
2894 camsrc_error("handle is null");
2895 return CAMERASRC_ERR_NULL_POINTER;
2898 p = CAMERASRC_HANDLE(handle);
2900 if (CAMERASRC_STATE(p) == CAMERASRC_STATE_READY) {
2901 return CAMERASRC_SUCCESS;
2904 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL &&
2905 CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW &&
2906 CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO &&
2907 CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) {
2908 camsrc_warning("Stop stream called [STREAM-NOT-STARTED STATE]");
2911 camsrc_info("Change to READY state first for preventing to check Q/DQ after stop");
2912 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_READY);
2915 p->timeperframe.denominator = 0;
2916 p->timeperframe.numerator = 0;
2920 #ifdef STOP_AF_BEFORE_STREAMOFF
2921 _camerasrc_stop_autofocusing(p);
2923 /* Wait for AF stop done */
2925 __ta__( " camerasrc_stop_stream:Wait for AF release",
2926 while (try_count++ < CAMERASRC_AF_TOTALTIME/CAMERASRC_AF_STOP_INTERVAL) {
2927 usleep( CAMERASRC_AF_STOP_INTERVAL );
2928 camerasrc_get_autofocusing_status(p, &af_status);
2929 if (af_status == CAMERASRC_AUTO_FOCUS_STATUS_RELEASED) {
2930 camsrc_info("AF Stop done");
2935 #endif /* STOP_AF_BEFORE_STREAMOFF */
2937 /* S T O P S T R E A M */
2938 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2939 __ta__( " camerasrc_stop_stream:VIDIOC_STREAMOFF",
2940 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_STREAMOFF, &type)) {
2941 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2942 camsrc_error("VIDIOC_STREAMOFF failed : %s", err_msg);
2943 return CAMERASRC_ERR_IO_CONTROL;
2947 /* M E M O R Y U N M A P P I N G & F R E E */
2948 switch(p->io_method) {
2949 case CAMERASRC_IO_METHOD_MMAP:
2950 camsrc_info("Init io method to MMAP mode");
2951 for (cnt = 0; cnt < p->num_buffers; ++cnt) {
2952 if (-1 == munmap (p->buffer[cnt].start,p->buffer[cnt].length)) {
2953 camsrc_error("MUNMAP failed.");
2954 return CAMERASRC_ERR_INTERNAL;
2957 p->buffer[cnt].start = NULL;
2958 p->buffer[cnt].length = 0;
2961 case CAMERASRC_IO_METHOD_USRPTR:
2962 camsrc_info("User ptr mode don't need munmap");
2964 case CAMERASRC_IO_METHOD_READ:
2966 camsrc_error("Device not support that io-method");
2967 #if USE_NOT_SUPPORT_ERR
2968 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2970 return CAMERASRC_SUCCESS;
2974 /* release buffer */
2976 vreq_bufs.count = 0;
2977 vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2978 vreq_bufs.memory = V4L2_MEMORY_MMAP;
2979 if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_REQBUFS, &vreq_bufs)) {
2980 strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
2981 camsrc_error("VIDIOC_REQBUFS failed : %s", err_msg);
2982 return CAMERASRC_ERR_IO_CONTROL;
2985 /* RETURN BUFFER MANAGE MODE TO DEFAULT */
2986 p->io_method = CAMERASRC_IO_METHOD_MMAP;
2987 p->present_buf = NULL;
2989 if (p->buffer != NULL) {
2993 if (p->alter_frame.start != NULL) {
2994 free(p->alter_frame.start);
2998 p->alter_frame.start = NULL;
3003 return CAMERASRC_SUCCESS;
3007 int camerasrc_wait_frame_available(camsrc_handle_t handle, long int timeout)
3009 camerasrc_handle_t *p = NULL;
3010 int err = CAMERASRC_ERR_UNKNOWN;
3012 if (handle == NULL) {
3013 camsrc_error("handle is null");
3014 return CAMERASRC_ERR_NULL_POINTER;
3017 p = CAMERASRC_HANDLE(handle);
3019 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL &&
3020 CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW &&
3021 CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO &&
3022 CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) {
3023 camsrc_warning("Invalid state transition" );
3026 if ( p->queued_buffer_count > 0 ) {
3027 /*camsrc_info( CAMERASRC, "Current queue count : %d", p->queued_buffer_count );*/
3028 err = _camerasrc_wait_frame_available(p, timeout);
3030 camsrc_warning("queued_buffer_count[%d] is unavailable. sleep 100 ms and try again...", p->queued_buffer_count );
3032 err = CAMERASRC_ERR_INVALID_STATE;
3039 int camerasrc_check_esd_shock(camsrc_handle_t *handle, int *check_val)
3041 camerasrc_handle_t* p = NULL;
3042 int err = CAMERASRC_ERR_UNKNOWN;
3044 camsrc_info("enter");
3046 if(handle == NULL) {
3047 camsrc_error("handle is null");
3048 return CAMERASRC_ERR_NULL_POINTER;
3051 p = CAMERASRC_HANDLE(handle);
3053 printf("start _camerasrc_check_emp_shock");
3055 err = _camerasrc_check_emp_shock(p, check_val);
3056 printf("check_val = %d", *check_val);
3057 printf("end _camerasrc_check_emp_shock");
3063 int camerasrc_queue_buffer(camsrc_handle_t handle, int buf_index, camerasrc_buffer_t *buffer)
3065 camerasrc_handle_t *p = NULL;
3066 int err = CAMERASRC_ERR_UNKNOWN;
3068 if (handle == NULL) {
3069 camsrc_error("handle is null");
3070 return CAMERASRC_ERR_NULL_POINTER;
3073 p = CAMERASRC_HANDLE(handle);
3075 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL &&
3076 CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW &&
3077 CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO &&
3078 CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS ) {
3079 camsrc_warning("Invalid state transition");
3082 err = _camerasrc_queue_buffer(p, buf_index, buffer);
3088 int camerasrc_dequeue_buffer(camsrc_handle_t handle, int *buf_index, camerasrc_buffer_t *buffer, camerasrc_buffer_t *thm_buffer)
3090 camerasrc_handle_t *p = NULL;
3091 int err = CAMERASRC_ERR_UNKNOWN;
3093 if (handle == NULL) {
3094 camsrc_error("handle is null");
3095 return CAMERASRC_ERR_NULL_POINTER;
3098 p = CAMERASRC_HANDLE(handle);
3100 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL &&
3101 CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW &&
3102 CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO &&
3103 CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) {
3104 camsrc_warning("Invalid state transition");
3107 err = _camerasrc_dequeue_buffer(p, buf_index, buffer, thm_buffer);
3113 int camerasrc_read_frame(camsrc_handle_t handle, camerasrc_buffer_t *main_img_buffer, camerasrc_buffer_t *thm_img_buffer, int *buffer_index)
3115 camerasrc_handle_t* p = NULL;
3116 int err = CAMERASRC_ERR_UNKNOWN;
3118 camsrc_info("ENTER");
3120 if (!handle || !main_img_buffer || !thm_img_buffer || !buffer_index) {
3121 camsrc_error("handle(%p)main(%p)thm(%p)index(%p) is null",
3122 handle, main_img_buffer, thm_img_buffer, buffer_index);
3123 return CAMERASRC_ERR_NULL_POINTER;
3126 p = CAMERASRC_HANDLE(handle);
3128 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_STILL &&
3129 CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW &&
3130 CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO &&
3131 CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) {
3132 camsrc_warning("Invalid state transition");
3135 #ifndef DUMMY_OUTPUT
3136 __ta__( " Stillshot select()",
3137 err = _camerasrc_wait_frame_available(p, CAMERASRC_TIMEOUT_CRITICAL_VALUE);
3139 if (err != CAMERASRC_SUCCESS) {
3140 camsrc_error("Frame waiting error, [%x]", err);
3145 __ta__( " Stillshot VIDIOC_DQBUF",
3146 err = _camerasrc_dequeue_buffer(p, buffer_index, main_img_buffer, thm_img_buffer);
3148 if (err != CAMERASRC_SUCCESS) {
3149 camsrc_error("Dequeue frame error, [%x]", err);
3154 camsrc_info("DEQUEUED Index : %d", *buffer_index);
3156 #if defined(USE_CAMERASRC_FRAME_DUMP)
3157 printf("******************in buf len = %d", inner_main_buffer.length);
3158 write_buffer_into_path(&inner_main_buffer, CAMERASRC_FRAME_DUMP_PATH, "main.jpg");
3161 return CAMERASRC_SUCCESS;
3165 int camerasrc_set_focused_callback(camsrc_handle_t handle, camerasrc_callback_t cb, void *usr_data)
3167 camerasrc_handle_t *p = NULL;
3169 camsrc_info("enter");
3171 if (handle == NULL) {
3172 camsrc_error("handle is null");
3173 return CAMERASRC_ERR_NULL_POINTER;
3176 p = CAMERASRC_HANDLE(handle);
3178 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_REALIZED &&
3179 CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3180 camsrc_warning("Invalid state transition");
3185 if (usr_data != NULL) {
3186 p->af_usr_data = usr_data;
3190 return CAMERASRC_SUCCESS;
3194 int camerasrc_set_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t *rect)
3196 camerasrc_handle_t *p = NULL;
3197 int err = CAMERASRC_ERR_UNKNOWN;
3199 camsrc_info("enter");
3201 if (handle == NULL) {
3202 camsrc_error("handle is null");
3203 return CAMERASRC_ERR_NULL_POINTER;
3206 p = CAMERASRC_HANDLE(handle);
3208 if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3209 camsrc_warning("Invalid state transition");
3212 err = _camerasrc_set_autofocusing_area(p, rect);
3214 if (err != CAMERASRC_SUCCESS) {
3215 camsrc_error("Set autofocusing area error");
3219 return CAMERASRC_SUCCESS;
3223 int camerasrc_get_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t *rect)
3225 camerasrc_handle_t *p = NULL;
3226 int err = CAMERASRC_ERR_UNKNOWN;
3228 camsrc_info("enter");
3230 if (handle == NULL) {
3231 camsrc_error("handle is null");
3232 return CAMERASRC_ERR_NULL_POINTER;
3235 p = CAMERASRC_HANDLE(handle);
3237 if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3238 camsrc_warning("Invalid state transition");
3241 err = _camerasrc_get_autofocusing_area(p, rect);
3243 if (err != CAMERASRC_SUCCESS) {
3244 camsrc_error("Get autofocusing area error");
3248 return CAMERASRC_SUCCESS;
3252 int camerasrc_start_autofocusing(camsrc_handle_t handle)
3254 camerasrc_handle_t *p = NULL;
3255 int err = CAMERASRC_ERR_UNKNOWN;
3257 camsrc_info("enter");
3259 if (handle == NULL) {
3260 camsrc_error("handle is null");
3261 return CAMERASRC_ERR_NULL_POINTER;
3264 p = CAMERASRC_HANDLE(handle);
3266 if (!(CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW ||
3267 CAMERASRC_STATE(p) == CAMERASRC_STATE_VIDEO ||
3268 CAMERASRC_STATE(p) == CAMERASRC_STATE_AF_IN_PROGRESS)) {
3269 camsrc_error("Invalid state [%d]", CAMERASRC_STATE(p));
3270 return CAMERASRC_ERR_INVALID_STATE;
3274 err = _camerasrc_start_autofocusing(p);
3276 if (err != CAMERASRC_SUCCESS) {
3277 camsrc_error("Create autofocusing thread error");
3281 camsrc_info("Set state to [AF-IN-PROGRESS]!!");
3282 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_AF_IN_PROGRESS);
3284 return CAMERASRC_SUCCESS;
3288 int camerasrc_stop_autofocusing(camsrc_handle_t handle)
3290 camerasrc_handle_t *p = NULL;
3291 int err = CAMERASRC_ERR_UNKNOWN;
3293 camsrc_info("enter");
3295 if (handle == NULL) {
3296 camsrc_error("handle is null");
3297 return CAMERASRC_ERR_NULL_POINTER;
3300 p = CAMERASRC_HANDLE(handle);
3302 if (!(CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW ||
3303 CAMERASRC_STATE(p) == CAMERASRC_STATE_VIDEO ||
3304 CAMERASRC_STATE(p) == CAMERASRC_STATE_AF_IN_PROGRESS)) {
3305 camsrc_error("Invalid state [%d]", CAMERASRC_STATE(p));
3306 return CAMERASRC_ERR_INVALID_STATE;
3310 camsrc_info("AF_STOP called!!");
3311 err = _camerasrc_stop_autofocusing(p);
3312 if (err != CAMERASRC_SUCCESS) {
3313 camsrc_error("Stop autofocusing error");
3317 if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) {
3318 camsrc_info("Set state to [PREVIEW] again!!");
3319 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW);
3321 camsrc_info("Do not change state");
3324 return CAMERASRC_SUCCESS;
3328 int camerasrc_release_autofocusing(camsrc_handle_t handle)
3330 camerasrc_handle_t *p = NULL;
3331 int err = CAMERASRC_ERR_UNKNOWN;
3333 camsrc_info("enter");
3335 if (handle == NULL) {
3336 camsrc_error("handle is null");
3337 return CAMERASRC_ERR_NULL_POINTER;
3340 p = CAMERASRC_HANDLE(handle);
3342 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW &&
3343 CAMERASRC_STATE(p) != CAMERASRC_STATE_VIDEO &&
3344 CAMERASRC_STATE(p) != CAMERASRC_STATE_AF_IN_PROGRESS) {
3345 return CAMERASRC_SUCCESS;
3349 camsrc_info("AF_RELEASE called!!");
3350 err = _camerasrc_release_autofocusing(p);
3351 if (err != CAMERASRC_SUCCESS) {
3352 camsrc_error("Stop autofocusing error");
3356 camsrc_info("Set state to [PREVIEW] again!!");
3357 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW);
3359 return CAMERASRC_SUCCESS;
3363 int camerasrc_init_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t af_mode, camerasrc_af_scan_range_t af_range)
3365 camerasrc_handle_t *p = NULL;
3366 int err = CAMERASRC_ERR_UNKNOWN;
3368 camsrc_info("enter");
3370 if (handle == NULL) {
3371 camsrc_error("handle is null");
3372 return CAMERASRC_ERR_NULL_POINTER;
3375 p = CAMERASRC_HANDLE(handle);
3377 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW) {
3378 camsrc_warning("Invalid state transition");
3381 p->cur_af_mode = af_mode;
3382 p->cur_af_range = af_range;
3384 err = _camerasrc_init_autofocusing_mode(p);
3385 if (err != CAMERASRC_SUCCESS) {
3386 camsrc_error("Init autofocusing mode error");
3390 return CAMERASRC_SUCCESS;
3394 int camerasrc_get_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t *af_mode, camerasrc_af_scan_range_t *af_range)
3396 camerasrc_handle_t *p = NULL;
3398 camsrc_info("enter");
3400 if (handle == NULL) {
3401 camsrc_error("handle is null");
3402 return CAMERASRC_ERR_NULL_POINTER;
3405 p = CAMERASRC_HANDLE(handle);
3408 *af_mode = p->cur_af_mode;
3412 *af_range = p->cur_af_range;
3415 return CAMERASRC_SUCCESS;
3419 int camerasrc_get_autofocusing_status(camsrc_handle_t handle, camerasrc_auto_focus_status_t *af_status)
3421 camerasrc_handle_t *p = NULL;
3423 camsrc_info("enter");
3425 if (handle == NULL) {
3426 camsrc_error("handle is null");
3427 return CAMERASRC_ERR_NULL_POINTER;
3430 if (af_status == NULL) {
3431 camsrc_error("*af_status is NULL");
3432 return CAMERASRC_ERR_NULL_POINTER;
3435 p = CAMERASRC_HANDLE(handle);
3437 *af_status = p->af_status;
3439 camsrc_info("[camerasrc_get_autofocusing_status] %d", *af_status);
3441 return CAMERASRC_SUCCESS;
3444 /**** M I S C E L L A N E O U S O P E R A T I O N ****/
3446 /**** I N P U T ( C A M D E V I C E ) O P E R A T I O N ****/
3448 int camerasrc_get_input(camsrc_handle_t handle, camerasrc_dev_id_t *id)
3450 camerasrc_handle_t *p = NULL;
3452 camsrc_info("enter");
3454 if (handle == NULL) {
3455 camsrc_error("handle is null");
3456 return CAMERASRC_ERR_NULL_POINTER;
3459 p = CAMERASRC_HANDLE(handle);
3461 if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3462 camsrc_warning("Invalid phase");
3465 *id = p->cur_dev_id;
3467 return CAMERASRC_SUCCESS;
3471 int camerasrc_set_input(camsrc_handle_t handle, camerasrc_dev_id_t camera_id)
3473 camerasrc_handle_t *p = NULL;
3474 struct v4l2_control control;
3475 int err = CAMERASRC_ERR_UNKNOWN;
3477 camsrc_info("enter");
3479 if (handle == NULL) {
3480 camsrc_error("handle is null");
3481 return CAMERASRC_ERR_NULL_POINTER;
3484 p = CAMERASRC_HANDLE(handle);
3486 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3487 camsrc_error("Invalid state");
3488 return CAMERASRC_ERR_INVALID_STATE;
3491 if (p->cur_dev_id == camera_id) {
3492 return CAMERASRC_SUCCESS;
3495 camsrc_info("Set Index to %d", _CAMERASRC_GET_DEV_INDEX(camera_id));
3497 err = _camerasrc_ioctl(p, VIDIOC_S_INPUT, &(_CAMERASRC_GET_DEV_INDEX(camera_id)));
3498 if (CAMERASRC_SUCCESS != err) {
3499 camsrc_error("[***DEBUG] ERROR SET INPUT to %dth DEVICE", _CAMERASRC_GET_DEV_INDEX(camera_id));
3500 return CAMERASRC_ERR_IO_CONTROL;
3502 camsrc_info("[***DEBUG] SET INPUT OK!!! to %dth DEVICE", _CAMERASRC_GET_DEV_INDEX(camera_id));
3503 camsrc_info("return value of ioctl VIDIOC_S_INPUT = %d", err);
3506 p->cur_dev_id = camera_id;
3508 /* check physical rotation of camera lens */
3509 #ifndef V4L2_CID_PHYSICAL_ROTATION
3510 #define V4L2_CID_PHYSICAL_ROTATION (V4L2_CID_PRIVATE_BASE + 300)
3511 #endif /* V4L2_CID_PHYSICAL_ROTATION */
3513 control.id = V4L2_CID_PHYSICAL_ROTATION;
3514 _camerasrc_ioctl(handle, VIDIOC_G_CTRL, &control);
3515 if(CAMERASRC_SUCCESS != _camerasrc_ioctl(handle, VIDIOC_G_CTRL, &control)) {
3516 camsrc_warning("failed to get rotation of lens");
3517 p->lens_rotation = -1;
3519 p->lens_rotation = control.value;
3520 camsrc_info("lens rotation %d", p->lens_rotation);
3526 /**** O U T P U T C O N T R O L O P E R A T I O N ****/
3528 int camerasrc_set_timeperframe(camsrc_handle_t handle, camerasrc_frac_t *frac)
3530 camerasrc_handle_t *p = NULL;
3532 camsrc_info("enter");
3534 if (handle == NULL) {
3535 camsrc_error("handle is null");
3536 return CAMERASRC_ERR_NULL_POINTER;
3539 p = CAMERASRC_HANDLE(handle);
3541 if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3542 camsrc_warning("Invalid phase, but can go");
3545 camsrc_info("Numerator = %d, Denominator = %d", frac->numerator, frac->denominator);
3548 p->timeperframe.numerator = frac->numerator;
3549 p->timeperframe.denominator = frac->denominator;
3552 return CAMERASRC_SUCCESS;
3556 int camerasrc_set_format(camsrc_handle_t handle, camerasrc_format_t *fmt)
3558 camerasrc_handle_t *p = NULL;
3559 int err = CAMERASRC_ERR_UNKNOWN;
3561 camsrc_info("enter");
3563 if (handle == NULL) {
3564 camsrc_error("handle is null");
3565 return CAMERASRC_ERR_NULL_POINTER;
3568 p = CAMERASRC_HANDLE(handle);
3570 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3571 camsrc_error("Invalid state");
3574 err = _camerasrc_dump_format(handle);
3575 if (err != CAMERASRC_SUCCESS) {
3576 camsrc_error("Format dump error");
3582 p->format.colorspace = fmt->colorspace;
3583 p->format.bytesperline = fmt->bytesperline;
3584 p->format.img_size.dim.width = fmt->img_size.dim.width;
3585 p->format.img_size.dim.height = fmt->img_size.dim.height;
3586 p->format.thumb_size.dim.width = fmt->thumb_size.dim.width;
3587 p->format.thumb_size.dim.height= fmt->thumb_size.dim.height;
3588 p->format.is_highquality_mode = fmt->is_highquality_mode;
3589 p->format.pix_format = fmt->pix_format;
3590 p->format.quality = fmt->quality;
3591 p->format.sizeimage = fmt->sizeimage;
3592 p->format.rotation = fmt->rotation;
3595 switch (fmt->pix_format) {
3596 case CAMERASRC_PIX_YUV422P:
3597 p->format.num_planes = 3;
3599 case CAMERASRC_PIX_YUV420P:
3600 p->format.num_planes = 3;
3602 case CAMERASRC_PIX_YUV420:
3603 p->format.num_planes = 2;
3605 case CAMERASRC_PIX_SN12:
3606 p->format.num_planes = 2;
3608 case CAMERASRC_PIX_ST12:
3609 p->format.num_planes = 2;
3611 case CAMERASRC_PIX_NV12:
3612 p->format.num_planes = 2;
3614 case CAMERASRC_PIX_YUY2:
3615 p->format.num_planes = 1;
3617 case CAMERASRC_PIX_UYVY:
3618 p->format.num_planes = 1;
3620 case CAMERASRC_PIX_RGGB8:
3621 p->format.num_planes = 1;
3623 case CAMERASRC_PIX_RGGB10:
3624 p->format.num_planes = 1;
3626 case CAMERASRC_PIX_RGB565:
3627 p->format.num_planes = 1;
3630 p->format.num_planes = 3;
3631 camsrc_error("Invalid output format.");
3635 err = _camerasrc_dump_format(handle);
3636 if (err != CAMERASRC_SUCCESS) {
3637 camsrc_error("Format dump error");
3641 camsrc_info("leave");
3647 int camerasrc_get_format(camsrc_handle_t handle, camerasrc_format_t *fmt)
3649 camerasrc_handle_t *p = NULL;
3651 camsrc_info("enter");
3653 if (handle == NULL) {
3654 camsrc_error("handle is null");
3655 return CAMERASRC_ERR_NULL_POINTER;
3658 p = CAMERASRC_HANDLE(handle);
3660 if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3661 camsrc_warning("Invalid phase");
3664 memcpy(fmt, &(p->format), sizeof(camerasrc_format_t));
3666 camsrc_info("leave");
3668 return CAMERASRC_SUCCESS;
3672 int camerasrc_try_format(camsrc_handle_t handle, camerasrc_format_t *fmt)
3674 camerasrc_handle_t *p = NULL;
3675 int err = CAMERASRC_ERR_UNKNOWN;
3677 camsrc_info("enter");
3679 if (handle == NULL) {
3680 camsrc_error("handle is null");
3681 return CAMERASRC_ERR_NULL_POINTER;
3684 p = CAMERASRC_HANDLE(handle);
3686 if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3687 camsrc_error("Invalid state");
3688 return CAMERASRC_ERR_INVALID_STATE;
3691 /* size limitaion check */
3692 if (fmt->img_size.dim.width < 0 || fmt->img_size.dim.width > CAMERASRC_MAX_WIDTH) {
3693 camsrc_info("Invalid width");
3694 return CAMERASRC_ERR_INVALID_PARAMETER;
3696 if (fmt->img_size.dim.height < 0 || fmt->img_size.dim.height > CAMERASRC_MAX_HEIGHT) {
3697 camsrc_info("Invalid height");
3698 return CAMERASRC_ERR_INVALID_PARAMETER;
3701 /* check pixel number & colorspace are in bound */
3702 if (fmt->pix_format < 0 || fmt->pix_format >= CAMERASRC_PIX_NUM) {
3703 camsrc_info("Invalid pixel format");
3704 return CAMERASRC_ERR_INVALID_PARAMETER;
3706 if (fmt->colorspace < 0 || fmt->colorspace >= CAMERASRC_COL_NUM) {
3707 camsrc_info("Invalid colorspace");
3708 return CAMERASRC_ERR_INVALID_PARAMETER;
3711 /* colorspace & pixel format combinability check */
3712 if (_CAMERASRC_MATCH_COL_TO_PIX(p->cur_dev_id, fmt->colorspace, fmt->pix_format, CAMERASRC_QUALITY_HIGH) ||
3713 _CAMERASRC_MATCH_COL_TO_PIX(p->cur_dev_id, fmt->colorspace, fmt->pix_format, CAMERASRC_QUALITY_NORMAL)) {
3714 err = CAMERASRC_SUCCESS;
3716 camsrc_info("UNAVAILABLE SETTING");
3717 err = CAMERASRC_ERR_INVALID_PARAMETER;
3720 camsrc_info("leave");
3726 int camerasrc_get_frame_data(camsrc_handle_t handle, camerasrc_frame_data_t *data)
3728 camerasrc_handle_t *p = NULL;
3729 int err = CAMERASRC_ERR_UNKNOWN;
3731 if (handle == NULL) {
3732 camsrc_error("handle is null");
3733 return CAMERASRC_ERR_NULL_POINTER;
3736 p = CAMERASRC_HANDLE(handle);
3738 if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3739 camsrc_warning("Invalid state transition");
3742 err = _camerasrc_get_frame_data(p, data);
3743 if (err != CAMERASRC_SUCCESS) {
3744 camsrc_error("toggle auto exposure failed");
3752 static int _camerasrc_dump_format(camsrc_handle_t handle)
3754 camerasrc_handle_t *p = NULL;
3756 camsrc_info("enter");
3758 if (handle == NULL) {
3759 camsrc_error("handle is null");
3760 return CAMERASRC_ERR_NULL_POINTER;
3763 p = CAMERASRC_HANDLE(handle);
3765 camsrc_info("---------FORMAT SETTING DUMP--------");
3766 camsrc_info("- Image size : %d x %d", p->format.img_size.dim.width, p->format.img_size.dim.height);
3767 camsrc_info("- Thumbnail size : %d x %d", p->format.thumb_size.dim.width, p->format.thumb_size.dim.height);
3768 camsrc_info("- Pixel format : %d", p->format.pix_format);
3769 camsrc_info("- Bytes per line : %d", p->format.bytesperline);
3770 camsrc_info("- Image size in bytes : %d", p->format.sizeimage);
3771 camsrc_info("- Colorspace : %d", p->format.colorspace);
3772 camsrc_info("- Rotation : %d", p->format.rotation);
3773 camsrc_info("------------------------------------");
3775 return CAMERASRC_SUCCESS;
3779 int camerasrc_get_exif_info(camsrc_handle_t handle, camerasrc_exif_t *exif_struct)
3781 camerasrc_handle_t* p = NULL;
3782 int err = CAMERASRC_ERR_UNKNOWN;
3784 camsrc_info("enter");
3786 if (handle == NULL) {
3787 camsrc_error("handle is null");
3788 return CAMERASRC_ERR_NULL_POINTER;
3791 p = CAMERASRC_HANDLE(handle);
3793 if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3794 camsrc_warning("Invalid state transition");
3797 err = _camerasrc_get_exif_info(p, (camerasrc_buffer_t*)exif_struct);
3798 if (err != CAMERASRC_SUCCESS) {
3799 camsrc_error("Get exif information string failed");
3806 int camerasrc_device_is_open(camsrc_handle_t handle)
3808 camerasrc_handle_t *p = handle;
3811 if (p->dev_fd > 0) {
3820 int camerasrc_set_videofd(camsrc_handle_t handle, int videofd)
3822 camerasrc_handle_t *p = handle;
3825 p->dev_fd = videofd;
3826 return CAMERASRC_SUCCESS;
3828 return CAMERASRC_ERR_INVALID_HANDLE;
3833 int camerasrc_set_af_hold_after_capture(camsrc_handle_t handle, int hold_af)
3835 camerasrc_handle_t *p = NULL;
3837 camsrc_info("enter");
3839 if (handle == NULL) {
3840 camsrc_error("handle is null");
3841 return CAMERASRC_ERR_NULL_POINTER;
3844 p = CAMERASRC_HANDLE(handle);
3846 p->hold_af_after_capturing = hold_af;
3848 camsrc_info("leave");
3850 return CAMERASRC_SUCCESS;
3854 int camerasrc_set_sensor_mode(camsrc_handle_t handle, int mode)
3856 camerasrc_handle_t *p = NULL;
3858 camsrc_info("enter");
3860 if (handle == NULL) {
3861 camsrc_error("handle is null");
3862 return CAMERASRC_ERR_NULL_POINTER;
3865 p = CAMERASRC_HANDLE(handle);
3867 p->sensor_mode = mode;
3869 camsrc_info("leave");
3871 return CAMERASRC_SUCCESS;
3875 int camerasrc_set_vflip(camsrc_handle_t handle, int vflip)
3877 camerasrc_handle_t *p = NULL;
3879 camsrc_info("enter");
3881 if (handle == NULL) {
3882 camsrc_error("handle is null");
3883 return CAMERASRC_ERR_NULL_POINTER;
3886 p = CAMERASRC_HANDLE(handle);
3890 if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) {
3891 CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip));
3894 camsrc_info("leave");
3896 return CAMERASRC_SUCCESS;
3900 int camerasrc_set_hflip(camsrc_handle_t handle, int hflip)
3902 camerasrc_handle_t *p = NULL;
3904 camsrc_info("enter");
3906 if (handle == NULL) {
3907 camsrc_error("handle is null");
3908 return CAMERASRC_ERR_NULL_POINTER;
3911 p = CAMERASRC_HANDLE(handle);
3914 if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) {
3915 CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip));
3918 camsrc_info("leave");
3920 return CAMERASRC_SUCCESS;
3924 /* For Query functionalities */
3925 int camerasrc_read_basic_dev_info(camerasrc_dev_id_t dev_id, camerasrc_caps_info_t* caps_info)
3927 int err = CAMERASRC_ERR_UNKNOWN;
3929 char* store_path = NULL;
3932 camsrc_info("enter");
3934 if(dev_id == CAMERASRC_DEV_ID_PRIMARY)
3935 store_path = CAMERASRC_PRIMARY_BASIC_INFO_PATH;
3936 else if (dev_id == CAMERASRC_DEV_ID_SECONDARY)
3937 store_path = CAMERASRC_SECONDARY_BASIC_INFO_PATH;
3940 camsrc_error("Unsupported device ID");
3941 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
3944 fp = fopen(store_path, "rb");
3947 fseek(fp, 0, SEEK_SET);
3948 nread = fread(caps_info, 1, sizeof(camerasrc_caps_info_t), fp);
3949 camsrc_info("Need to be read : %d / Actual read : %d", sizeof(camerasrc_caps_info_t), nread);
3953 return CAMERASRC_ERR_ALLOCATION;
3955 err = CAMERASRC_SUCCESS;
3956 camsrc_info("leave");
3961 int camerasrc_read_misc_dev_info(camerasrc_dev_id_t dev_id, camerasrc_ctrl_list_info_t* ctrl_info)
3963 int err = CAMERASRC_ERR_UNKNOWN;
3964 camsrc_info("enter");
3968 char* store_path = NULL;
3970 if(dev_id == CAMERASRC_DEV_ID_PRIMARY)
3971 store_path = CAMERASRC_PRIMARY_MISC_INFO_PATH;
3972 else if (dev_id == CAMERASRC_DEV_ID_SECONDARY)
3973 store_path = CAMERASRC_SECONDARY_MISC_INFO_PATH;
3976 camsrc_error("Unsupported device ID");
3977 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
3980 fp = fopen(store_path, "rb");
3983 fseek(fp, 0, SEEK_SET);
3984 nread = fread(ctrl_info, 1, sizeof(camerasrc_ctrl_list_info_t), fp);
3985 camsrc_info("Need to be read : %d / Actual read : %d", sizeof(camerasrc_ctrl_list_info_t), nread);
3989 return CAMERASRC_ERR_ALLOCATION;
3991 err = CAMERASRC_SUCCESS;
3992 camsrc_info("leave");
3997 int camerasrc_read_extra_dev_info(camerasrc_dev_id_t dev_id, camerasrc_extra_info_t* extra_info)
3999 int err = CAMERASRC_ERR_UNKNOWN;
4000 camsrc_info("enter");
4004 char* store_path = NULL;
4006 if(dev_id == CAMERASRC_DEV_ID_PRIMARY)
4007 store_path = CAMERASRC_PRIMARY_EXTRA_INFO_PATH;
4008 else if (dev_id == CAMERASRC_DEV_ID_SECONDARY)
4009 store_path = CAMERASRC_SECONDARY_EXTRA_INFO_PATH;
4012 camsrc_error("Unsupported device ID");
4013 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4016 fp = fopen(store_path, "rb");
4019 fseek(fp, 0, SEEK_SET);
4020 nread = fread(extra_info, 1, sizeof(camerasrc_extra_info_t), fp);
4021 camsrc_info("Need to be read : %d / Actual read : %d", sizeof(camerasrc_extra_info_t), nread);
4025 return CAMERASRC_ERR_ALLOCATION;
4027 err = CAMERASRC_SUCCESS;
4028 camsrc_info("leave");
4033 int camerasrc_write_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info)
4035 camerasrc_handle_t* p = NULL;
4036 char* store_path = NULL;
4039 camsrc_info("enter");
4041 if(handle == NULL) {
4042 camsrc_error("handle is null");
4043 return CAMERASRC_ERR_NULL_POINTER;
4046 p = CAMERASRC_HANDLE(handle);
4050 if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY)
4052 camsrc_info("Primary(Mega) camera capabilities info will be written..");
4053 store_path = CAMERASRC_PRIMARY_BASIC_INFO_PATH;
4055 else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY)
4057 camsrc_info("Secondary(VGA) camera capabilities info will be written..");
4058 store_path = CAMERASRC_SECONDARY_BASIC_INFO_PATH;
4062 camsrc_error("Unsupported device ID");
4063 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4065 camsrc_info("PATH = %s", store_path);
4067 fp = fopen(store_path, "wb");
4070 fseek(fp, 0, SEEK_SET);
4071 nwrite = fwrite(caps_info, 1, sizeof(camerasrc_caps_info_t), fp);
4072 camsrc_info("Need to be written : %d / Actual written : %d", sizeof(camerasrc_caps_info_t), nwrite);
4076 return CAMERASRC_ERR_ALLOCATION;
4078 camsrc_info("leave");
4079 return CAMERASRC_SUCCESS;
4083 int camerasrc_write_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_info)
4085 camerasrc_handle_t* p = NULL;
4087 camsrc_info("enter");
4089 if(handle == NULL) {
4090 camsrc_error("handle is null");
4091 return CAMERASRC_ERR_NULL_POINTER;
4094 p = CAMERASRC_HANDLE(handle);
4099 char* store_path = NULL;
4101 if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY)
4103 camsrc_info("Primary(Mega) camera controls info will be written..");
4104 store_path = CAMERASRC_PRIMARY_MISC_INFO_PATH;
4106 else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY)
4108 camsrc_info("Secondary(VGA) camera controls info will be written..");
4109 store_path = CAMERASRC_SECONDARY_MISC_INFO_PATH;
4113 camsrc_error("Unsupported device ID");
4114 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4117 fp = fopen(store_path, "wb");
4120 fseek(fp, 0, SEEK_SET);
4121 nwrite = fwrite(ctrl_info, 1, sizeof(camerasrc_ctrl_list_info_t), fp);
4122 camsrc_info("Need to be written : %d / Actual written : %d", sizeof(camerasrc_ctrl_list_info_t), nwrite);
4126 return CAMERASRC_ERR_ALLOCATION;
4128 camsrc_info("leave");
4129 return CAMERASRC_SUCCESS;
4133 int camerasrc_write_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info)
4135 camerasrc_handle_t* p = NULL;
4137 camsrc_info("enter");
4139 if(handle == NULL) {
4140 camsrc_error("handle is null");
4141 return CAMERASRC_ERR_NULL_POINTER;
4144 p = CAMERASRC_HANDLE(handle);
4149 char* store_path = NULL;
4151 if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY)
4153 camsrc_info("Primary(Mega) extra controls info will be written..");
4154 store_path = CAMERASRC_PRIMARY_EXTRA_INFO_PATH;
4156 else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY)
4158 camsrc_info("Secondary(VGA) extra controls info will be written..");
4159 store_path = CAMERASRC_SECONDARY_EXTRA_INFO_PATH;
4163 camsrc_error("Unsupported device ID");
4164 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4167 fp = fopen(store_path, "wb");
4170 fseek(fp, 0, SEEK_SET);
4171 nwrite = fwrite(extra_info, 1, sizeof(camerasrc_extra_info_t), fp);
4172 camsrc_info("Need to be written : %d / Actual written : %d", sizeof(camerasrc_extra_info_t), nwrite);
4176 return CAMERASRC_ERR_ALLOCATION;
4178 camsrc_info("leave");
4179 return CAMERASRC_SUCCESS;
4182 void _camerasrc_add_total_resolution_info( camerasrc_caps_info_t* caps_info, int fcc_use, int width, int height )
4186 if( 1 || fcc_use == CAMERASRC_FCC_USE_REC_PREVIEW
4187 || fcc_use == CAMERASRC_FCC_USE_CAP_PREVIEW )
4189 for( i = 0 ; i < caps_info->num_preview_resolution ; i++ )
4191 if( caps_info->preview_resolution_width[i] == width
4192 && caps_info->preview_resolution_height[i] == height )
4194 camsrc_info("preview resolution[%dx%d] is already existed.", width, height);
4199 caps_info->preview_resolution_width[i] = width;
4200 caps_info->preview_resolution_height[i] = height;
4201 caps_info->num_preview_resolution++;
4203 camsrc_info("preview resolution[%dx%d] is added.", width, height);
4205 else if( fcc_use == CAMERASRC_FCC_USE_NORMAL_CAPTURE
4206 || fcc_use == CAMERASRC_FCC_USE_CONT_CAPTURE )
4208 for( i = 0 ; i < caps_info->num_capture_resolution ; i++ )
4210 if( caps_info->capture_resolution_width[i] == width
4211 && caps_info->capture_resolution_height[i] == height )
4213 camsrc_info("capture resolution[%dx%d] is already existed.", width, height);
4218 caps_info->capture_resolution_width[i] = width;
4219 caps_info->capture_resolution_height[i] = height;
4220 caps_info->num_capture_resolution++;
4222 camsrc_info("capture resolution[%dx%d] is added.", width, height);
4228 void _camerasrc_add_total_fps( camerasrc_caps_info_t* caps_info, int numerator, int denominator )
4232 for( i = 0 ; i < caps_info->num_fps ; i++ )
4234 if( caps_info->fps[i].numerator == numerator
4235 && caps_info->fps[i].denominator == denominator )
4237 camsrc_info("fps[%d/%d] is already existed.", numerator, denominator);
4242 caps_info->fps[caps_info->num_fps].numerator = numerator;
4243 caps_info->fps[caps_info->num_fps].denominator = denominator;
4244 caps_info->num_fps++;
4246 camsrc_info("fps[%d/%d] is added.", numerator, denominator);
4251 int _camerasrc_query_pixfmt_timeperframe(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info, int fmt_index, int resolution_index )
4254 struct v4l2_frmivalenum vfrmivalenum;
4255 unsigned int fcc = 0;
4256 camerasrc_resolution_t* resolutions = NULL;
4258 if( !handle || !caps_info )
4260 camsrc_info("handle[%p] or caps_info[%p] is NULL.", handle, caps_info);
4261 return CAMERASRC_ERR_NULL_POINTER;
4264 if( 0 > fmt_index || 0 > resolution_index )
4266 camsrc_info("some index is too small. fmt_index[%d], resolution_index[%d]",
4267 fmt_index, resolution_index);
4268 return CAMERASRC_ERR_RANGE_UNDER;
4271 fcc = caps_info->fmt_desc[fmt_index].fcc;
4272 resolutions = &(caps_info->fmt_desc[fmt_index].resolutions[resolution_index]);
4275 *How many resolutions are supported in this format
4277 CLEAR(vfrmivalenum);
4278 vfrmivalenum.index = tpf_cnt;
4279 vfrmivalenum.pixel_format = fcc;
4280 vfrmivalenum.width = resolutions->w;
4281 vfrmivalenum.height = resolutions->h;
4283 while(0 == _camerasrc_ioctl(handle, VIDIOC_ENUM_FRAMEINTERVALS, &vfrmivalenum))
4285 resolutions->tpf[tpf_cnt].num = vfrmivalenum.discrete.numerator;
4286 resolutions->tpf[tpf_cnt].den = vfrmivalenum.discrete.denominator;
4289 _camerasrc_add_total_fps( caps_info, vfrmivalenum.discrete.denominator, vfrmivalenum.discrete.numerator );
4294 camsrc_info("No timeperframe supported. driver may not support to query");
4295 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4298 resolutions->num_avail_tpf = tpf_cnt;
4300 return CAMERASRC_SUCCESS;
4303 int _camerasrc_query_pixfmt_resolution(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info, int fmt_index )
4306 int err = CAMERASRC_ERR_UNKNOWN;
4307 struct v4l2_frmsizeenum vfrmszenum;
4308 camerasrc_fmt_desc_t* fmt_desc = NULL;
4310 if( !handle || !caps_info )
4312 camsrc_info("handle[%p] or caps_info[%p] is NULL.", handle, caps_info);
4313 return CAMERASRC_ERR_NULL_POINTER;
4318 camsrc_info("fmt_index[%d] is too small.", fmt_index);
4319 return CAMERASRC_ERR_RANGE_UNDER;
4322 fmt_desc = &caps_info->fmt_desc[fmt_index];
4325 *How many resolutions are supported in this format
4328 vfrmszenum.index = res_cnt;
4329 vfrmszenum.pixel_format = fmt_desc->fcc;
4330 while(0 == _camerasrc_ioctl(handle, VIDIOC_ENUM_FRAMESIZES, &vfrmszenum))
4332 fmt_desc->resolutions[res_cnt].w = vfrmszenum.discrete.width;
4333 fmt_desc->resolutions[res_cnt].h = vfrmszenum.discrete.height;
4335 _camerasrc_add_total_resolution_info( caps_info, caps_info->fmt_desc[fmt_index].fcc_use,
4336 vfrmszenum.discrete.width, vfrmszenum.discrete.height );
4338 err = _camerasrc_query_pixfmt_timeperframe(handle, caps_info, fmt_index, res_cnt);
4339 if(err != CAMERASRC_SUCCESS)
4341 camsrc_info("timeperframe querying error, err = %d", err);
4346 vfrmszenum.index = res_cnt;
4351 camsrc_info("No resolution supported in fcc[0x%8x]. driver may not support to query", fmt_desc->fcc);
4352 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4355 fmt_desc->num_resolution = res_cnt;
4357 return CAMERASRC_SUCCESS;
4360 int _camerasrc_query_basic_dev_info(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info) {
4361 struct v4l2_fmtdesc vfmtdesc;
4362 struct v4l2_input vinput;
4363 int err = CAMERASRC_ERR_UNKNOWN;
4365 char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
4367 caps_info->num_preview_resolution = 0;
4368 caps_info->num_capture_resolution = 0;
4369 caps_info->num_preview_fmt = 0;
4370 caps_info->num_capture_fmt = 0;
4371 caps_info->num_fps = 0;
4374 * Count how many formats are supported in this dev
4380 * What name of module is selected?
4382 if(CAMERASRC_SUCCESS != _camerasrc_ioctl(handle, VIDIOC_ENUMINPUT, &vinput)) {
4383 strerror_r(handle->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
4384 camsrc_error("VIDIOC_ENUMINPUT failed : %s", err_msg);
4385 return CAMERASRC_ERR_IO_CONTROL;
4387 memcpy(caps_info->dev_name, vinput.name, 32);
4390 vfmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
4391 while(0 == _camerasrc_ioctl(handle, VIDIOC_ENUM_FMT, &vfmtdesc))
4393 camsrc_info("pixelformat \"%c%c%c%c\"(%8x) detected",
4394 (char)(vfmtdesc.pixelformat >> 0),
4395 (char)(vfmtdesc.pixelformat >> 8),
4396 (char)(vfmtdesc.pixelformat >> 16),
4397 (char)(vfmtdesc.pixelformat >> 24),
4398 vfmtdesc.pixelformat);
4399 caps_info->fmt_desc[fmt_cnt].fcc = vfmtdesc.pixelformat;
4401 * Along the description of the format, we seperate them into each usecase
4403 camsrc_info("description \"%s\"", vfmtdesc.description );
4404 if(!strcmp("rec_prev", (const char*)(vfmtdesc.description)))
4406 caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_REC_PREVIEW;
4407 caps_info->preview_fmt[caps_info->num_preview_fmt] = vfmtdesc.pixelformat;
4408 caps_info->num_preview_fmt++;
4410 else if(!strcmp("cap_prev", (const char*)(vfmtdesc.description)))
4412 caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_CAP_PREVIEW;
4413 caps_info->preview_fmt[caps_info->num_preview_fmt] = vfmtdesc.pixelformat;
4414 caps_info->num_preview_fmt++;
4416 else if(!strcmp("recording", (const char*)(vfmtdesc.description)))
4418 caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_RECORDING;
4420 else if(!strcmp("capture", (const char*)(vfmtdesc.description)))
4422 caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_NORMAL_CAPTURE;
4423 caps_info->capture_fmt[caps_info->num_capture_fmt] = vfmtdesc.pixelformat;
4424 caps_info->num_capture_fmt++;
4426 else if(!strcmp("cont_cap", (const char*)(vfmtdesc.description)))
4428 caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_CONT_CAPTURE;
4429 caps_info->capture_fmt[caps_info->num_capture_fmt] = vfmtdesc.pixelformat;
4430 caps_info->num_capture_fmt++;
4434 caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_NONE;
4436 err = _camerasrc_query_pixfmt_resolution(handle, caps_info, fmt_cnt);
4437 if(err != CAMERASRC_SUCCESS)
4439 camsrc_info("pixel format querying error, err = %x", err);
4442 vfmtdesc.index = fmt_cnt;
4443 vfmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
4448 * memory allocation as counted num
4450 camsrc_info("Total supported format = %d", fmt_cnt);
4451 caps_info->num_fmt_desc = fmt_cnt;
4454 * If no formats supported
4458 camsrc_info("no format supported");
4459 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4461 return CAMERASRC_SUCCESS;
4465 int camerasrc_query_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info) {
4466 camerasrc_handle_t* p = NULL;
4467 int err = CAMERASRC_ERR_UNKNOWN;
4469 camsrc_info("enter");
4471 if(handle == NULL) {
4472 camsrc_error("handle is null");
4473 return CAMERASRC_ERR_NULL_POINTER;
4476 p = CAMERASRC_HANDLE(handle);
4478 err = _camerasrc_query_basic_dev_info(p, caps_info);
4480 err = CAMERASRC_SUCCESS;
4481 camsrc_info("leave");
4486 int _camerasrc_query_ctrl_menu (camerasrc_handle_t* handle, struct v4l2_queryctrl queryctrl, camerasrc_ctrl_info_t* ctrl_info)
4488 struct v4l2_querymenu querymenu;
4490 camsrc_info(" Menu items:");
4492 memset (&querymenu, 0, sizeof (querymenu));
4493 querymenu.id = queryctrl.id;
4495 for (querymenu.index = queryctrl.minimum;
4496 querymenu.index <= queryctrl.maximum;
4497 querymenu.index++) {
4498 if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYMENU, &querymenu)) {
4499 camsrc_info(" menu name : %s", querymenu.name);
4500 ctrl_info->ctrl_menu[querymenu.index].menu_index = querymenu.index;
4501 memcpy(&(ctrl_info->ctrl_menu[querymenu.index].menu_name), querymenu.name, 32);
4503 camsrc_error("VIDIOC_QUERYMENU error");
4504 return CAMERASRC_ERR_IO_CONTROL;
4507 return CAMERASRC_SUCCESS;
4510 static int _find_camsrc_ctrl_id(camerasrc_handle_t* handle, int v4l2_cid)
4514 for(i=0; i<CAMERASRC_CTRL_NUM; i++)
4516 tmp_id = _CAMERASRC_GET_CID(i, handle->cur_dev_id);
4517 if(tmp_id == v4l2_cid)
4524 int _camerasrc_query_misc_dev_info(camerasrc_handle_t* handle, camerasrc_ctrl_list_info_t* ctrl_list_info)
4526 struct v4l2_queryctrl queryctrl;
4532 camsrc_info("QUERY_BASE ");
4533 for (i = CAMERASRC_CTRL_BRIGHTNESS; i < CAMERASRC_CTRL_NUM; i++) {
4534 queryctrl.id = _CAMERASRC_GET_CID(i, handle->cur_dev_id);
4535 if(queryctrl.id == -1)
4539 if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYCTRL, &queryctrl)) {
4540 if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
4542 camsrc_info("ID [%8x] disabled", queryctrl.id);
4545 camsrc_info("Control %s", queryctrl.name);
4546 ctrl_list_info->ctrl_info[ctrl_cnt].v4l2_ctrl_id = queryctrl.id;
4547 ctrl_list_info->ctrl_info[ctrl_cnt].camsrc_ctrl_id = i;
4548 if(ctrl_list_info->ctrl_info[ctrl_cnt].camsrc_ctrl_id == -1)
4550 camsrc_warning("This control is not included in camsrc ctrl ID error");
4552 switch(queryctrl.type)
4554 case V4L2_CTRL_TYPE_INTEGER:
4555 ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_RANGE;
4557 case V4L2_CTRL_TYPE_BOOLEAN:
4558 ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_BOOL;
4560 case V4L2_CTRL_TYPE_MENU:
4561 ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_ARRAY;
4562 _camerasrc_query_ctrl_menu (handle, queryctrl, &(ctrl_list_info->ctrl_info[ctrl_cnt]));
4565 ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_UNKNOWN;
4568 memcpy(ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_name,queryctrl.name, 32);
4569 ctrl_list_info->ctrl_info[ctrl_cnt].min = queryctrl.minimum;
4570 ctrl_list_info->ctrl_info[ctrl_cnt].max = queryctrl.maximum;
4571 ctrl_list_info->ctrl_info[ctrl_cnt].step = queryctrl.step;
4572 ctrl_list_info->ctrl_info[ctrl_cnt].default_val = queryctrl.default_value;
4573 camsrc_info("Control %s", queryctrl.name);
4575 if (errno == EINVAL)
4577 camsrc_error("VIDIOC_QUERYCTRL error");
4578 return CAMERASRC_ERR_IO_CONTROL;
4582 ctrl_list_info->num_ctrl_list_info = ctrl_cnt;
4583 return CAMERASRC_SUCCESS;
4587 int camerasrc_query_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info)
4589 camerasrc_handle_t* p = NULL;
4590 int err = CAMERASRC_ERR_UNKNOWN;
4592 camsrc_info("enter");
4594 if(handle == NULL) {
4595 camsrc_error("handle is null");
4596 return CAMERASRC_ERR_NULL_POINTER;
4599 p = CAMERASRC_HANDLE(handle);
4601 err = _camerasrc_query_misc_dev_info(p, ctrl_list_info);
4603 err = CAMERASRC_SUCCESS;
4605 camsrc_info("leave");
4611 int camerasrc_query_misc_dev_ctrl_info(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t* ctrl_info)
4613 struct v4l2_queryctrl queryctrl;
4617 queryctrl.id = _CAMERASRC_GET_CID(ctrl_id, CAMERASRC_HANDLE(handle)->cur_dev_id);
4618 if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYCTRL, &queryctrl)) {
4619 if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
4621 camsrc_info("ID [%8x] disabled", queryctrl.id);
4623 camsrc_info("Control %s", queryctrl.name);
4624 ctrl_info->v4l2_ctrl_id = queryctrl.id;
4625 ctrl_info->camsrc_ctrl_id = ctrl_id;
4626 if(ctrl_info->camsrc_ctrl_id == -1)
4628 camsrc_warning("This control is not included in camsrc ctrl ID error");
4630 switch(queryctrl.type)
4632 case V4L2_CTRL_TYPE_INTEGER:
4633 ctrl_info->ctrl_type = CTRL_TYPE_RANGE;
4635 case V4L2_CTRL_TYPE_BOOLEAN:
4636 ctrl_info->ctrl_type = CTRL_TYPE_BOOL;
4638 case V4L2_CTRL_TYPE_MENU:
4639 ctrl_info->ctrl_type = CTRL_TYPE_ARRAY;
4640 _camerasrc_query_ctrl_menu (handle, queryctrl, ctrl_info);
4643 ctrl_info->ctrl_type = CTRL_TYPE_UNKNOWN;
4646 memcpy(ctrl_info->ctrl_name,queryctrl.name, MAX_SZ_CTRL_NAME_STRING);
4647 ctrl_info->min = queryctrl.minimum;
4648 ctrl_info->max = queryctrl.maximum;
4649 ctrl_info->step = queryctrl.step;
4650 ctrl_info->default_val = queryctrl.default_value;
4651 camsrc_info("Control %s", queryctrl.name);
4653 camsrc_error("VIDIOC_QUERYCTRL error");
4654 return CAMERASRC_ERR_IO_CONTROL;
4656 return CAMERASRC_SUCCESS;
4660 int camerasrc_dump_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info)
4662 camsrc_info("enter");
4666 camsrc_info("============================================================");
4667 for(i = 0; i < ctrl_list_info->num_ctrl_list_info; i++)
4669 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);
4670 camsrc_info(" Control type = %d", ctrl_list_info->ctrl_info[i].ctrl_type);
4671 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);
4672 if(ctrl_list_info->ctrl_info[i].ctrl_type == CTRL_TYPE_ARRAY)
4674 camsrc_info("\t\t - Menu list");
4675 for(j = ctrl_list_info->ctrl_info[i].min; j <= ctrl_list_info->ctrl_info[i].max; j++)
4677 camsrc_info("\t\t * %s", ctrl_list_info->ctrl_info[i].ctrl_menu[j].menu_name);
4681 camsrc_info("============================================================");
4682 camsrc_info("leave");
4683 return CAMERASRC_SUCCESS;
4687 int camerasrc_dump_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info) {
4688 camsrc_info("enter");
4691 camsrc_info("===============================================================");
4692 for(i = 0; i< caps_info->num_fmt_desc; i++)
4694 camsrc_info("Supported fourcc = \"%c%c%c%c\" (0x%08x) num of resolution = %d",
4695 (char)(caps_info->fmt_desc[i].fcc >> 0),
4696 (char)(caps_info->fmt_desc[i].fcc >> 8),
4697 (char)(caps_info->fmt_desc[i].fcc >> 16),
4698 (char)(caps_info->fmt_desc[i].fcc >> 24),
4699 caps_info->fmt_desc[i].fcc,
4700 caps_info->fmt_desc[i].num_resolution);
4701 for(j=0; j<caps_info->fmt_desc[i].num_resolution; j++)
4703 camsrc_info("\tresolution = %d x %d, num of tpf = %d",
4704 caps_info->fmt_desc[i].resolutions[j].w, caps_info->fmt_desc[i].resolutions[j].h,
4705 caps_info->fmt_desc[i].resolutions[j].num_avail_tpf);
4706 for(k=0; k<caps_info->fmt_desc[i].resolutions[j].num_avail_tpf; k++)
4708 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);
4712 camsrc_info("===============================================================");
4713 camsrc_info("total supported preview resolution");
4714 for( i = 0 ; i < caps_info->num_preview_resolution ; i++ )
4716 camsrc_info("%5dx%5d", caps_info->preview_resolution_width[i], caps_info->preview_resolution_height[i]);
4719 camsrc_info("===============================================================");
4720 camsrc_info("total supported capture resolution");
4721 for( i = 0 ; i < caps_info->num_capture_resolution ; i++ )
4723 camsrc_info("%5dx%5d", caps_info->capture_resolution_width[i], caps_info->capture_resolution_height[i]);
4726 camsrc_info("===============================================================");
4727 camsrc_info("total supported preview fourcc");
4728 for( i = 0 ; i < caps_info->num_preview_fmt ; i++ )
4730 camsrc_info("\"%c%c%c%c\" (0x%08x)",
4731 (char)(caps_info->preview_fmt[i]),
4732 (char)(caps_info->preview_fmt[i]>>8),
4733 (char)(caps_info->preview_fmt[i]>>16),
4734 (char)(caps_info->preview_fmt[i]>>24),
4735 caps_info->preview_fmt[i]);
4737 camsrc_info("===============================================================");
4738 camsrc_info("total supported capture fourcc");
4739 for( i = 0 ; i < caps_info->num_capture_fmt ; i++ )
4741 camsrc_info("\"%c%c%c%c\" (0x%08x)",
4742 (char)(caps_info->capture_fmt[i]),
4743 (char)(caps_info->capture_fmt[i]>>8),
4744 (char)(caps_info->capture_fmt[i]>>16),
4745 (char)(caps_info->capture_fmt[i]>>24),
4746 caps_info->capture_fmt[i]);
4748 camsrc_info("===============================================================");
4749 camsrc_info("total supported fps");
4750 for( i = 0 ; i < caps_info->num_fps ; i++ )
4752 camsrc_info("%3d/%3d", caps_info->fps[i].numerator, caps_info->fps[i].denominator);
4754 camsrc_info("===============================================================");
4755 camsrc_info("leave");
4756 return CAMERASRC_SUCCESS;
4760 int camerasrc_dump_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info)
4762 camsrc_info("enter");
4763 camsrc_info("===============================================================");
4764 camsrc_info(" Strobe can support below");
4765 if (extra_info->strobe_caps == CAMERASRC_STROBE_CAP_NONE) {
4766 camsrc_info(" - Strobe Support Nothing");
4768 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_OFF)
4769 camsrc_info(" - Always off mode");
4770 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_ON)
4771 camsrc_info(" - Always on mode");
4772 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_AUTO)
4773 camsrc_info(" - Auto mode");
4774 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_REDEYE)
4775 camsrc_info(" - Redeye reduction mode");
4776 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_SLOWSYNC)
4777 camsrc_info(" - Slow sync mode");
4778 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_FRONT_CURTAIN)
4779 camsrc_info(" - Front curtain mode");
4780 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_REAR_CURTAIN)
4781 camsrc_info(" - Rear curtain mode");
4782 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_PERMANENT)
4783 camsrc_info(" - Permanent mode");
4784 if (extra_info->strobe_caps & CAMERASRC_STROBE_CAP_EXTERNAL)
4785 camsrc_info(" - External strobe mode");
4788 if (extra_info->detection_caps) {
4789 camsrc_info(" Facedetection can be supported");
4791 camsrc_info(" Facedetection can't be supported");
4794 camsrc_info("===============================================================");
4795 camsrc_info("leave");
4797 return CAMERASRC_SUCCESS;
4800 static int _camerasrc_query_extra_dev_info(camerasrc_handle_t* handle, camerasrc_extra_info_t* extra_info)
4802 struct v4l2_capability capability;
4804 if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYCAP, &capability)) {
4805 camsrc_info("VIDIOC_QUERYCAP result [0x%08x]", capability.capabilities);
4806 if((capability.capabilities & V4L2_CAP_STROBE) != 0)
4808 /* Strobe supported */
4809 struct v4l2_strobe strobecaps;
4810 if (0 == _camerasrc_ioctl (handle, VIDIOC_G_STROBE, &strobecaps))
4812 extra_info->strobe_caps = strobecaps.capabilities;
4816 camsrc_error("VIDIOC_G_STROBE error");
4817 return CAMERASRC_ERR_IO_CONTROL;
4822 /* Strobe NOT supported */
4823 camsrc_error("STROBE not supported");
4824 extra_info->strobe_caps = 0;
4827 if((capability.capabilities & V4L2_CAP_OBJ_RECOGNITION) != 0)
4829 /* Recognition supported */
4830 extra_info->detection_caps = 1;
4834 camsrc_error("FACEDETECTION not supported");
4835 extra_info->detection_caps = 0;
4836 /* Recognition NOT supported */
4839 return CAMERASRC_SUCCESS;
4841 camsrc_error("VIDIOC_QUERYCAP error");
4843 return CAMERASRC_ERR_IO_CONTROL;
4848 int camerasrc_query_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info)
4850 camerasrc_handle_t* p = NULL;
4851 int err = CAMERASRC_ERR_UNKNOWN;
4853 camsrc_info("enter");
4855 if(handle == NULL) {
4856 camsrc_error("handle is null");
4857 return CAMERASRC_ERR_NULL_POINTER;
4860 p = CAMERASRC_HANDLE(handle);
4862 err = _camerasrc_query_extra_dev_info(p, extra_info);
4864 err = CAMERASRC_SUCCESS;
4865 camsrc_info("leave");
4870 /* END For Query functionalities */