camerasrc/src/camerasrc.c

   1 /*
   2  * camerasrc
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jeongmo Yang <jm80.yang@samsung.com>
   7  *
   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)
  11  * any later version.
  12  *
  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.
  17  *
  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
  21  *
  22  */
  23
  24 #include "camerasrc-common.h"
  25 #include "camerasrc-internal.h"
  26 #include <semaphore.h>
  27
  28 #define BUF_LEN 64
  29 #define ITLV_DATA_INFO_OFFSET   0x1000
  30 #define EMBEDDED_OFFSET         (2040*2+4)
  31
  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 */
  36
  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)
  40 enum scenario_mode {
  41     IS_MODE_PREVIEW_STILL,
  42     IS_MODE_PREVIEW_VIDEO,
  43     IS_MODE_CAPTURE_STILL,
  44     IS_MODE_CAPTURE_VIDEO,
  45     IS_MODE_MAX
  46 };
  47 #endif /* V4L2_CID_IS_S_SCENARIO_MODE */
  48
  49 #ifndef V4L2_CID_EMBEDDEDDATA_ENABLE
  50 #define V4L2_CID_EMBEDDEDDATA_ENABLE            (V4L2_CID_PRIVATE_BASE + 130)
  51 #endif /* V4L2_CID_EMBEDDEDDATA_ENABLE */
  52
  53 /*
  54  * LOCAL DEFINITIONS
  55  */
  56 #ifndef EXPORT_API
  57 #define EXPORT_API __attribute__((__visibility__("default")))
  58 #endif
  59
  60 #define LOCK(p) {\
  61     if(0 != pthread_mutex_lock(&(p->mutex))) {\
  62         camsrc_error("Mutex locking error");\
  63         camsrc_assert(0);\
  64     }\
  65 }
  66
  67 #define UNLOCK(p) {\
  68     if(0 != pthread_mutex_unlock(&(p->mutex))) {\
  69         camsrc_error("Mutex unlocking error");\
  70         camsrc_assert(0);\
  71     }\
  72 }
  73
  74 extern const CAMERASRC_DEV_DEPENDENT_MISC_FUNC *dev_misc_func;
  75
  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);
  89
  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);
  98
  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);
 103
 104
 105 #if 1
 106 typedef struct {
 107         char *key_path;
 108         int   key_prefix;
 109 } camerasrc_sync_param_t;
 110
 111 int camsrc_create_sync(const camerasrc_sync_param_t *param)
 112 {
 113         sem_t *sem = NULL;
 114
 115         sem = sem_open(param->key_path, O_CREAT, 0666, 1);
 116         if (sem == SEM_FAILED) {
 117                 switch (errno) {
 118                 case EACCES:
 119                         camsrc_error("The semaphore already exist, but caller does not have permission %s", param->key_path);
 120                         break;
 121                 case ENOMEM:
 122                         camsrc_error("Insufficient memory");
 123                         break;
 124                 case ENFILE:
 125                         camsrc_error("Too many open files in system");
 126                         break;
 127                 default:
 128                         camsrc_critical("Semaphore create fail! (name:%s, errno %d)", param->key_path, errno);
 129                 }
 130
 131                 return CAMERASRC_ERR_INTERNAL;
 132         }
 133
 134         return CAMERASRC_SUCCESS;
 135 }
 136
 137 int camsrc_remove_sync(const camerasrc_sync_param_t *param)
 138 {
 139         int err = 0;
 140
 141         err = sem_unlink(param->key_path);
 142         if (err == -1) {
 143                 camsrc_critical("Semaphore destroy Fail! (name:%s, errno %d)", param->key_path, errno);
 144                 return CAMERASRC_ERR_INTERNAL;
 145         }
 146
 147         return CAMERASRC_SUCCESS;
 148 }
 149
 150 int camsrc_lock_sync(const camerasrc_sync_param_t *param)
 151 {
 152         sem_t *sem = NULL;
 153         int ret;
 154         int err = CAMERASRC_SUCCESS;
 155         int sem_value = -1;
 156         struct timespec wait_time;
 157
 158         sem = sem_open(param->key_path, O_CREAT, 0666, 1);
 159         if (sem == SEM_FAILED)
 160         {
 161                 camsrc_critical("Semaphore open Fail! (name:%s, errno %d)", param->key_path, errno);
 162                 return CAMERASRC_ERR_INTERNAL;
 163         }
 164
 165 retry_lock:
 166         wait_time.tv_sec = (long int)(time(NULL)) + 6;
 167         wait_time.tv_nsec = 0;
 168
 169         ret = sem_timedwait(sem, &wait_time);
 170         if (ret == -1) {
 171                 switch (errno) {
 172                 case EINTR:
 173                         camsrc_critical("Lock RETRY LOCK");
 174                         goto retry_lock;
 175                         break;
 176                 case EINVAL:
 177                         camsrc_critical("Invalid semaphore");
 178                         err = CAMERASRC_ERR_INTERNAL;
 179                         break;
 180                 case EAGAIN:
 181                         camsrc_critical("EAGAIN");
 182                         err = CAMERASRC_ERR_INTERNAL;
 183                         break;
 184                 case ETIMEDOUT:
 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) {
 190                                         ret = sem_post(sem);
 191                                         if (ret == -1) {
 192                                                 camsrc_critical("sem_post error %s : %d", param->key_path, sem_value);
 193                                         } else {
 194                                                 camsrc_critical("lock recovery success...try lock again");
 195                                                 goto retry_lock;
 196                                         }
 197                                 } else {
 198                                         camsrc_critical("sem value is not 0. but failed sem_timedwait so retry.. : %s",param->key_path);
 199                                         usleep(5);
 200                                         goto retry_lock;
 201                                 }
 202                         } else {
 203                                 camsrc_critical("sem_getvalue failed : %s",param->key_path);
 204                         }
 205                         err = CAMERASRC_ERR_INTERNAL;
 206                         break;
 207                 }
 208         }
 209         sem_close(sem);
 210         return err;
 211 }
 212
 213 int camsrc_unlock_sync(const camerasrc_sync_param_t *param)
 214 {
 215         sem_t *sem = NULL;
 216         int ret;
 217         int err = CAMERASRC_SUCCESS;
 218
 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;
 223         }
 224
 225         ret = sem_post(sem);
 226         if (ret == -1) {
 227                 camsrc_critical("UNLOCK FAIL");
 228                 err = CAMERASRC_ERR_INTERNAL;
 229         }
 230
 231         sem_close(sem);
 232         return err;
 233 }
 234 #endif
 235
 236
 237 #if defined(USE_CAMERASRC_FRAME_DUMP)
 238 #define WRITE_UNIT  4096
 239 static int seq_no = 0;
 240
 241 static void write_buffer_into_path(camerasrc_buffer_t *buffer, char *path, char *name)
 242 {
 243         int fd = -1;
 244         int write_len = 0;
 245         char temp_fn[255];
 246         char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
 247
 248         sprintf(temp_fn, "%s/%s", path, name);
 249
 250         fd = open(temp_fn, O_CREAT | O_WRONLY | O_SYNC);
 251
 252         if(fd == -1) {
 253                 strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
 254                 camsrc_error("OPEN ERR!!!! : %s", err_msg);
 255                 camsrc_assert(0);
 256         } else {
 257                 camsrc_info("Open success, FD = %d, seq = %d", fd, seq_no);
 258         }
 259
 260         int write_remain = buffer->length;
 261         int offset = 0;
 262
 263         while (write_remain > 0) {
 264                 write_len = write(fd, buffer->start + offset, write_remain<WRITE_UNIT?write_remain:WRITE_UNIT);
 265                 if (write_len < 0) {
 266                         strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
 267                         camsrc_error("WRITE ERR!!!! : %s", err_msg);
 268                         camsrc_assert(0);
 269                 } else {
 270                         write_remain -= write_len;
 271                         offset+= write_len;
 272                         camsrc_info("%d written, %d left", write_len, write_remain);
 273                 }
 274         }
 275
 276         close(fd);
 277 }
 278 #endif
 279
 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);
 282
 283
 284 static int _camerasrc_set_cmd(camsrc_handle_t handle, _camsrc_cmd_t cmd, void *value)
 285 {
 286         camerasrc_handle_t *p = NULL;
 287         int err = CAMERASRC_ERR_UNKNOWN;
 288
 289         camsrc_info("enter");
 290
 291         if (handle == NULL) {
 292                 camsrc_error("handle is null");
 293                 return CAMERASRC_ERR_NULL_POINTER;
 294         }
 295
 296         p = CAMERASRC_HANDLE(handle);
 297
 298         if (dev_misc_func->_set_cmd == NULL) {
 299                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
 300         }
 301
 302         err = dev_misc_func->_set_cmd(p, cmd, value);
 303
 304         return err;
 305 }
 306
 307 static int _camerasrc_get_cmd(camsrc_handle_t handle, _camsrc_cmd_t cmd, void *value)
 308 {
 309         camerasrc_handle_t *p = NULL;
 310         int err = CAMERASRC_ERR_UNKNOWN;
 311
 312         if(handle == NULL) {
 313                 camsrc_error("handle is null");
 314                 return CAMERASRC_ERR_NULL_POINTER;
 315         }
 316
 317         p = CAMERASRC_HANDLE(handle);
 318
 319         if(dev_misc_func->_get_cmd == NULL)
 320                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
 321
 322         err = dev_misc_func->_get_cmd(p, cmd, value);
 323
 324         return err;
 325 }
 326
 327
 328 int camerasrc_support_embed_exif(camsrc_handle_t handle, int* support_exif)
 329 {
 330         int err = CAMERASRC_ERR_UNKNOWN;
 331
 332         err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_SUPPORT_EMBED_EXIF, support_exif);
 333         if(err != CAMERASRC_SUCCESS) *support_exif = -1;
 334
 335         return err;
 336 }
 337
 338
 339 int camerasrc_support_jpeg_encoding(camsrc_handle_t handle, int *support_jpeg_encoding)
 340 {
 341         int err = CAMERASRC_ERR_UNKNOWN;
 342
 343         err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_SUPPORT_JPEG_ENCODING, support_jpeg_encoding);
 344         if (err != CAMERASRC_SUCCESS) {
 345                 *support_jpeg_encoding = 0;
 346         }
 347
 348         return err;
 349 }
 350
 351
 352 int camerasrc_get_screennail_buffer(camsrc_handle_t handle, camerasrc_buffer_t *scrnl_buf)
 353 {
 354         camerasrc_handle_t *p = NULL;
 355
 356         if (handle == NULL) {
 357                 camsrc_error("handle is null");
 358                 return CAMERASRC_ERR_NULL_POINTER;
 359         }
 360
 361         if (scrnl_buf == NULL) {
 362                 camsrc_error("scrnl_buf is null");
 363                 return CAMERASRC_ERR_INVALID_PARAMETER;
 364         }
 365
 366         p = CAMERASRC_HANDLE(handle);
 367
 368         scrnl_buf->start = p->scrnl_buf.start;
 369         scrnl_buf->length = p->scrnl_buf.length;
 370
 371         camsrc_info("screennail ptr[%p],length[%d]", scrnl_buf->start, scrnl_buf->length);
 372
 373         return CAMERASRC_SUCCESS;
 374 }
 375
 376
 377 int camerasrc_start_facedetection(camsrc_handle_t handle)
 378 {
 379         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_FACEDETECTION, _CAMERASRC_FACEDETECTION_START);
 380 }
 381
 382
 383 int camerasrc_stop_facedetection(camsrc_handle_t handle)
 384 {
 385         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_FACEDETECTION, _CAMERASRC_FACEDETECTION_STOP);
 386 }
 387
 388
 389 int camerasrc_get_facedetection(camsrc_handle_t handle, int *is_detecting)
 390 {
 391         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_FACEDETECTION, is_detecting);
 392 }
 393
 394
 395 int camerasrc_set_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t frac)
 396 {
 397         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_SHUTTER_SPEED, &frac);
 398 }
 399
 400
 401 int camerasrc_get_shutter_speed(camsrc_handle_t handle, camerasrc_frac_t *frac)
 402 {
 403         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_SHUTTER_SPEED, frac);
 404 }
 405
 406
 407 int camerasrc_set_exposure_value(camsrc_handle_t handle, camerasrc_frac_t frac)
 408 {
 409         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_EXPOSURE_VALUE, &frac);
 410 }
 411
 412
 413 int camerasrc_get_exposure_value(camsrc_handle_t handle, camerasrc_frac_t *frac)
 414 {
 415         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_EXPOSURE_VALUE, frac);
 416 }
 417
 418
 419 int camerasrc_set_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t mode)
 420 {
 421         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_STROBE_MODE, &mode);
 422 }
 423
 424
 425 int camerasrc_get_strobe_mode(camsrc_handle_t handle, camerasrc_strobe_mode_t *mode)
 426 {
 427         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_STROBE_MODE, mode);
 428 }
 429
 430
 431 int camerasrc_set_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int value)
 432 {
 433         _camerasrc_ctrl_t ctrl;
 434
 435         CLEAR(ctrl);
 436
 437         ctrl.cid = ctrl_id;
 438         ctrl.value = value;
 439
 440         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_CTRL, &ctrl);
 441 }
 442
 443
 444 int camerasrc_get_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, int *value)
 445 {
 446         int err = CAMERASRC_ERR_UNKNOWN;
 447         _camerasrc_ctrl_t ctrl;
 448
 449         CLEAR(ctrl);
 450
 451         ctrl.cid = ctrl_id;
 452
 453         err = CAMERASRC_GET_CMD(_CAMERASRC_CMD_CTRL, &ctrl);
 454         if (err != CAMERASRC_SUCCESS) {
 455                 return err;
 456         }
 457
 458         *value = ctrl.value;
 459
 460         return err;
 461 }
 462
 463
 464 int camerasrc_query_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t *ctrl_info)
 465 {
 466         struct v4l2_queryctrl queryctrl;
 467
 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;
 471         }
 472
 473         CLEAR(queryctrl);
 474
 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;
 479         }
 480
 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);
 484                 }
 485
 486                 ctrl_info->v4l2_ctrl_id = queryctrl.id;
 487                 ctrl_info->camsrc_ctrl_id = ctrl_id;
 488
 489                 switch (queryctrl.type) {
 490                 case V4L2_CTRL_TYPE_INTEGER:
 491                         ctrl_info->ctrl_type = CTRL_TYPE_RANGE;
 492                         break;
 493                 case V4L2_CTRL_TYPE_BOOLEAN:
 494                         ctrl_info->ctrl_type = CTRL_TYPE_BOOL;
 495                         break;
 496                 case V4L2_CTRL_TYPE_MENU:
 497                         ctrl_info->ctrl_type = CTRL_TYPE_ARRAY;
 498                         _camerasrc_query_ctrl_menu (handle, queryctrl, ctrl_info);
 499                         break;
 500                 default:
 501                         ctrl_info->ctrl_type = CTRL_TYPE_UNKNOWN;
 502                         break;
 503                 }
 504
 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;
 510
 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);
 515         } else {
 516                 camsrc_error("VIDIOC_QUERYCTRL error");
 517
 518                 return CAMERASRC_ERR_IO_CONTROL;
 519         }
 520
 521         return CAMERASRC_SUCCESS;
 522 }
 523
 524
 525 int camerasrc_support_control(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id)
 526 {
 527         return CAMERASRC_SUCCESS;
 528 }
 529
 530
 531 int _camerasrc_get_JPG_length(camerasrc_handle_t *handle)
 532 {
 533         int jpg_length;
 534
 535         CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_LENGTH, &jpg_length);
 536
 537         return jpg_length;
 538 }
 539
 540
 541 int _camerasrc_get_thumbnail_JPG_length(camerasrc_handle_t *handle)
 542 {
 543         int jpg_length;
 544
 545         CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_LENGTH, &jpg_length);
 546
 547         return jpg_length;
 548 }
 549
 550
 551 int _camerasrc_get_thumbnail_JPG_offset(camerasrc_handle_t *handle)
 552 {
 553         int thumb_offset;
 554
 555         CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_OFFSET, &thumb_offset);
 556
 557         return thumb_offset;
 558 }
 559
 560
 561 int _camerasrc_get_screennail_JPG_length(camerasrc_handle_t *handle)
 562 {
 563         int length;
 564
 565         CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_SCRNL_LENGTH, &length);
 566
 567         return length;
 568 }
 569
 570
 571 int _camerasrc_get_screennail_JPG_offset(camerasrc_handle_t *handle)
 572 {
 573         int offset;
 574
 575         CAMERASRC_GET_CMD(_CAMERASRC_CMD_JPEG_SCRNL_OFFSET, &offset);
 576
 577         return offset;
 578 }
 579
 580
 581 int _camerasrc_set_thumbnail_size(camerasrc_handle_t *handle)
 582 {
 583         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_JPEG_THMBNL_LENGTH, NULL);
 584 }
 585
 586
 587 int _camerasrc_check_emp_shock(camerasrc_handle_t *handle, int *check_val)
 588 {
 589         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_ESD_CHECK, check_val);
 590 }
 591
 592
 593 int _camerasrc_set_jpeg_compress_ratio(camerasrc_handle_t *handle, unsigned int quality)
 594 {
 595         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_JPEG_COMPRESS_RATIO, &quality);
 596 }
 597
 598
 599 int _camerasrc_ioctl(camerasrc_handle_t *handle, int request, void *arg)
 600 {
 601         if (dev_misc_func->_ioctl == NULL) {
 602 #if USE_NOT_SUPPORT_ERR
 603                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
 604 #else
 605                 return CAMERASRC_SUCCESS;
 606 #endif
 607         }
 608
 609         return dev_misc_func->_ioctl(handle, request, arg);
 610 }
 611
 612
 613 int _camerasrc_ioctl_once(camerasrc_handle_t *handle, int request, void *arg)
 614 {
 615         if (dev_misc_func->_ioctl_once == NULL) {
 616 #if USE_NOT_SUPPORT_ERR
 617                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
 618 #else
 619                 return CAMERASRC_SUCCESS;
 620 #endif
 621         }
 622
 623         return dev_misc_func->_ioctl_once(handle, request, arg);
 624 }
 625
 626
 627 void *_camerasrc_run_autofocusing(camerasrc_handle_t *handle)
 628 {
 629         if (dev_misc_func->_run_autofocusing != NULL) {
 630                 dev_misc_func->_run_autofocusing(handle);
 631         }
 632
 633         return NULL;
 634 }
 635
 636
 637 int _camerasrc_skip_frame(camerasrc_handle_t *handle, long int timeout, int skip_frame)
 638 {
 639         if (dev_misc_func->_skip_frame == NULL) {
 640 #if USE_NOT_SUPPORT_ERR
 641                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
 642 #else
 643                 return CAMERASRC_SUCCESS;
 644 #endif
 645         }
 646
 647         return dev_misc_func->_skip_frame(handle, timeout, skip_frame);
 648 }
 649
 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)
 652 {
 653         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_AREA, rect);
 654 }
 655
 656 int _camerasrc_get_autofocusing_area(camerasrc_handle_t *handle, camerasrc_rect_t *rect)
 657 {
 658         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_AF_AREA, rect);
 659 }
 660
 661 int _camerasrc_start_autofocusing(camerasrc_handle_t *handle)
 662 {
 663         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_START);
 664 }
 665
 666 int _camerasrc_stop_autofocusing(camerasrc_handle_t *handle)
 667 {
 668         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_STOP);
 669 }
 670
 671 int _camerasrc_release_autofocusing(camerasrc_handle_t *handle)
 672 {
 673         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_RELEASE);
 674 }
 675
 676 int _camerasrc_destroy_autofocusing(camerasrc_handle_t *handle)
 677 {
 678         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_DESTROY);
 679 }
 680
 681 int _camerasrc_init_autofocusing_mode(camerasrc_handle_t *handle)
 682 {
 683         return CAMERASRC_SET_CMD(_CAMERASRC_CMD_AF_CONTROL, _CAMERASRC_AF_INIT);
 684 }
 685
 686
 687 int _camerasrc_get_frame_data(camerasrc_handle_t *handle, camerasrc_frame_data_t *data)
 688 {
 689         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_FRAME_DATA, data);
 690 }
 691
 692 int _camerasrc_get_exif_info(camerasrc_handle_t *handle, camerasrc_buffer_t *exif_string)
 693 {
 694         return CAMERASRC_GET_CMD(_CAMERASRC_CMD_EXIF_INFO, exif_string);
 695 }
 696
 697
 698 int _camerasrc_copy_frame(camerasrc_handle_t *handle, camerasrc_buffer_t *src_buffer, camerasrc_buffer_t *dst_buffer, int isThumbnail)
 699 {
 700         if (dev_misc_func->_copy_frame == NULL) {
 701 #if USE_NOT_SUPPORT_ERR
 702                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
 703 #else
 704                 return CAMERASRC_SUCCESS;
 705 #endif
 706         }
 707
 708         return dev_misc_func->_copy_frame(handle, src_buffer, dst_buffer, isThumbnail);
 709 }
 710
 711
 712
 713 static int _camerasrc_chk_opened(char *conf_filename)
 714 {
 715         camsrc_info("enter");
 716
 717         char buf[CAMERASRC_MAX_FILENAME_LEN] = {'\0',};
 718         char proc_buf[CAMERASRC_MAX_FILENAME_LEN] = {'\0',};
 719         int fd = -1;
 720         int len = 0;
 721         int buf_len = 0;
 722         int pid = 0;
 723         char access[9];
 724         int err_fd = -1;
 725         int err = CAMERASRC_SUCCESS;
 726
 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;
 734         } else {
 735                 camsrc_info("Dev has been opened. start check...");
 736         }
 737
 738         len = read(fd, buf, CAMERASRC_MAX_FILENAME_LEN);
 739         sscanf(buf, "%2d:%5d:%64s", &buf_len, &pid, access);
 740
 741         camsrc_info("%d : %d : %s", buf_len, pid, access);
 742         if (buf_len == 0) {
 743                 camsrc_info("Wrong written check file!");
 744                 close(fd);
 745
 746                 return CAMERASRC_ERR_INTERNAL;
 747         }
 748
 749         if (!strcmp(access, CAMERASRC_DEV_RELEASED_STR)) {
 750                 camsrc_info("Has opened but closed properly!");
 751                 close(fd);
 752
 753                 return CAMERASRC_SUCCESS;
 754         }
 755
 756         if (pid == getpid()) {
 757                 camsrc_info("Double open!! You can't go. Investigate the PID's FD list");
 758                 close(fd);
 759
 760                 return CAMERASRC_ERR_DEVICE_BUSY;
 761         }
 762
 763         snprintf(proc_buf, CAMERASRC_MAX_FILENAME_LEN, "/proc/%d", pid);
 764         err_fd = open(proc_buf, O_RDONLY | O_NONBLOCK, 0);
 765         if (err_fd == -1) {
 766                 camsrc_info("The proc node [%s] are not exist it's fake node", proc_buf);
 767                 err = CAMERASRC_SUCCESS;
 768         } else {
 769                 camsrc_info("The proc node [%s] are loaded. almost opened...", proc_buf);
 770                 close(err_fd);
 771
 772                 err = CAMERASRC_ERR_DEVICE_BUSY;
 773         }
 774
 775         close(fd);
 776
 777         return err;
 778 }
 779
 780
 781 static int __camerasrc_open_device(camerasrc_handle_t *p)
 782 {
 783         #define MAX_DEVICE_COUNT 4
 784
 785         int i = 0;
 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;
 790
 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);
 794
 795                 p->dev_fd = open(device_name, O_RDWR | O_NONBLOCK, 0);
 796                 if (p->dev_fd < 0) {
 797                         /* open failed */
 798                         strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
 799                         camsrc_error("Device open fail [%d][%s]", errno, err_msg);
 800
 801                         switch (errno) {
 802                         case EBUSY:
 803                                 ret = CAMERASRC_ERR_DEVICE_BUSY;
 804                                 break;
 805                         case ENOENT:
 806                         case ENODEV:
 807                                 ret = CAMERASRC_ERR_DEVICE_NOT_FOUND;
 808                                 break;
 809                         default:
 810                                 ret = CAMERASRC_ERR_DEVICE_OPEN;
 811                                 break;
 812                         }
 813
 814                         break;
 815                 } else {
 816                         int ioctl_ret = 0;
 817
 818                         camsrc_info("opened device fd %d", p->dev_fd);
 819
 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;
 828                                 }
 829                         } else {
 830                                 camsrc_warning("VIDIOC_QUERYCAP error %x", ioctl_ret);
 831                         }
 832
 833                         close(p->dev_fd);
 834                         p->dev_fd = -1;
 835                 }
 836         }
 837
 838         camsrc_error("failed to find capture device %x", ret);
 839
 840         return ret;
 841 }
 842
 843 static int _camerasrc_seamless_record_onaccess_open(char *conf_filename, camerasrc_handle_t *p)
 844 {
 845         camsrc_info("enter");
 846
 847         int fd = -1;
 848         int len = 0;
 849         int ret = CAMERASRC_SUCCESS;
 850         char buf[BUF_LEN];
 851         char tot_buf[BUF_LEN];
 852         camerasrc_sync_param_t syncparam = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX};
 853
 854         camsrc_lock_sync(&syncparam);
 855
 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);
 861                         return ret;
 862                 }
 863
 864                 p->is_async_open = 0;
 865         } else {
 866                 p->is_async_open = 1;
 867         }
 868
 869         /* Write open status */
 870         fd = open(conf_filename, O_RDWR | O_NONBLOCK | O_CREAT, 0666);
 871         if (fd == -1) {
 872                 camsrc_info("failed to open ", conf_filename);
 873                 /* Release camera device */
 874                 close(p->dev_fd);
 875                 p->dev_fd = -1;
 876                 return CAMERASRC_ERR_INTERNAL;
 877         }
 878
 879         /**
 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
 885          */
 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);
 888         tot_buf[len] = '\0';
 889         len = write(fd, tot_buf, len+1);
 890
 891         close(fd);
 892         fd = -1;
 893
 894         camsrc_unlock_sync(&syncparam);
 895
 896         return CAMERASRC_SUCCESS;
 897 }
 898
 899
 900 static int _camerasrc_seamless_delete_onaccess(char *conf_filename, camerasrc_handle_t *p)
 901 {
 902         camsrc_info("enter");
 903
 904         int fd = p->dev_fd;
 905         int chk_fd = 0;
 906         int len = 0;
 907         int err = CAMERASRC_ERR_UNKNOWN;
 908         char buf[BUF_LEN];
 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',};
 912
 913         camsrc_info("Start delete...");
 914
 915         /* TODO : Semaphore lock */
 916         camsrc_lock_sync(&param);
 917
 918         if (!(p->is_async_open)) {
 919                 close(fd);
 920         }
 921
 922         chk_fd = open(conf_filename, O_WRONLY | O_NONBLOCK);
 923         if (chk_fd == -1) {
 924                 camsrc_info("FD = %d", fd);
 925                 return CAMERASRC_ERR_INTERNAL;
 926         }
 927
 928         len = snprintf(buf, BUF_LEN, "%d:%s", getpid(), CAMERASRC_DEV_RELEASED_STR);
 929         camsrc_info("using string : %s", buf);
 930
 931         len = snprintf(tot_buf, BUF_LEN, "%d:%s", len, buf);
 932         camsrc_info("write string final : %s", tot_buf);
 933
 934         len = write(chk_fd, tot_buf, len);
 935         if (len == -1) {
 936                 strerror_r(errno, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
 937                 camsrc_info("WRITE ERROR!!!!, error = %s, fd = %d", err_msg, chk_fd);
 938         }
 939
 940         close(chk_fd);
 941
 942         camsrc_unlock_sync(&param);
 943         /* TODO : Semaphore unlock */
 944         err = CAMERASRC_SUCCESS;
 945         camsrc_info("End delete...");
 946
 947         return err;
 948 }
 949
 950
 951 static int _camerasrc_initialize_handle(camerasrc_handle_t *handle)
 952 {
 953         camsrc_info("enter");
 954
 955         if (handle == NULL) {
 956                 camsrc_error("handle is null");
 957                 return CAMERASRC_ERR_NULL_POINTER;
 958         }
 959
 960         /* Initialize handle variables */
 961         handle->buffer = NULL;
 962         handle->is_async_open = 0;
 963         handle->dev_fd = -1;
 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;
 984
 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");
 989         }
 990
 991         CLEAR(handle->queued_buf_list);
 992         CLEAR(handle->format);
 993
 994         return CAMERASRC_SUCCESS;
 995 }
 996
 997
 998 static int _camerasrc_wait_frame_available(camerasrc_handle_t *handle, long int timeout)
 999 {
1000         camerasrc_handle_t *p = handle;
1001         fd_set fds;
1002         struct timeval tv;
1003         int r;
1004
1005 #if defined (USE_SKIP_FRAME)
1006         int skip_frame = CAMERASRC_JPG_STILL_SKIP_FRAME;
1007 #endif
1008
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 */
1013                 } else {
1014                         usleep((int)(1000000 * p->timeperframe.numerator / p->timeperframe.denominator));
1015                 }
1016
1017                 camsrc_info("Device emergency closed. wait will return proper time");
1018
1019                 return CAMERASRC_SUCCESS;
1020         }
1021
1022         /**
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()
1025          */
1026
1027         FD_ZERO(&fds);
1028         FD_SET(p->dev_fd, &fds);
1029
1030         /* skip frame */
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);
1035         }
1036 #endif
1037
1038         /* set timeout */
1039         tv.tv_sec = (long int)timeout/1000;
1040         tv.tv_usec = timeout * 1000 - tv.tv_sec * 1000000;
1041
1042         /* select waiting */
1043         r = select(p->dev_fd + 1, &fds, NULL, NULL, &tv);
1044         if (-1 == r) {
1045                 if (EINTR == errno) {
1046                         return CAMERASRC_SUCCESS;
1047                 }
1048                 camsrc_error("select() failed.");
1049
1050                 return CAMERASRC_ERR_INTERNAL;
1051         }
1052
1053         if (0 == r) {
1054                 return CAMERASRC_ERR_DEVICE_WAIT_TIMEOUT;
1055         }
1056
1057         return CAMERASRC_SUCCESS;
1058 }
1059
1060
1061 struct v4l2_buffer *_camerasrc_get_correct_buf(camerasrc_handle_t *handle, struct v4l2_buffer *queued_buf_list, camerasrc_buffer_t *buffer)
1062 {
1063         unsigned int num_buffers = 0;
1064         int cnt = 0;
1065         camerasrc_get_num_buffer(handle, &num_buffers);
1066
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]);
1070                 }
1071         }
1072
1073         return NULL;
1074 }
1075
1076
1077 static int _camerasrc_queue_buffer(camerasrc_handle_t *handle, int buf_index, camerasrc_buffer_t *buffer)
1078 {
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',};
1083
1084         if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) {
1085                 camsrc_info("Device emergency closed. Q will return successfully");
1086                 return CAMERASRC_SUCCESS;
1087         }
1088
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;
1092         }
1093
1094         CLEAR(vbuf);
1095
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;
1101                 }
1102
1103                 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1104                 vbuf.memory = V4L2_MEMORY_MMAP;
1105                 vbuf.index = buf_index;
1106                 pvbuf = &vbuf;
1107                 break;
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);
1111                 }
1112
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]);
1116                 }
1117                 break;
1118         case CAMERASRC_IO_METHOD_READ:
1119         default:
1120                 camsrc_error("Device not support that io-method");
1121 #if USE_NOT_SUPPORT_ERR
1122                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1123 #else
1124                 return CAMERASRC_SUCCESS;
1125 #endif
1126         }
1127
1128         if (CAMERASRC_STATE(handle) == CAMERASRC_STATE_READY) {
1129                 camsrc_warning("Q after ready state will success");
1130                 return CAMERASRC_SUCCESS;
1131         }
1132
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;
1137         }
1138
1139         LOCK(p);
1140         if (p->io_method == CAMERASRC_IO_METHOD_MMAP) {
1141                 p->buffer[buf_index].queued_status = CAMERASRC_BUFFER_QUEUED;
1142                 p->queued_buffer_count++;
1143         }
1144         UNLOCK(p);
1145
1146         return CAMERASRC_SUCCESS;
1147 }
1148
1149
1150 static int _camerasrc_get_proper_index(camerasrc_handle_t *handle, void *data)
1151 {
1152         int i = 0;
1153
1154         for (i = 0; i < handle->num_buffers; i++) {
1155                 if (handle->buffer[i].start == data) {
1156                         return i;
1157                 }
1158         }
1159
1160         camsrc_info("Index NOT found. new buffer... go to error");
1161
1162         return -1;
1163 }
1164
1165
1166 static int _camerasrc_dequeue_buffer(camerasrc_handle_t *handle, int *buf_index, camerasrc_buffer_t *buffer, camerasrc_buffer_t *thm_buffer)
1167 {
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',};
1172
1173         if (p->dev_fd == CAMERASRC_DEV_FD_EMERGENCY_CLOSED) {
1174                 buf_index = 0;
1175                 buffer = &p->alter_frame;
1176                 buffer = NULL;
1177                 camsrc_info("Device emergency closed. DQ return fake frame");
1178                 return CAMERASRC_SUCCESS;
1179         }
1180
1181         switch(p->io_method) {
1182         case CAMERASRC_IO_METHOD_MMAP:
1183                 CLEAR(vbuf);
1184                 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1185                 vbuf.memory = V4L2_MEMORY_MMAP;
1186                 break;
1187         case CAMERASRC_IO_METHOD_USRPTR:
1188                 CLEAR(vbuf);
1189                 vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1190                 vbuf.memory = V4L2_MEMORY_USERPTR;
1191                 break;
1192         case CAMERASRC_IO_METHOD_READ:
1193         default:
1194                 camsrc_error("Device not support that io-method");
1195 #if USE_NOT_SUPPORT_ERR
1196                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1197 #else
1198                 return CAMERASRC_SUCCESS;
1199 #endif
1200         }
1201
1202         if (CAMERASRC_SUCCESS != _camerasrc_ioctl(p, VIDIOC_DQBUF, &vbuf)) {
1203                 switch (p->errnum) {
1204                 case EAGAIN:
1205                         camsrc_info("VIDIOC_DQBUF [EAGAIN]");
1206                         return CAMERASRC_SUCCESS;
1207                 case EIO:
1208                         /* Could ignore EIO, see spec. */
1209                         /* fall through */
1210                         camsrc_info("VIDIOC_DQBUF [EIO]");
1211                         break;
1212                 case EINVAL:
1213                         camsrc_info("VIDIOC_DQBUF [EINVAL]");
1214                         printf("VIDIOC_DQBUF [EINVAL]");
1215                         return CAMERASRC_ERR_INVALID_VALUE;
1216                 default:
1217                         strerror_r(p->errnum, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1218                         camsrc_info("VIDIOC_DQBUF [%s]", err_msg);
1219                         break;
1220                 }
1221         }
1222
1223         /* A F   I N I T */
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");
1231                         } else {
1232                                 p->af_init_called = 1;
1233                         }
1234                 } else {
1235                         camsrc_info("AF init SKIP!");
1236                 }
1237
1238                 p->first_frame = 0;
1239         }
1240
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;
1248                         LOCK(p);
1249                         p->buffer[vbuf.index].queued_status = CAMERASRC_BUFFER_DEQUEUED;
1250                         p->queued_buffer_count--;
1251                         UNLOCK(p);
1252 #if 1
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);
1259                                 break;
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);
1265                                 break;
1266                         case CAMERASRC_PIX_INTERLEAVED:
1267                         {
1268                                 unsigned char *p_size_info = NULL;
1269 #if 0
1270                                 if (vbuf.index == 2) {
1271                                         FILE *fp = fopen("./test2.dump", "w+");
1272                                         fwrite(buffer->start, p->buffer[vbuf.index].length, 1, fp);
1273                                         fflush(fp);
1274                                         fclose(fp);
1275                                 }
1276 #endif
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);
1281                                 break;
1282                         }
1283                         case CAMERASRC_PIX_RGGB10:
1284                         case CAMERASRC_PIX_RGGB8:
1285                         default:
1286                                 buffer->length = -1;
1287                                 break;
1288                         }
1289 #else
1290                         buffer->length = vbuf.bytesused;
1291 #endif
1292                         break;
1293                 case CAMERASRC_IO_METHOD_USRPTR:
1294                 {
1295                         int i = 0;
1296                         int dequeued = 0;
1297
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);
1304 #endif
1305                                 if (vbuf.m.userptr == (unsigned long) p->buffer[i].start) {
1306                                         dequeued = 1;
1307                                         break;
1308                                 }
1309                         }
1310
1311                         if (!dequeued) {
1312                                 camsrc_error("Dequeued buffer not matched to user ptr!");
1313                                 return CAMERASRC_ERR_IO_CONTROL;
1314                         }
1315
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;
1319
1320                         break;
1321                 }
1322                 case CAMERASRC_IO_METHOD_READ:
1323                 default:
1324                         camsrc_error("Device not support that io-method");
1325 #if USE_NOT_SUPPORT_ERR
1326                         return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1327 #else
1328                         return CAMERASRC_SUCCESS;
1329 #endif
1330                         break;
1331                 }
1332         } else if (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL && p->format.colorspace == CAMERASRC_COL_JPEG) {
1333                 /* JPEG Capture */
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);
1340                         LOCK(p);
1341                         p->buffer[vbuf.index].queued_status = CAMERASRC_BUFFER_DEQUEUED;
1342                         p->queued_buffer_count--;
1343                         UNLOCK(p);
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);
1351                                 }
1352                                 else if(p->format.pix_format == CAMERASRC_PIX_RGGB8) {
1353                                         unsigned int thumb_offset = 0, thumb_length = 0;
1354
1355                                         thumb_offset = _camerasrc_get_thumbnail_JPG_offset(p);
1356                                         thumb_length = _camerasrc_get_thumbnail_JPG_length(p);
1357
1358                                         if( thumb_offset == 0 || thumb_length == 0 )
1359                                         {
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);
1363                                         }
1364                                         else
1365                                         {
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);
1369                                         }
1370                                 }
1371                                 else {
1372                                         camsrc_error("Unknown image format... ");
1373 #if USE_NOT_SUPPORT_ERR
1374                                         return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1375 #else
1376                                         return CAMERASRC_SUCCESS;
1377 #endif
1378                                 }
1379                         }
1380
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);
1384
1385                         /**
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
1389                          */
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;
1394                         }
1395
1396                         break;
1397                 case CAMERASRC_IO_METHOD_USRPTR:
1398                 {
1399                         int i = 0;
1400                         int dequeued = 0;
1401
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);
1408 #endif
1409                                 if (vbuf.m.userptr == (unsigned long) p->buffer[i].start) {
1410                                         dequeued = 1;
1411                                         break;
1412                                 }
1413                         }
1414
1415                         if (!dequeued) {
1416                                 camsrc_error("Dequeued buffer not matched to user ptr!");
1417                                 return CAMERASRC_ERR_IO_CONTROL;
1418                         }
1419
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;
1426                         }
1427                         camsrc_info("JPEG frame length = %d", buffer->length);
1428
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;
1441                                         }
1442                                         camsrc_info("Thumbnail JPEG frame length = %d", thm_buffer->length);
1443                                 } else {
1444                                         camsrc_error("Unknown image format... ");
1445 #if USE_NOT_SUPPORT_ERR
1446                                         return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1447 #else
1448                                         return CAMERASRC_SUCCESS;
1449 #endif
1450                                 }
1451                         }
1452                         break;
1453                 }
1454                 case CAMERASRC_IO_METHOD_READ:
1455                 default:
1456                         camsrc_error("Device not support that io-method");
1457 #if USE_NOT_SUPPORT_ERR
1458                         return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1459 #else
1460                         return CAMERASRC_SUCCESS;
1461 #endif
1462                         break;
1463                 }
1464         } else {
1465                 camsrc_error("Invalid state transition");
1466                 return CAMERASRC_ERR_INVALID_STATE;
1467         }
1468
1469         return CAMERASRC_SUCCESS;
1470 }
1471
1472 static int _camerasrc_dump_format(camsrc_handle_t handle);
1473
1474 /**** M A I N    O P E R A T I O N ****/
1475 int camerasrc_create(camsrc_handle_t *phandle)
1476 {
1477         camerasrc_handle_t *p = NULL;
1478         int err = CAMERASRC_ERR_UNKNOWN;
1479         char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1480
1481         camsrc_info("enter");
1482
1483         if (phandle == NULL) {
1484                 camsrc_error("handle is null");
1485                 return CAMERASRC_ERR_NULL_POINTER;
1486         }
1487
1488         p = (camerasrc_handle_t *)malloc(sizeof(camerasrc_handle_t));
1489         if(p == NULL) {
1490                 camsrc_error("malloc fail");
1491                 return CAMERASRC_ERR_ALLOCATION;
1492         }
1493
1494         memset(p, '\0', sizeof(camerasrc_handle_t));
1495
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");
1501
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;
1507         }
1508
1509         err = pthread_mutex_init(&(p->mutex), NULL);
1510         if(err) {
1511                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1512                 camsrc_info("Mutex creating status : %s", err_msg);
1513         }
1514
1515         err = pthread_mutex_init(&(p->af_mutex), NULL);
1516         if(err) {
1517                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1518                 camsrc_info("AF Mutex creating status : %s", err_msg);
1519         }
1520
1521         err = pthread_cond_init(&(p->af_wait_cond), NULL);
1522         if(err) {
1523                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1524                 camsrc_info("AF Condition creating status : %s", err_msg);
1525         }
1526
1527         camsrc_info("Thread creation start..");
1528         err = pthread_create(&p->focusing_thread, NULL, (void*)_camerasrc_run_autofocusing, p);
1529         if(err) {
1530                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1531                 camsrc_info("AF Thread creating status : %s", err_msg);
1532         }
1533
1534         camsrc_info("Thread creation end..");
1535
1536         *phandle = (camsrc_handle_t)p;
1537         err = CAMERASRC_SUCCESS;
1538         return err;
1539 }
1540
1541
1542 int camerasrc_destroy(camsrc_handle_t handle)
1543 {
1544         camerasrc_handle_t* p = NULL;
1545         int err = CAMERASRC_ERR_UNKNOWN;
1546         char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1547
1548         camsrc_info("enter");
1549
1550         if(handle == NULL) {
1551                 camsrc_error("handle is null");
1552                 return CAMERASRC_ERR_NULL_POINTER;
1553         }
1554
1555         p = CAMERASRC_HANDLE(handle);
1556
1557         if(CAMERASRC_STATE(p) != CAMERASRC_STATE_UNREALIZED) {
1558                 camsrc_warning("Invalid state transition");
1559         }
1560
1561         /* Remove AF thread */
1562         _camerasrc_destroy_autofocusing(p);
1563
1564         camsrc_info("Thread join wait start..");
1565         err = pthread_join(p->focusing_thread, NULL);
1566         if(err) {
1567                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1568                 camsrc_info("AF Thread join status : %s", err_msg);
1569         }
1570
1571         camsrc_info("Thread join wait end..");
1572
1573         err = pthread_cond_destroy(&p->af_wait_cond);
1574         if(err) {
1575                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1576                 camsrc_info("AF Condition destroying error : %s", err_msg);
1577         }
1578
1579         err = pthread_mutex_destroy(&(p->af_mutex));
1580         if(err) {
1581                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1582                 camsrc_info("AF Mutex destroying error : %s", err_msg);
1583         }
1584
1585         err = pthread_mutex_destroy(&(p->mutex));
1586         if(err) {
1587                 strerror_r(err, err_msg, CAMERASRC_ERRMSG_MAX_LEN);
1588                 camsrc_info("Mutex destroying error : %s", err_msg);
1589         }
1590
1591         free((void*)p);
1592         handle = NULL;
1593         err = CAMERASRC_SUCCESS;
1594         return err;
1595 }
1596
1597
1598 int camerasrc_close_device(camsrc_handle_t handle)
1599 {
1600         camerasrc_handle_t* p = NULL;
1601         int err = CAMERASRC_ERR_UNKNOWN;
1602
1603         camsrc_info("enter");
1604
1605         if(handle == NULL) {
1606                 camsrc_error("handle is null");
1607                 return CAMERASRC_ERR_NULL_POINTER;
1608         }
1609
1610         p = CAMERASRC_HANDLE(handle);
1611
1612         p->is_async_open = 0;
1613
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;
1619                 }
1620                 p->dev_fd = CAMERASRC_DEV_FD_EMERGENCY_CLOSED;
1621         }
1622 #else
1623         if(!CAMERASRC_IS_DEV_CLOSED(p)) {
1624
1625                 if( !(p->is_async_open) ) {
1626                         close(p->dev_fd);
1627                 }
1628
1629                 p->dev_fd = CAMERASRC_DEV_FD_EMERGENCY_CLOSED;
1630         }
1631         /* prepare "Kagemusha" frame data */
1632         LOCK(p);
1633         memcpy(p->alter_frame.start, p->buffer[0].start, p->alter_frame.length);
1634         UNLOCK(p);
1635 #endif
1636         return CAMERASRC_SUCCESS;
1637 }
1638
1639
1640 int camerasrc_get_state(camsrc_handle_t handle, camerasrc_state_t* state)
1641 {
1642         camerasrc_handle_t* p = NULL;
1643
1644         if(handle == NULL) {
1645                 camsrc_error("handle is null");
1646                 return CAMERASRC_ERR_NULL_POINTER;
1647         }
1648
1649         p = CAMERASRC_HANDLE(handle);
1650
1651         *state = CAMERASRC_STATE(p);
1652         return CAMERASRC_SUCCESS;
1653 }
1654
1655
1656 int camerasrc_realize(camsrc_handle_t handle)
1657 {
1658         camerasrc_handle_t* p = NULL;
1659         int ret = CAMERASRC_SUCCESS;
1660
1661         camerasrc_sync_param_t param = {CAMERASRC_SYNC_KEY_PATH, CAMERASRC_SYNC_KEY_PREFIX};
1662         mode_t mask = 0;
1663
1664         camsrc_info("enter");
1665
1666         if(handle == NULL) {
1667                 camsrc_error("handle is null");
1668                 return CAMERASRC_ERR_NULL_POINTER;
1669         }
1670
1671         p = CAMERASRC_HANDLE(handle);
1672
1673         /* STATE OR PHASE CHECKING */
1674         if(CAMERASRC_STATE(p) == CAMERASRC_STATE_REALIZED) {
1675                 return CAMERASRC_SUCCESS;
1676         }
1677         if(CAMERASRC_STATE(p) != CAMERASRC_STATE_CREATED &&
1678            CAMERASRC_STATE(p) != CAMERASRC_STATE_UNREALIZED) {
1679                 camsrc_warning("Invalid state transition");
1680         }
1681
1682         mask = umask(0);
1683
1684         /* CREATE SEMAPHORE */
1685         camsrc_create_sync(&param);
1686
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);
1694                 }
1695         }
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);
1701                 } else {
1702                         p->is_async_open = 0;
1703                 }
1704         } else {
1705                 p->is_async_open = 1;
1706         }
1707 #endif /* USE_OPEN_CHK */
1708
1709         umask(mask);
1710
1711         if (ret == CAMERASRC_SUCCESS) {
1712                 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_REALIZED);
1713         }
1714
1715         return ret;
1716 }
1717
1718
1719 int camerasrc_unrealize(camsrc_handle_t handle)
1720 {
1721         camerasrc_handle_t* p = NULL;
1722         int err = CAMERASRC_ERR_UNKNOWN;
1723
1724         camsrc_info("enter");
1725
1726         if(handle == NULL) {
1727                 camsrc_error("handle is null");
1728                 return CAMERASRC_ERR_NULL_POINTER;
1729         }
1730
1731         p = CAMERASRC_HANDLE(handle);
1732
1733         if(CAMERASRC_STATE(p) == CAMERASRC_STATE_UNREALIZED ||
1734                         CAMERASRC_STATE(p) == CAMERASRC_STATE_DESTROYED) {
1735                 return CAMERASRC_SUCCESS;
1736         }
1737         if(CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
1738                 camsrc_warning("Invalid state transition");
1739         }
1740
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;
1746                 }
1747         }
1748 #else /* USE_OPEN_CHK */
1749         if(!CAMERASRC_IS_DEV_CLOSED(p)) {
1750
1751                 if( !(p->is_async_open) ) {
1752                         close(p->dev_fd);
1753                 }
1754         }
1755 #endif /* USE_OPEN_CHK */
1756
1757         p->dev_fd = -1;
1758         p->check_esd = 0;
1759
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;
1764         return err;
1765 }
1766
1767
1768 int camerasrc_start(camsrc_handle_t handle)
1769 {
1770         camerasrc_handle_t* p = NULL;
1771         int err = CAMERASRC_ERR_UNKNOWN;
1772
1773         camsrc_info("enter");
1774
1775         if(handle == NULL) {
1776                 camsrc_error("handle is null");
1777                 return CAMERASRC_ERR_NULL_POINTER;
1778         }
1779
1780         p = CAMERASRC_HANDLE(handle);
1781
1782         /* STATE OR PHASE CHECKING */
1783         if(CAMERASRC_STATE(p) == CAMERASRC_STATE_READY) {
1784                 return CAMERASRC_SUCCESS;
1785         }
1786         if(CAMERASRC_STATE(p) != CAMERASRC_STATE_REALIZED) {
1787                 camsrc_warning("Invalid state transition");
1788         }
1789
1790         CAMERASRC_SET_STATE(p, CAMERASRC_STATE_READY);
1791         CAMERASRC_SET_PHASE(p, CAMERASRC_PHASE_RUNNING);
1792
1793         camsrc_info("Transit to running phase");
1794         err = CAMERASRC_SUCCESS;
1795         return err;
1796 }
1797
1798
1799 int camerasrc_present_usr_buffer(camsrc_handle_t handle, camerasrc_usr_buf_t *present_buf, camerasrc_io_method_t io_method)
1800 {
1801         camerasrc_handle_t *p = NULL;
1802         int err = CAMERASRC_ERR_UNKNOWN;
1803
1804         camsrc_info("enter");
1805
1806         if (handle == NULL) {
1807                 camsrc_error("handle is null");
1808                 return CAMERASRC_ERR_NULL_POINTER;
1809         }
1810
1811         p = CAMERASRC_HANDLE(handle);
1812
1813         if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
1814                 camsrc_warning("Invalid state transition");
1815         }
1816
1817         switch(io_method) {
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;
1824 #else
1825                         return CAMERASRC_SUCCESS;
1826 #endif
1827                 }
1828                 p->io_method = CAMERASRC_IO_METHOD_MMAP;
1829                 break;
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;
1835                 }
1836
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;
1840                 }
1841                 p->present_buf = present_buf;
1842                 p->io_method = CAMERASRC_IO_METHOD_USRPTR;
1843                 break;
1844         case CAMERASRC_IO_METHOD_READ:
1845         default:
1846 #if USE_NOT_SUPPORT_ERR
1847                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
1848 #else
1849                 return CAMERASRC_SUCCESS;
1850 #endif
1851                 break;
1852         }
1853
1854         err = CAMERASRC_SUCCESS;
1855         return err;
1856 }
1857
1858
1859 int camerasrc_get_num_buffer(camsrc_handle_t handle, unsigned int *num_buffer)
1860 {
1861         camerasrc_handle_t *p = NULL;
1862
1863         if (handle == NULL) {
1864                 camsrc_error("handle is null");
1865                 return CAMERASRC_ERR_NULL_POINTER;
1866         }
1867
1868         p = CAMERASRC_HANDLE(handle);
1869
1870         camerasrc_state_t state = CAMERASRC_STATE_NONE;
1871         camerasrc_get_state(handle, &state);
1872
1873         switch(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.");
1881                 *num_buffer = 0;
1882                 break;
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;
1888                 break;
1889         default:
1890                 camsrc_error("Unknown state");
1891                 *num_buffer = -1;
1892                 return CAMERASRC_ERR_INVALID_STATE;
1893         }
1894
1895         return CAMERASRC_SUCCESS;
1896 }
1897
1898
1899 int camerasrc_get_io_method(camsrc_handle_t handle, camerasrc_io_method_t* io_method)
1900 {
1901         camerasrc_handle_t *p = NULL;
1902
1903         camsrc_info("enter");
1904
1905         if (handle == NULL) {
1906                 camsrc_error("handle is null");
1907                 return CAMERASRC_ERR_NULL_POINTER;
1908         }
1909
1910         p = CAMERASRC_HANDLE(handle);
1911
1912         *io_method = p->io_method;
1913
1914         return CAMERASRC_SUCCESS;
1915 }
1916
1917
1918 int camerasrc_start_still_stream(camsrc_handle_t handle)
1919 {
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;
1925         int cnt = 0;
1926         char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
1927
1928         camsrc_info("enter");
1929
1930         if (handle == NULL) {
1931                 camsrc_error("handle is null");
1932                 return CAMERASRC_ERR_NULL_POINTER;
1933         }
1934
1935         p = CAMERASRC_HANDLE(handle);
1936
1937         if (CAMERASRC_STATE(p) == CAMERASRC_STATE_STILL) {
1938                 return CAMERASRC_SUCCESS;
1939         }
1940
1941         if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
1942                 camsrc_warning("Invalid state transition");
1943         }
1944
1945         /* S T I L L   M O D E   S E T T I N G */
1946         /*
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
1949          */
1950         CLEAR(vstreamparm);
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;
1957         }
1958         );
1959
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;
1966         } else {
1967                 camsrc_info("Quality not initialized, or incorrect value. set high quality...");
1968                 vstreamparm.parm.capture.capturemode = V4L2_MODE_HIGHQUALITY;
1969         }
1970
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;
1981         }
1982         );
1983
1984         /* S T I L L   F O R M A T   S E T T I N G */
1985         CLEAR(vformat);
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;
1992                 break;
1993         case CAMERASRC_PIX_YUV422P:
1994                 camsrc_info("422P capture activated..");
1995                 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV422P;
1996                 break;
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;
2001                 break;
2002         case CAMERASRC_PIX_ST12:
2003                 camsrc_info("NV12T capture activated..");
2004                 vformat.fmt.pix.pixelformat = V4L2_PIX_FMT_NV12T;
2005                 break;
2006         case CAMERASRC_PIX_YUY2:
2007                 camsrc_info("YUY2 capture activated..");
2008                 vformat.fmt.pix.pixelformat = CAMERASRC_V4L2_PREVIEW_PIX_FMT_DEFAULT;
2009                 break;
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;
2014                 break;
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;
2018                 break;
2019         default:
2020                 camsrc_error("Not supported format!");
2021                 break;
2022         }
2023
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;
2033         }
2034         );
2035
2036         camsrc_info("Stillshot VIDIOC_S_FMT done");
2037
2038         CLEAR(vreq_bufs);
2039
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");
2044
2045                 if (vformat.fmt.pix.pixelformat == CAMERASRC_V4L2_JPEG_CAPTURE_PIX_FMT_DEFAULT ) {
2046                         vreq_bufs.count = CAMERASRC_STILL_BUFFER_NUM;
2047                 } else {
2048                         vreq_bufs.count = CAMERASRC_PREVIEW_BUFFER_NUM;
2049                 }
2050                 vreq_bufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2051                 vreq_bufs.memory = V4L2_MEMORY_MMAP;
2052
2053                 camsrc_info("VIDIOC_REQBUFS count:%d, type:%d, memory:%d",
2054                                         vreq_bufs.count, vreq_bufs.type, vreq_bufs.memory);
2055
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;
2061                 }
2062                 );
2063
2064                 camsrc_info("Stillshot VIDIOC_REQBUFS done");
2065                 camsrc_assert(vreq_bufs.count >= 1);
2066
2067                 p->num_buffers = vreq_bufs.count;
2068                 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2069
2070                 if (!p->buffer) {
2071                         camsrc_error("calloc() failed");
2072                         return CAMERASRC_ERR_ALLOCATION;
2073                 }
2074
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;
2078                         CLEAR(vbuf);
2079
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;
2087                         }
2088
2089                         p->buffer[p->buffer_idx].length = vbuf.length;
2090                         p->buffer[p->buffer_idx].start = mmap(NULL /* start anywhere */,
2091                                                               vbuf.length,
2092                                                               PROT_READ | PROT_WRITE,
2093                                                               MAP_SHARED,
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;
2098                         }
2099
2100                         camsrc_info("MMAP BUF: addr[%p] size[%d]",
2101                                                p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2102                 }
2103                 );
2104
2105                 camsrc_info("Stillshot VIDIOC_QUERYBUF and mmap done");
2106                 break;
2107
2108         case CAMERASRC_IO_METHOD_USRPTR:
2109                 camsrc_info("USRPTR mode");
2110
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;
2118                 }
2119
2120                 camsrc_assert(vreq_bufs.count >= 1);
2121
2122                 p->num_buffers = vreq_bufs.count;
2123                 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2124
2125                 if (!p->buffer) {
2126                         camsrc_error("calloc() failed");
2127                         return CAMERASRC_ERR_ALLOCATION;
2128                 }
2129
2130                 if (!p->present_buf->present_buffer) {
2131                         camsrc_error("No Usrptr buffer presented!");
2132                         return CAMERASRC_ERR_ALLOCATION;
2133                 }
2134
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;
2138
2139                         if (!p->buffer[p->buffer_idx].start) {
2140                                 camsrc_error("presented usrptr buffer is NULL");
2141                                 return CAMERASRC_ERR_ALLOCATION;
2142                         }
2143
2144                         camsrc_info("USERPTR BUF: addr[%p] size[%d]",
2145                                                p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2146                 }
2147                 break;
2148
2149         case CAMERASRC_IO_METHOD_READ:
2150         default:
2151                 camsrc_error("Device not support that io-method");
2152 #if USE_NOT_SUPPORT_ERR
2153                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2154 #else
2155                 return CAMERASRC_SUCCESS;
2156 #endif
2157                 break;
2158         }
2159
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");
2165         }
2166
2167         /* Rotation set */
2168         __ta__( "            _CAMERASRC_CMD_ROTATION",
2169         CAMERASRC_SET_CMD(_CAMERASRC_CMD_ROTATION, &(p->format.rotation));
2170         );
2171
2172         /* Sensor flip */
2173         __ta__( "            _CAMERASRC_CMD_VFLIP",
2174         CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip));
2175         );
2176
2177         __ta__( "            _CAMERASRC_CMD_HFLIP",
2178         CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip));
2179         );
2180
2181         /* set JPEG quality */
2182         if (p->format.pix_format == CAMERASRC_PIX_RGGB8) {
2183                 int err = CAMERASRC_ERR_UNKNOWN;
2184                 struct v4l2_control control;
2185
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);
2191                 );
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);
2195                         return err;
2196                 }
2197         }
2198
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");
2203
2204                 p->queued_buffer_count = 0;
2205                 for (cnt = 0; cnt < p->num_buffers; cnt++) {
2206                         struct v4l2_buffer lvbuf;
2207                         CLEAR(lvbuf);
2208
2209                         lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2210                         lvbuf.memory = V4L2_MEMORY_MMAP;
2211                         lvbuf.index = cnt;
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;
2217                         }
2218                         );
2219
2220                         LOCK(p);
2221                         p->buffer[lvbuf.index].queued_status = CAMERASRC_BUFFER_QUEUED;
2222                         p->queued_buffer_count++;
2223                         UNLOCK(p);
2224                 }
2225
2226                 camsrc_info("Stillshot VIDIOC_QBUF done");
2227
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;
2234                 }
2235                 );
2236                 camsrc_info("Stillshot VIDIOC_STREAMON done");
2237                 break;
2238
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;
2243                         CLEAR(lvbuf);
2244
2245                         lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2246                         lvbuf.memory = V4L2_MEMORY_USERPTR;
2247                         lvbuf.index = cnt;
2248                         lvbuf.m.userptr = (unsigned long)p->buffer[cnt].start;
2249                         lvbuf.length = p->buffer[cnt].length;
2250
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;
2255                         }
2256                 }
2257
2258                 camsrc_info("Stillshot VIDIOC_QBUF done");
2259
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;
2265                 }
2266                 camsrc_info("Stillshot VIDIOC_STREAMON done");
2267                 break;
2268
2269         case CAMERASRC_IO_METHOD_READ:
2270         default:
2271                 camsrc_error("Device not support that io-method");
2272 #if USE_NOT_SUPPORT_ERR
2273                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2274 #else
2275                 return CAMERASRC_SUCCESS;
2276 #endif
2277                 break;
2278         }
2279
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;
2284
2285                 control.id = V4L2_CID_CAMERA_CAPTURE;
2286                 control.value = 0;
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);
2290                 );
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);
2294                         return err;
2295                 }
2296         }
2297
2298
2299         LOCK(p);
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;
2303         } else {
2304                 p->skip_frame_func = NULL;
2305         }
2306         );
2307         UNLOCK(p);
2308
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);
2314                 }
2315         }
2316 #endif
2317
2318         CAMERASRC_SET_STATE(p, CAMERASRC_STATE_STILL);
2319
2320         return CAMERASRC_SUCCESS;
2321 }
2322
2323
2324 int camerasrc_start_preview_stream(camsrc_handle_t handle)
2325 {
2326         camerasrc_handle_t* p = NULL;
2327         int err = CAMERASRC_ERR_UNKNOWN;
2328
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;
2334         int cnt = 0;
2335         int preview_width = 0;
2336         int preview_height = 0;
2337 /*
2338         int capture_width = 0;
2339         int capture_height = 0;
2340 */
2341         char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
2342
2343         camsrc_info("enter");
2344
2345         if (handle == NULL) {
2346                 camsrc_error("handle is null");
2347                 return CAMERASRC_ERR_NULL_POINTER;
2348         }
2349
2350         p = CAMERASRC_HANDLE(handle);
2351
2352         /* STATE OR PHASE CHECKING */
2353         if(CAMERASRC_STATE(p) == CAMERASRC_STATE_PREVIEW) {
2354                 return CAMERASRC_SUCCESS;
2355         }
2356         if(CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
2357                 camsrc_warning("Invalid state transition");
2358         }
2359
2360         /* P R E V I E W   M O D E   S E T T I N G */
2361         CLEAR(vstreamparm);
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;
2368         }
2369         );
2370
2371         vstreamparm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2372
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;
2383                 } else {
2384                         camsrc_info("Quality not initialized, or incorrect value. set normal quality...");
2385                         vstreamparm.parm.capture.capturemode = 0;
2386                 }
2387
2388                 vstreamparm.parm.capture.timeperframe.numerator = p->timeperframe.numerator;
2389                 vstreamparm.parm.capture.timeperframe.denominator = p->timeperframe.denominator;
2390
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);
2394
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;
2400                 }
2401                 );
2402         }
2403
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;
2411         }
2412
2413         if (p->format.colorspace != CAMERASRC_COL_RAW) {
2414                 camsrc_error("Invalid store method.");
2415                 return CAMERASRC_ERR_INVALID_PARAMETER;
2416         }
2417
2418         err = _camerasrc_dump_format(handle);
2419         if (err != CAMERASRC_SUCCESS) {
2420                 camsrc_error("Format dump error");
2421                 return err;
2422         }
2423
2424         preview_width = p->format.img_size.dim.width;
2425         preview_height = p->format.img_size.dim.height;
2426
2427         CLEAR(vformat);
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;
2432
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;
2438                 break;
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;
2443                 break;
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;
2448                 break;
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;
2453                 break;
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;
2459                 break;
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;
2464                 break;
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 */
2470                 /* ... */
2471                 break;
2472         default:
2473                 camsrc_error("Invalid output format.");
2474                 break;
2475         }
2476
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("===========================================");
2485
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;
2491         }
2492         );
2493
2494         control.id = V4L2_CID_CACHEABLE;
2495         if (p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) {
2496                 control.value = 1;
2497         } else {
2498                 control.value = 0;
2499         }
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);
2503         );
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);
2507                 return err;
2508         }
2509
2510         control.id = V4L2_CID_EMBEDDEDDATA_ENABLE;
2511         if (p->format.pix_format == CAMERASRC_PIX_INTERLEAVED) {
2512                 control.value = 1;
2513         } else {
2514                 control.value = 0;
2515         }
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);
2519         );
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);
2523                 return err;
2524         }
2525
2526         /* Prepare alter format frame */
2527         __ta__( "            camerasrc_query_img_buf_size",
2528         camerasrc_query_img_buf_size(p, &(p->alter_frame.length), NULL);
2529         );
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;
2534         }
2535
2536         /* M E M O R Y   M A P P I N G */
2537         CLEAR(vreq_bufs);
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;
2550                 }
2551                 );
2552                 camsrc_assert(vreq_bufs.count >= 1);
2553
2554                 p->num_buffers = vreq_bufs.count;
2555                 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2556                 if (!p->buffer) {
2557                         camsrc_error("calloc() failed");
2558                         return CAMERASRC_ERR_ALLOCATION;
2559                 }
2560
2561                 for (p->buffer_idx = 0; p->buffer_idx < vreq_bufs.count; ++(p->buffer_idx)) {
2562                         struct v4l2_buffer vbuf;
2563                         CLEAR(vbuf);
2564                         vbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2565                         vbuf.memory = V4L2_MEMORY_MMAP;
2566                         vbuf.index = p->buffer_idx;
2567
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;
2573                         }
2574                         );
2575
2576                         __ta__( "            mmap",
2577                         p->buffer[p->buffer_idx].length = vbuf.length;
2578                         p->buffer[p->buffer_idx].start = mmap(NULL /* start anywhere */,
2579                                                               vbuf.length,
2580                                                               PROT_READ | PROT_WRITE,
2581                                                               MAP_SHARED,
2582                                                               p->dev_fd, vbuf.m.offset);
2583                         );
2584                         if (MAP_FAILED == p->buffer[p->buffer_idx].start) {
2585                                 camsrc_error("mmap failed.");
2586                                 return CAMERASRC_ERR_ALLOCATION;
2587                         }
2588
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);
2591
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);
2598                                 }
2599                                 break;
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);
2604                                 }
2605                                 break;
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.");
2610                                 }
2611                                 break;
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.");
2615                                 }
2616                                 break;
2617                         default:
2618                                 camsrc_error("Not supported format[%d]", p->format.pix_format);
2619                                 break;
2620                         }
2621
2622                         camsrc_info("MMAP BUF: addr[%p] size[%d]",
2623                                                p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2624                 }
2625                 break;
2626         case CAMERASRC_IO_METHOD_USRPTR:
2627                 camsrc_info("USRPTR mode");
2628
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;
2637                 }
2638                 );
2639                 camsrc_assert(vreq_bufs.count >= 1);
2640
2641                 p->num_buffers = vreq_bufs.count;
2642                 p->buffer = calloc (vreq_bufs.count, sizeof (camerasrc_buffer_t));
2643
2644                 if(!p->buffer) {
2645                         camsrc_error("calloc() failed");
2646                         return CAMERASRC_ERR_ALLOCATION;
2647                 }
2648
2649                 if(!p->present_buf->present_buffer) {
2650                         camsrc_error("No Usrptr buffer presented!");
2651                         return CAMERASRC_ERR_ALLOCATION;
2652                 }
2653
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;
2657
2658                         if (!p->buffer[p->buffer_idx].start) {
2659                                 camsrc_error("presented usrptr buffer is NULL");
2660                                 return CAMERASRC_ERR_ALLOCATION;
2661                         }
2662
2663                         camsrc_info("USERPTR BUF: addr[%p] size[%d]",
2664                                                p->buffer[p->buffer_idx].start, p->buffer[p->buffer_idx].length);
2665                 }
2666                 break;
2667         case CAMERASRC_IO_METHOD_READ:
2668         default:
2669                 camsrc_error("Device not support that io-method");
2670 #if USE_NOT_SUPPORT_ERR
2671                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2672 #else
2673                 return CAMERASRC_SUCCESS;
2674 #endif
2675                 break;
2676         }
2677
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");
2682
2683                 p->queued_buffer_count = 0;
2684                 for (cnt = 0; cnt < p->num_buffers; cnt++) {
2685                         struct v4l2_buffer lvbuf;
2686                         CLEAR(lvbuf);
2687
2688                         lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2689                         lvbuf.memory = V4L2_MEMORY_MMAP;
2690                         lvbuf.index = cnt;
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;
2696                         }
2697                         );
2698
2699                         LOCK(p);
2700                         p->buffer[lvbuf.index].queued_status = CAMERASRC_BUFFER_QUEUED;
2701                         p->queued_buffer_count++;
2702                         UNLOCK(p);
2703                 }
2704                 break;
2705         case CAMERASRC_IO_METHOD_USRPTR:
2706                 camsrc_info("USRPTR mode");
2707
2708                 for (cnt = 0; cnt < p->present_buf->num_buffer; cnt++) {
2709                         struct v4l2_buffer lvbuf;
2710                         CLEAR(lvbuf);
2711
2712                         lvbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2713                         lvbuf.memory = V4L2_MEMORY_USERPTR;
2714                         lvbuf.index = cnt;
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;
2722                         }
2723                         );
2724
2725                         camsrc_info("QBUF Address [%d] %p", lvbuf.index, (void*)lvbuf.m.userptr);
2726
2727                         memcpy(&(p->queued_buf_list[cnt]), &lvbuf, sizeof(struct v4l2_buffer));
2728                 }
2729                 break;
2730         case CAMERASRC_IO_METHOD_READ:
2731         default:
2732                 camsrc_error("Device not support that io-method");
2733 #if USE_NOT_SUPPORT_ERR
2734                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2735 #else
2736                 return CAMERASRC_SUCCESS;
2737 #endif
2738                 break;
2739         }
2740
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");
2746         }
2747
2748         /* Rotation set */
2749         __ta__( "            _CAMERASRC_CMD_ROTATION",
2750         CAMERASRC_SET_CMD(_CAMERASRC_CMD_ROTATION, &(p->format.rotation));
2751         );
2752 #if USE_SENSOR_MODE
2753         /* Sensor mode Set */
2754         __ta__( "            _CAMERASRC_CMD_SENSOR_MODE",
2755         CAMERASRC_SET_CMD(_CAMERASRC_CMD_SENSOR_MODE, &(p->sensor_mode));
2756         );
2757 #endif
2758         /* Sensor flip */
2759         __ta__( "            _CAMERASRC_CMD_VFLIP",
2760         CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip));
2761         );
2762         __ta__( "            _CAMERASRC_CMD_HFLIP",
2763         CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip));
2764         );
2765
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;
2772         }
2773         );
2774
2775         /* For noti that it is first frame DQ */
2776         p->first_frame = 1;
2777
2778         LOCK(p);
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;
2781         } else {
2782                 p->skip_frame_func = NULL;
2783         }
2784         UNLOCK(p);
2785
2786 #if defined(USE_SKIP_FRAME_AT_RAW_FRAME)
2787         if(p->skip_frame_func != NULL)
2788                 p->skip_frame_func(p, 5000, 3);
2789 #endif
2790
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);
2793         }
2794
2795         CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW);
2796
2797         return CAMERASRC_SUCCESS;
2798 }
2799
2800
2801 int camerasrc_query_img_buf_size(camsrc_handle_t handle, unsigned int* main_img_size, unsigned int* thm_img_size)
2802 {
2803         camerasrc_handle_t* p = NULL;
2804
2805         camsrc_info("enter");
2806
2807         if (handle == NULL) {
2808                 camsrc_error("handle is null");
2809                 return CAMERASRC_ERR_NULL_POINTER;
2810         }
2811
2812         p = CAMERASRC_HANDLE(handle);
2813
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");
2818         }
2819
2820         camsrc_info("Start to set format");
2821
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) {
2829                         *thm_img_size = 0;
2830                 }
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) {
2841                         *thm_img_size = 0;
2842                 }
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;
2851                         }
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;
2858                         }
2859                 } else {
2860                         camsrc_error("Unknown image format...");
2861 #if USE_NOT_SUPPORT_ERR
2862                         return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2863 #else
2864                         return CAMERASRC_SUCCESS;
2865 #endif
2866                 }
2867
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);
2870         } else {
2871                 camsrc_error("Unknown format set. can't go any more");
2872                 camsrc_assert(0);
2873         }
2874
2875         camsrc_info("leave..");
2876
2877         return CAMERASRC_SUCCESS;
2878 }
2879
2880
2881 int camerasrc_stop_stream(camsrc_handle_t handle)
2882 {
2883         camerasrc_handle_t *p = NULL;
2884         enum v4l2_buf_type type;
2885         int cnt = 0;
2886         int try_count = 0;
2887         camerasrc_auto_focus_status_t af_status = 0;
2888         struct v4l2_requestbuffers vreq_bufs;
2889         char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
2890
2891         camsrc_info("enter");
2892
2893         if(handle == NULL) {
2894                 camsrc_error("handle is null");
2895                 return CAMERASRC_ERR_NULL_POINTER;
2896         }
2897
2898         p = CAMERASRC_HANDLE(handle);
2899
2900         if (CAMERASRC_STATE(p) == CAMERASRC_STATE_READY) {
2901                 return CAMERASRC_SUCCESS;
2902         }
2903
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]");
2909         }
2910
2911         camsrc_info("Change to READY state first for preventing to check Q/DQ after stop");
2912         CAMERASRC_SET_STATE(p, CAMERASRC_STATE_READY);
2913
2914         LOCK(p);
2915         p->timeperframe.denominator = 0;
2916         p->timeperframe.numerator = 0;
2917         p->first_frame = 1;
2918         UNLOCK(p);
2919
2920 #ifdef STOP_AF_BEFORE_STREAMOFF
2921         _camerasrc_stop_autofocusing(p);
2922
2923         /* Wait for AF stop done */
2924         try_count = 0;
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");
2931                         break;
2932                 }
2933         }
2934         );
2935 #endif /* STOP_AF_BEFORE_STREAMOFF */
2936
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;
2944         }
2945         );
2946
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;
2955                         }
2956
2957                         p->buffer[cnt].start = NULL;
2958                         p->buffer[cnt].length = 0;
2959                 }
2960                 break;
2961         case CAMERASRC_IO_METHOD_USRPTR:
2962                 camsrc_info("User ptr mode don't need munmap");
2963                 break;
2964         case CAMERASRC_IO_METHOD_READ:
2965         default:
2966                 camsrc_error("Device not support that io-method");
2967 #if USE_NOT_SUPPORT_ERR
2968                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
2969 #else
2970                 return CAMERASRC_SUCCESS;
2971 #endif
2972         }
2973
2974         /* release buffer */
2975         CLEAR(vreq_bufs);
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;
2983         }
2984
2985         /* RETURN BUFFER MANAGE MODE TO DEFAULT */
2986         p->io_method = CAMERASRC_IO_METHOD_MMAP;
2987         p->present_buf = NULL;
2988
2989         if (p->buffer != NULL) {
2990                 free(p->buffer);
2991         }
2992
2993         if (p->alter_frame.start != NULL) {
2994                 free(p->alter_frame.start);
2995         }
2996
2997         p->buffer = NULL;
2998         p->alter_frame.start = NULL;
2999
3000         p->buffer_idx = 0;
3001         p->num_buffers = 0;
3002
3003         return CAMERASRC_SUCCESS;
3004 }
3005
3006
3007 int camerasrc_wait_frame_available(camsrc_handle_t handle, long int timeout)
3008 {
3009         camerasrc_handle_t *p = NULL;
3010         int err = CAMERASRC_ERR_UNKNOWN;
3011
3012         if (handle == NULL) {
3013                 camsrc_error("handle is null");
3014                 return CAMERASRC_ERR_NULL_POINTER;
3015         }
3016
3017         p = CAMERASRC_HANDLE(handle);
3018
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" );
3024         }
3025
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);
3029         } else {
3030                 camsrc_warning("queued_buffer_count[%d] is unavailable. sleep 100 ms and try again...", p->queued_buffer_count );
3031                 usleep( 100000 );
3032                 err = CAMERASRC_ERR_INVALID_STATE;
3033         }
3034
3035         return err;
3036 }
3037
3038
3039 int camerasrc_check_esd_shock(camsrc_handle_t *handle, int *check_val)
3040 {
3041         camerasrc_handle_t* p = NULL;
3042         int err = CAMERASRC_ERR_UNKNOWN;
3043
3044         camsrc_info("enter");
3045
3046         if(handle == NULL) {
3047                 camsrc_error("handle is null");
3048                 return CAMERASRC_ERR_NULL_POINTER;
3049         }
3050
3051         p = CAMERASRC_HANDLE(handle);
3052
3053         printf("start  _camerasrc_check_emp_shock");
3054         *check_val = 0;
3055         err = _camerasrc_check_emp_shock(p, check_val);
3056         printf("check_val = %d", *check_val);
3057         printf("end  _camerasrc_check_emp_shock");
3058
3059         return err;
3060 }
3061
3062
3063 int camerasrc_queue_buffer(camsrc_handle_t handle, int buf_index, camerasrc_buffer_t *buffer)
3064 {
3065         camerasrc_handle_t *p = NULL;
3066         int err = CAMERASRC_ERR_UNKNOWN;
3067
3068         if (handle == NULL) {
3069                 camsrc_error("handle is null");
3070                 return CAMERASRC_ERR_NULL_POINTER;
3071         }
3072
3073         p = CAMERASRC_HANDLE(handle);
3074
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");
3080         }
3081
3082         err = _camerasrc_queue_buffer(p, buf_index, buffer);
3083
3084         return err;
3085 }
3086
3087
3088 int camerasrc_dequeue_buffer(camsrc_handle_t handle, int *buf_index, camerasrc_buffer_t *buffer, camerasrc_buffer_t *thm_buffer)
3089 {
3090         camerasrc_handle_t *p = NULL;
3091         int err = CAMERASRC_ERR_UNKNOWN;
3092
3093         if (handle == NULL) {
3094                 camsrc_error("handle is null");
3095                 return CAMERASRC_ERR_NULL_POINTER;
3096         }
3097
3098         p = CAMERASRC_HANDLE(handle);
3099
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");
3105         }
3106
3107         err = _camerasrc_dequeue_buffer(p, buf_index, buffer, thm_buffer);
3108
3109         return err;
3110 }
3111
3112
3113 int camerasrc_read_frame(camsrc_handle_t handle, camerasrc_buffer_t *main_img_buffer, camerasrc_buffer_t *thm_img_buffer, int *buffer_index)
3114 {
3115         camerasrc_handle_t* p = NULL;
3116         int err = CAMERASRC_ERR_UNKNOWN;
3117
3118         camsrc_info("ENTER");
3119
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;
3124         }
3125
3126         p = CAMERASRC_HANDLE(handle);
3127
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");
3133         }
3134
3135 #ifndef DUMMY_OUTPUT
3136         __ta__( "                Stillshot select()",
3137         err = _camerasrc_wait_frame_available(p, CAMERASRC_TIMEOUT_CRITICAL_VALUE);
3138         );
3139         if (err != CAMERASRC_SUCCESS) {
3140                 camsrc_error("Frame waiting error, [%x]", err);
3141                 return err;
3142         }
3143
3144         /* Buffer DQ */
3145         __ta__( "                Stillshot VIDIOC_DQBUF",
3146         err = _camerasrc_dequeue_buffer(p, buffer_index, main_img_buffer, thm_img_buffer);
3147         );
3148         if (err != CAMERASRC_SUCCESS) {
3149                 camsrc_error("Dequeue frame error, [%x]", err);
3150                 return err;
3151         }
3152 #endif
3153
3154         camsrc_info("DEQUEUED Index : %d", *buffer_index);
3155
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");
3159 #endif
3160
3161         return CAMERASRC_SUCCESS;
3162 }
3163
3164
3165 int camerasrc_set_focused_callback(camsrc_handle_t handle, camerasrc_callback_t cb, void *usr_data)
3166 {
3167         camerasrc_handle_t *p = NULL;
3168
3169         camsrc_info("enter");
3170
3171         if (handle == NULL) {
3172                 camsrc_error("handle is null");
3173                 return CAMERASRC_ERR_NULL_POINTER;
3174         }
3175
3176         p = CAMERASRC_HANDLE(handle);
3177
3178         if (CAMERASRC_STATE(p) != CAMERASRC_STATE_REALIZED &&
3179             CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3180                 camsrc_warning("Invalid state transition");
3181         }
3182
3183         LOCK(p);
3184         p->af_cb = cb;
3185         if (usr_data != NULL) {
3186                 p->af_usr_data = usr_data;
3187         }
3188         UNLOCK(p);
3189
3190         return CAMERASRC_SUCCESS;
3191 }
3192
3193
3194 int camerasrc_set_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t *rect)
3195 {
3196         camerasrc_handle_t *p = NULL;
3197         int err = CAMERASRC_ERR_UNKNOWN;
3198
3199         camsrc_info("enter");
3200
3201         if (handle == NULL) {
3202                 camsrc_error("handle is null");
3203                 return CAMERASRC_ERR_NULL_POINTER;
3204         }
3205
3206         p = CAMERASRC_HANDLE(handle);
3207
3208         if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3209                 camsrc_warning("Invalid state transition");
3210         }
3211
3212         err = _camerasrc_set_autofocusing_area(p, rect);
3213
3214         if (err != CAMERASRC_SUCCESS) {
3215                 camsrc_error("Set autofocusing area error");
3216                 return err;
3217         }
3218
3219         return CAMERASRC_SUCCESS;
3220 }
3221
3222
3223 int camerasrc_get_autofocusing_area(camsrc_handle_t handle, camerasrc_rect_t *rect)
3224 {
3225         camerasrc_handle_t *p = NULL;
3226         int err = CAMERASRC_ERR_UNKNOWN;
3227
3228         camsrc_info("enter");
3229
3230         if (handle == NULL) {
3231                 camsrc_error("handle is null");
3232                 return CAMERASRC_ERR_NULL_POINTER;
3233         }
3234
3235         p = CAMERASRC_HANDLE(handle);
3236
3237         if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3238                 camsrc_warning("Invalid state transition");
3239         }
3240
3241         err = _camerasrc_get_autofocusing_area(p, rect);
3242
3243         if (err != CAMERASRC_SUCCESS) {
3244                 camsrc_error("Get autofocusing area error");
3245                 return err;
3246         }
3247
3248         return CAMERASRC_SUCCESS;
3249 }
3250
3251
3252 int camerasrc_start_autofocusing(camsrc_handle_t handle)
3253 {
3254         camerasrc_handle_t *p = NULL;
3255         int err = CAMERASRC_ERR_UNKNOWN;
3256
3257         camsrc_info("enter");
3258
3259         if (handle == NULL) {
3260                 camsrc_error("handle is null");
3261                 return CAMERASRC_ERR_NULL_POINTER;
3262         }
3263
3264         p = CAMERASRC_HANDLE(handle);
3265
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;
3271         }
3272
3273         /* START AF */
3274         err = _camerasrc_start_autofocusing(p);
3275
3276         if (err != CAMERASRC_SUCCESS) {
3277                 camsrc_error("Create autofocusing thread error");
3278                 return err;
3279         }
3280
3281         camsrc_info("Set state to [AF-IN-PROGRESS]!!");
3282         CAMERASRC_SET_STATE(p, CAMERASRC_STATE_AF_IN_PROGRESS);
3283
3284         return CAMERASRC_SUCCESS;
3285 }
3286
3287
3288 int camerasrc_stop_autofocusing(camsrc_handle_t handle)
3289 {
3290         camerasrc_handle_t *p = NULL;
3291         int err = CAMERASRC_ERR_UNKNOWN;
3292
3293         camsrc_info("enter");
3294
3295         if (handle == NULL) {
3296                 camsrc_error("handle is null");
3297                 return CAMERASRC_ERR_NULL_POINTER;
3298         }
3299
3300         p = CAMERASRC_HANDLE(handle);
3301
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;
3307         }
3308
3309         /* STOP AF */
3310         camsrc_info("AF_STOP called!!");
3311         err = _camerasrc_stop_autofocusing(p);
3312         if (err != CAMERASRC_SUCCESS) {
3313                 camsrc_error("Stop autofocusing error");
3314                 return err;
3315         }
3316
3317         if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) {
3318                 camsrc_info("Set state to [PREVIEW] again!!");
3319                 CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW);
3320         } else {
3321                 camsrc_info("Do not change state");
3322         }
3323
3324         return CAMERASRC_SUCCESS;
3325 }
3326
3327
3328 int camerasrc_release_autofocusing(camsrc_handle_t handle)
3329 {
3330         camerasrc_handle_t *p = NULL;
3331         int err = CAMERASRC_ERR_UNKNOWN;
3332
3333         camsrc_info("enter");
3334
3335         if (handle == NULL) {
3336                 camsrc_error("handle is null");
3337                 return CAMERASRC_ERR_NULL_POINTER;
3338         }
3339
3340         p = CAMERASRC_HANDLE(handle);
3341
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;
3346         }
3347
3348         /* STOP AF */
3349         camsrc_info("AF_RELEASE called!!");
3350         err = _camerasrc_release_autofocusing(p);
3351         if (err != CAMERASRC_SUCCESS) {
3352                 camsrc_error("Stop autofocusing error");
3353                 return err;
3354         }
3355
3356         camsrc_info("Set state to [PREVIEW] again!!");
3357         CAMERASRC_SET_STATE(p, CAMERASRC_STATE_PREVIEW);
3358
3359         return CAMERASRC_SUCCESS;
3360 }
3361
3362
3363 int camerasrc_init_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t af_mode, camerasrc_af_scan_range_t af_range)
3364 {
3365         camerasrc_handle_t *p = NULL;
3366         int err = CAMERASRC_ERR_UNKNOWN;
3367
3368         camsrc_info("enter");
3369
3370         if (handle == NULL) {
3371                 camsrc_error("handle is null");
3372                 return CAMERASRC_ERR_NULL_POINTER;
3373         }
3374
3375         p = CAMERASRC_HANDLE(handle);
3376
3377         if (CAMERASRC_STATE(p) != CAMERASRC_STATE_PREVIEW) {
3378                 camsrc_warning("Invalid state transition");
3379         }
3380
3381         p->cur_af_mode = af_mode;
3382         p->cur_af_range = af_range;
3383
3384         err = _camerasrc_init_autofocusing_mode(p);
3385         if (err != CAMERASRC_SUCCESS) {
3386                 camsrc_error("Init autofocusing mode error");
3387                 return err;
3388         }
3389
3390         return CAMERASRC_SUCCESS;
3391 }
3392
3393
3394 int camerasrc_get_autofocusing_mode(camsrc_handle_t handle, camerasrc_af_mode_t *af_mode, camerasrc_af_scan_range_t *af_range)
3395 {
3396         camerasrc_handle_t *p = NULL;
3397
3398         camsrc_info("enter");
3399
3400         if (handle == NULL) {
3401                 camsrc_error("handle is null");
3402                 return CAMERASRC_ERR_NULL_POINTER;
3403         }
3404
3405         p = CAMERASRC_HANDLE(handle);
3406
3407         if (af_mode) {
3408                 *af_mode = p->cur_af_mode;
3409         }
3410
3411         if (af_range) {
3412                 *af_range = p->cur_af_range;
3413         }
3414
3415         return CAMERASRC_SUCCESS;
3416 }
3417
3418
3419 int camerasrc_get_autofocusing_status(camsrc_handle_t handle, camerasrc_auto_focus_status_t *af_status)
3420 {
3421         camerasrc_handle_t *p = NULL;
3422
3423         camsrc_info("enter");
3424
3425         if (handle == NULL) {
3426                 camsrc_error("handle is null");
3427                 return CAMERASRC_ERR_NULL_POINTER;
3428         }
3429
3430         if (af_status == NULL) {
3431                 camsrc_error("*af_status is NULL");
3432                 return CAMERASRC_ERR_NULL_POINTER;
3433         }
3434
3435         p = CAMERASRC_HANDLE(handle);
3436
3437         *af_status = p->af_status;
3438
3439         camsrc_info("[camerasrc_get_autofocusing_status] %d", *af_status);
3440
3441         return CAMERASRC_SUCCESS;
3442 }
3443
3444 /**** M I S C E L L A N E O U S    O P E R A T I O N ****/
3445
3446 /**** I N P U T ( C A M D E V I C E )    O P E R A T I O N ****/
3447
3448 int camerasrc_get_input(camsrc_handle_t handle, camerasrc_dev_id_t *id)
3449 {
3450         camerasrc_handle_t *p = NULL;
3451
3452         camsrc_info("enter");
3453
3454         if (handle == NULL) {
3455                 camsrc_error("handle is null");
3456                 return CAMERASRC_ERR_NULL_POINTER;
3457         }
3458
3459         p = CAMERASRC_HANDLE(handle);
3460
3461         if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3462                 camsrc_warning("Invalid phase");
3463         }
3464
3465         *id = p->cur_dev_id;
3466
3467         return CAMERASRC_SUCCESS;
3468 }
3469
3470
3471 int camerasrc_set_input(camsrc_handle_t handle, camerasrc_dev_id_t camera_id)
3472 {
3473         camerasrc_handle_t *p = NULL;
3474         struct v4l2_control control;
3475         int err = CAMERASRC_ERR_UNKNOWN;
3476
3477         camsrc_info("enter");
3478
3479         if (handle == NULL) {
3480                 camsrc_error("handle is null");
3481                 return CAMERASRC_ERR_NULL_POINTER;
3482         }
3483
3484         p = CAMERASRC_HANDLE(handle);
3485
3486         if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3487                 camsrc_error("Invalid state");
3488                 return CAMERASRC_ERR_INVALID_STATE;
3489         }
3490
3491         if (p->cur_dev_id == camera_id) {
3492                 return CAMERASRC_SUCCESS;
3493         }
3494
3495         camsrc_info("Set Index to %d", _CAMERASRC_GET_DEV_INDEX(camera_id));
3496
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;
3501         } else {
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);
3504         }
3505
3506         p->cur_dev_id = camera_id;
3507
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 */
3512
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;
3518         } else {
3519                 p->lens_rotation = control.value;
3520                 camsrc_info("lens rotation %d", p->lens_rotation);
3521         }
3522
3523         return err;
3524 }
3525
3526 /**** O U T P U T    C O N T R O L    O P E R A T I O N ****/
3527
3528 int camerasrc_set_timeperframe(camsrc_handle_t handle, camerasrc_frac_t *frac)
3529 {
3530         camerasrc_handle_t *p = NULL;
3531
3532         camsrc_info("enter");
3533
3534         if (handle == NULL) {
3535                 camsrc_error("handle is null");
3536                 return CAMERASRC_ERR_NULL_POINTER;
3537         }
3538
3539         p = CAMERASRC_HANDLE(handle);
3540
3541         if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3542                 camsrc_warning("Invalid phase, but can go");
3543         }
3544
3545         camsrc_info("Numerator = %d, Denominator = %d", frac->numerator, frac->denominator);
3546
3547         LOCK(p);
3548         p->timeperframe.numerator = frac->numerator;
3549         p->timeperframe.denominator = frac->denominator;
3550         UNLOCK(p);
3551
3552         return CAMERASRC_SUCCESS;
3553 }
3554
3555
3556 int camerasrc_set_format(camsrc_handle_t handle, camerasrc_format_t *fmt)
3557 {
3558         camerasrc_handle_t *p = NULL;
3559         int err = CAMERASRC_ERR_UNKNOWN;
3560
3561         camsrc_info("enter");
3562
3563         if (handle == NULL) {
3564                 camsrc_error("handle is null");
3565                 return CAMERASRC_ERR_NULL_POINTER;
3566         }
3567
3568         p = CAMERASRC_HANDLE(handle);
3569
3570         if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3571                 camsrc_error("Invalid state");
3572         }
3573
3574         err = _camerasrc_dump_format(handle);
3575         if (err != CAMERASRC_SUCCESS) {
3576                 camsrc_error("Format dump error");
3577                 return err;
3578         }
3579
3580         CLEAR(p->format);
3581
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;
3593         p->is_preset = 0;
3594
3595         switch (fmt->pix_format) {
3596         case CAMERASRC_PIX_YUV422P:
3597                 p->format.num_planes = 3;
3598                 break;
3599         case CAMERASRC_PIX_YUV420P:
3600                 p->format.num_planes = 3;
3601                 break;
3602         case CAMERASRC_PIX_YUV420:
3603                 p->format.num_planes = 2;
3604                 break;
3605         case CAMERASRC_PIX_SN12:
3606                 p->format.num_planes = 2;
3607                 break;
3608         case CAMERASRC_PIX_ST12:
3609                 p->format.num_planes = 2;
3610                 break;
3611         case CAMERASRC_PIX_NV12:
3612                 p->format.num_planes = 2;
3613                 break;
3614         case CAMERASRC_PIX_YUY2:
3615                 p->format.num_planes = 1;
3616                 break;
3617         case CAMERASRC_PIX_UYVY:
3618                 p->format.num_planes = 1;
3619                 break;
3620         case CAMERASRC_PIX_RGGB8:
3621                 p->format.num_planes = 1;
3622                 break;
3623         case CAMERASRC_PIX_RGGB10:
3624                 p->format.num_planes = 1;
3625                 break;
3626         case CAMERASRC_PIX_RGB565:
3627                 p->format.num_planes = 1;
3628                 break;
3629         default:
3630                 p->format.num_planes = 3;
3631                 camsrc_error("Invalid output format.");
3632                 break;
3633         }
3634
3635         err = _camerasrc_dump_format(handle);
3636         if (err != CAMERASRC_SUCCESS) {
3637                 camsrc_error("Format dump error");
3638                 return err;
3639         }
3640
3641         camsrc_info("leave");
3642
3643         return err;
3644 }
3645
3646
3647 int camerasrc_get_format(camsrc_handle_t handle, camerasrc_format_t *fmt)
3648 {
3649         camerasrc_handle_t *p = NULL;
3650
3651         camsrc_info("enter");
3652
3653         if (handle == NULL) {
3654                 camsrc_error("handle is null");
3655                 return CAMERASRC_ERR_NULL_POINTER;
3656         }
3657
3658         p = CAMERASRC_HANDLE(handle);
3659
3660         if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3661                 camsrc_warning("Invalid phase");
3662         }
3663
3664         memcpy(fmt, &(p->format), sizeof(camerasrc_format_t));
3665
3666         camsrc_info("leave");
3667
3668         return CAMERASRC_SUCCESS;
3669 }
3670
3671
3672 int camerasrc_try_format(camsrc_handle_t handle, camerasrc_format_t *fmt)
3673 {
3674         camerasrc_handle_t *p = NULL;
3675         int err = CAMERASRC_ERR_UNKNOWN;
3676
3677         camsrc_info("enter");
3678
3679         if (handle == NULL) {
3680                 camsrc_error("handle is null");
3681                 return CAMERASRC_ERR_NULL_POINTER;
3682         }
3683
3684         p = CAMERASRC_HANDLE(handle);
3685
3686         if (CAMERASRC_STATE(p) != CAMERASRC_STATE_READY) {
3687                 camsrc_error("Invalid state");
3688                 return CAMERASRC_ERR_INVALID_STATE;
3689         }
3690
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;
3695         }
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;
3699         }
3700
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;
3705         }
3706         if (fmt->colorspace < 0 || fmt->colorspace >= CAMERASRC_COL_NUM) {
3707                 camsrc_info("Invalid colorspace");
3708                 return CAMERASRC_ERR_INVALID_PARAMETER;
3709         }
3710
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;
3715         } else {
3716                 camsrc_info("UNAVAILABLE SETTING");
3717                 err = CAMERASRC_ERR_INVALID_PARAMETER;
3718         }
3719
3720         camsrc_info("leave");
3721
3722         return err;
3723 }
3724
3725
3726 int camerasrc_get_frame_data(camsrc_handle_t handle, camerasrc_frame_data_t *data)
3727 {
3728         camerasrc_handle_t *p = NULL;
3729         int err = CAMERASRC_ERR_UNKNOWN;
3730
3731         if (handle == NULL) {
3732                 camsrc_error("handle is null");
3733                 return CAMERASRC_ERR_NULL_POINTER;
3734         }
3735
3736         p = CAMERASRC_HANDLE(handle);
3737
3738         if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3739                 camsrc_warning("Invalid state transition");
3740         }
3741
3742         err = _camerasrc_get_frame_data(p, data);
3743         if (err != CAMERASRC_SUCCESS) {
3744                 camsrc_error("toggle auto exposure failed");
3745                 return err;
3746         }
3747
3748         return err;
3749 }
3750
3751
3752 static int _camerasrc_dump_format(camsrc_handle_t handle)
3753 {
3754         camerasrc_handle_t *p = NULL;
3755
3756         camsrc_info("enter");
3757
3758         if (handle == NULL) {
3759                 camsrc_error("handle is null");
3760                 return CAMERASRC_ERR_NULL_POINTER;
3761         }
3762
3763         p = CAMERASRC_HANDLE(handle);
3764
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("------------------------------------");
3774
3775         return CAMERASRC_SUCCESS;
3776 }
3777
3778
3779 int camerasrc_get_exif_info(camsrc_handle_t handle, camerasrc_exif_t *exif_struct)
3780 {
3781         camerasrc_handle_t* p = NULL;
3782         int err = CAMERASRC_ERR_UNKNOWN;
3783
3784         camsrc_info("enter");
3785
3786         if (handle == NULL) {
3787                 camsrc_error("handle is null");
3788                 return CAMERASRC_ERR_NULL_POINTER;
3789         }
3790
3791         p = CAMERASRC_HANDLE(handle);
3792
3793         if (CAMERASRC_PHASE(p) != CAMERASRC_PHASE_RUNNING) {
3794                 camsrc_warning("Invalid state transition");
3795         }
3796
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");
3800         }
3801
3802         return err;
3803 }
3804
3805
3806 int camerasrc_device_is_open(camsrc_handle_t handle)
3807 {
3808         camerasrc_handle_t *p = handle;
3809
3810         if (p) {
3811                 if (p->dev_fd > 0) {
3812                         return TRUE;
3813                 }
3814         }
3815
3816         return FALSE;
3817 }
3818
3819
3820 int camerasrc_set_videofd(camsrc_handle_t handle, int videofd)
3821 {
3822         camerasrc_handle_t *p = handle;
3823
3824         if (p) {
3825                 p->dev_fd = videofd;
3826                 return CAMERASRC_SUCCESS;
3827         } else {
3828                 return CAMERASRC_ERR_INVALID_HANDLE;
3829         }
3830 }
3831
3832
3833 int camerasrc_set_af_hold_after_capture(camsrc_handle_t handle, int hold_af)
3834 {
3835         camerasrc_handle_t *p = NULL;
3836
3837         camsrc_info("enter");
3838
3839         if (handle == NULL) {
3840                 camsrc_error("handle is null");
3841                 return CAMERASRC_ERR_NULL_POINTER;
3842         }
3843
3844         p = CAMERASRC_HANDLE(handle);
3845
3846         p->hold_af_after_capturing = hold_af;
3847
3848         camsrc_info("leave");
3849
3850         return CAMERASRC_SUCCESS;
3851 }
3852
3853
3854 int camerasrc_set_sensor_mode(camsrc_handle_t handle, int mode)
3855 {
3856         camerasrc_handle_t *p = NULL;
3857
3858         camsrc_info("enter");
3859
3860         if (handle == NULL) {
3861                 camsrc_error("handle is null");
3862                 return CAMERASRC_ERR_NULL_POINTER;
3863         }
3864
3865         p = CAMERASRC_HANDLE(handle);
3866
3867         p->sensor_mode = mode;
3868
3869         camsrc_info("leave");
3870
3871         return CAMERASRC_SUCCESS;
3872 }
3873
3874
3875 int camerasrc_set_vflip(camsrc_handle_t handle, int vflip)
3876 {
3877         camerasrc_handle_t *p = NULL;
3878
3879         camsrc_info("enter");
3880
3881         if (handle == NULL) {
3882                 camsrc_error("handle is null");
3883                 return CAMERASRC_ERR_NULL_POINTER;
3884         }
3885
3886         p = CAMERASRC_HANDLE(handle);
3887
3888         p->vflip = vflip;
3889
3890         if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) {
3891                 CAMERASRC_SET_CMD(_CAMERASRC_CMD_VFLIP, &(p->vflip));
3892         }
3893
3894         camsrc_info("leave");
3895
3896         return CAMERASRC_SUCCESS;
3897 }
3898
3899
3900 int camerasrc_set_hflip(camsrc_handle_t handle, int hflip)
3901 {
3902         camerasrc_handle_t *p = NULL;
3903
3904         camsrc_info("enter");
3905
3906         if (handle == NULL) {
3907                 camsrc_error("handle is null");
3908                 return CAMERASRC_ERR_NULL_POINTER;
3909         }
3910
3911         p = CAMERASRC_HANDLE(handle);
3912
3913         p->hflip = hflip;
3914         if (CAMERASRC_STATE(p) > CAMERASRC_STATE_READY) {
3915                 CAMERASRC_SET_CMD(_CAMERASRC_CMD_HFLIP, &(p->hflip));
3916         }
3917
3918         camsrc_info("leave");
3919
3920         return CAMERASRC_SUCCESS;
3921 }
3922
3923
3924 /* For Query functionalities */
3925 int camerasrc_read_basic_dev_info(camerasrc_dev_id_t dev_id, camerasrc_caps_info_t* caps_info)
3926 {
3927         int err = CAMERASRC_ERR_UNKNOWN;
3928         int nread = 0;
3929         char* store_path = NULL;
3930         FILE *fp = NULL;
3931
3932         camsrc_info("enter");
3933
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;
3938         else
3939         {
3940                 camsrc_error("Unsupported device ID");
3941                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
3942         }
3943
3944         fp = fopen(store_path, "rb");
3945         if(fp)
3946         {
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);
3950                 fclose(fp);
3951         }
3952         else
3953                 return CAMERASRC_ERR_ALLOCATION;
3954
3955         err = CAMERASRC_SUCCESS;
3956         camsrc_info("leave");
3957         return err;
3958 }
3959
3960
3961 int camerasrc_read_misc_dev_info(camerasrc_dev_id_t dev_id, camerasrc_ctrl_list_info_t* ctrl_info)
3962 {
3963         int err = CAMERASRC_ERR_UNKNOWN;
3964         camsrc_info("enter");
3965
3966         int nread = 0;
3967         FILE *fp = NULL;
3968         char* store_path = NULL;
3969
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;
3974         else
3975         {
3976                 camsrc_error("Unsupported device ID");
3977                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
3978         }
3979
3980         fp = fopen(store_path, "rb");
3981         if(fp)
3982         {
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);
3986                 fclose(fp);
3987         }
3988         else
3989                 return CAMERASRC_ERR_ALLOCATION;
3990
3991         err = CAMERASRC_SUCCESS;
3992         camsrc_info("leave");
3993         return err;
3994 }
3995
3996
3997 int camerasrc_read_extra_dev_info(camerasrc_dev_id_t dev_id, camerasrc_extra_info_t* extra_info)
3998 {
3999         int err = CAMERASRC_ERR_UNKNOWN;
4000         camsrc_info("enter");
4001
4002         int nread = 0;
4003         FILE *fp = NULL;
4004         char* store_path = NULL;
4005
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;
4010         else
4011         {
4012                 camsrc_error("Unsupported device ID");
4013                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4014         }
4015
4016         fp = fopen(store_path, "rb");
4017         if(fp)
4018         {
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);
4022                 fclose(fp);
4023         }
4024         else
4025                 return CAMERASRC_ERR_ALLOCATION;
4026
4027         err = CAMERASRC_SUCCESS;
4028         camsrc_info("leave");
4029         return err;
4030 }
4031
4032
4033 int camerasrc_write_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info)
4034 {
4035         camerasrc_handle_t* p = NULL;
4036         char* store_path = NULL;
4037         FILE *fp = NULL;
4038
4039         camsrc_info("enter");
4040
4041         if(handle == NULL) {
4042                 camsrc_error("handle is null");
4043                 return CAMERASRC_ERR_NULL_POINTER;
4044         }
4045
4046         p = CAMERASRC_HANDLE(handle);
4047
4048         int nwrite = 0;
4049
4050         if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY)
4051         {
4052                 camsrc_info("Primary(Mega) camera capabilities info will be written..");
4053                 store_path = CAMERASRC_PRIMARY_BASIC_INFO_PATH;
4054         }
4055         else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY)
4056         {
4057                 camsrc_info("Secondary(VGA) camera capabilities info will be written..");
4058                 store_path = CAMERASRC_SECONDARY_BASIC_INFO_PATH;
4059         }
4060         else
4061         {
4062                 camsrc_error("Unsupported device ID");
4063                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4064         }
4065         camsrc_info("PATH = %s", store_path);
4066
4067         fp = fopen(store_path, "wb");
4068         if(fp)
4069         {
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);
4073                 fclose(fp);
4074         }
4075         else
4076                 return CAMERASRC_ERR_ALLOCATION;
4077
4078         camsrc_info("leave");
4079         return CAMERASRC_SUCCESS;
4080 }
4081
4082
4083 int camerasrc_write_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_info)
4084 {
4085         camerasrc_handle_t* p = NULL;
4086
4087         camsrc_info("enter");
4088
4089         if(handle == NULL) {
4090                 camsrc_error("handle is null");
4091                 return CAMERASRC_ERR_NULL_POINTER;
4092         }
4093
4094         p = CAMERASRC_HANDLE(handle);
4095
4096         int nwrite = 0;
4097         FILE *fp = NULL;
4098
4099         char* store_path = NULL;
4100
4101         if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY)
4102         {
4103                 camsrc_info("Primary(Mega) camera controls info will be written..");
4104                 store_path = CAMERASRC_PRIMARY_MISC_INFO_PATH;
4105         }
4106         else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY)
4107         {
4108                 camsrc_info("Secondary(VGA) camera controls info will be written..");
4109                 store_path = CAMERASRC_SECONDARY_MISC_INFO_PATH;
4110         }
4111         else
4112         {
4113                 camsrc_error("Unsupported device ID");
4114                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4115         }
4116
4117         fp = fopen(store_path, "wb");
4118         if(fp)
4119         {
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);
4123                 fclose(fp);
4124         }
4125         else
4126                 return CAMERASRC_ERR_ALLOCATION;
4127
4128         camsrc_info("leave");
4129         return CAMERASRC_SUCCESS;
4130 }
4131
4132
4133 int camerasrc_write_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info)
4134 {
4135         camerasrc_handle_t* p = NULL;
4136
4137         camsrc_info("enter");
4138
4139         if(handle == NULL) {
4140                 camsrc_error("handle is null");
4141                 return CAMERASRC_ERR_NULL_POINTER;
4142         }
4143
4144         p = CAMERASRC_HANDLE(handle);
4145
4146         int nwrite = 0;
4147         FILE *fp = NULL;
4148
4149         char* store_path = NULL;
4150
4151         if(p->cur_dev_id == CAMERASRC_DEV_ID_PRIMARY)
4152         {
4153                 camsrc_info("Primary(Mega) extra controls info will be written..");
4154                 store_path = CAMERASRC_PRIMARY_EXTRA_INFO_PATH;
4155         }
4156         else if (p->cur_dev_id == CAMERASRC_DEV_ID_SECONDARY)
4157         {
4158                 camsrc_info("Secondary(VGA) extra controls info will be written..");
4159                 store_path = CAMERASRC_SECONDARY_EXTRA_INFO_PATH;
4160         }
4161         else
4162         {
4163                 camsrc_error("Unsupported device ID");
4164                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4165         }
4166
4167         fp = fopen(store_path, "wb");
4168         if(fp)
4169         {
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);
4173                 fclose(fp);
4174         }
4175         else
4176                 return CAMERASRC_ERR_ALLOCATION;
4177
4178         camsrc_info("leave");
4179         return CAMERASRC_SUCCESS;
4180 }
4181
4182 void _camerasrc_add_total_resolution_info( camerasrc_caps_info_t* caps_info, int fcc_use, int width, int height )
4183 {
4184         int i = 0;
4185
4186         if( 1 || fcc_use == CAMERASRC_FCC_USE_REC_PREVIEW
4187                         || fcc_use == CAMERASRC_FCC_USE_CAP_PREVIEW )
4188         {
4189                 for( i = 0 ; i < caps_info->num_preview_resolution ; i++ )
4190                 {
4191                         if( caps_info->preview_resolution_width[i] == width
4192                                         && caps_info->preview_resolution_height[i] == height )
4193                         {
4194                                 camsrc_info("preview resolution[%dx%d] is already existed.", width, height);
4195                                 return;
4196                         }
4197                 }
4198
4199                 caps_info->preview_resolution_width[i] = width;
4200                 caps_info->preview_resolution_height[i] = height;
4201                 caps_info->num_preview_resolution++;
4202
4203                 camsrc_info("preview resolution[%dx%d] is added.", width, height);
4204         }
4205         else if( fcc_use == CAMERASRC_FCC_USE_NORMAL_CAPTURE
4206                         || fcc_use == CAMERASRC_FCC_USE_CONT_CAPTURE )
4207         {
4208                 for( i = 0 ; i < caps_info->num_capture_resolution ; i++ )
4209                 {
4210                         if( caps_info->capture_resolution_width[i] == width
4211                                         && caps_info->capture_resolution_height[i] == height )
4212                         {
4213                                 camsrc_info("capture resolution[%dx%d] is already existed.", width, height);
4214                                 return;
4215                         }
4216                 }
4217
4218                 caps_info->capture_resolution_width[i] = width;
4219                 caps_info->capture_resolution_height[i] = height;
4220                 caps_info->num_capture_resolution++;
4221
4222                 camsrc_info("capture resolution[%dx%d] is added.", width, height);
4223         }
4224
4225         return;
4226 }
4227
4228 void _camerasrc_add_total_fps( camerasrc_caps_info_t* caps_info, int numerator, int denominator )
4229 {
4230         int i = 0;
4231
4232         for( i = 0 ; i < caps_info->num_fps ; i++ )
4233         {
4234                 if( caps_info->fps[i].numerator == numerator
4235                                 && caps_info->fps[i].denominator == denominator )
4236                 {
4237                         camsrc_info("fps[%d/%d] is already existed.", numerator, denominator);
4238                         return;
4239                 }
4240         }
4241
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++;
4245
4246         camsrc_info("fps[%d/%d] is added.", numerator, denominator);
4247
4248         return;
4249 }
4250
4251 int _camerasrc_query_pixfmt_timeperframe(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info, int fmt_index, int resolution_index )
4252 {
4253         int tpf_cnt = 0;
4254         struct v4l2_frmivalenum vfrmivalenum;
4255         unsigned int fcc = 0;
4256         camerasrc_resolution_t* resolutions = NULL;
4257
4258         if( !handle || !caps_info )
4259         {
4260                 camsrc_info("handle[%p] or caps_info[%p] is NULL.", handle, caps_info);
4261                 return CAMERASRC_ERR_NULL_POINTER;
4262         }
4263
4264         if( 0 > fmt_index || 0 > resolution_index )
4265         {
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;
4269         }
4270
4271         fcc = caps_info->fmt_desc[fmt_index].fcc;
4272         resolutions = &(caps_info->fmt_desc[fmt_index].resolutions[resolution_index]);
4273
4274         /*
4275                 *How many resolutions are supported in this format
4276                 */
4277         CLEAR(vfrmivalenum);
4278         vfrmivalenum.index = tpf_cnt;
4279         vfrmivalenum.pixel_format = fcc;
4280         vfrmivalenum.width = resolutions->w;
4281         vfrmivalenum.height = resolutions->h;
4282
4283         while(0 == _camerasrc_ioctl(handle,  VIDIOC_ENUM_FRAMEINTERVALS, &vfrmivalenum))
4284         {
4285                 resolutions->tpf[tpf_cnt].num = vfrmivalenum.discrete.numerator;
4286                 resolutions->tpf[tpf_cnt].den = vfrmivalenum.discrete.denominator;
4287                 tpf_cnt++;
4288
4289                 _camerasrc_add_total_fps( caps_info, vfrmivalenum.discrete.denominator, vfrmivalenum.discrete.numerator );
4290         }
4291
4292         if(tpf_cnt == 0)
4293         {
4294                 camsrc_info("No timeperframe supported. driver may not support to query");
4295                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4296         }
4297
4298         resolutions->num_avail_tpf = tpf_cnt;
4299
4300         return CAMERASRC_SUCCESS;
4301 }
4302
4303 int _camerasrc_query_pixfmt_resolution(camerasrc_handle_t* handle, camerasrc_caps_info_t* caps_info, int fmt_index )
4304 {
4305         int res_cnt = 0;
4306         int err = CAMERASRC_ERR_UNKNOWN;
4307         struct v4l2_frmsizeenum vfrmszenum;
4308         camerasrc_fmt_desc_t* fmt_desc = NULL;
4309
4310         if( !handle || !caps_info )
4311         {
4312                 camsrc_info("handle[%p] or caps_info[%p] is NULL.", handle, caps_info);
4313                 return CAMERASRC_ERR_NULL_POINTER;
4314         }
4315
4316         if( 0 > fmt_index )
4317         {
4318                 camsrc_info("fmt_index[%d] is too small.", fmt_index);
4319                 return CAMERASRC_ERR_RANGE_UNDER;
4320         }
4321
4322         fmt_desc = &caps_info->fmt_desc[fmt_index];
4323
4324         /*
4325                 *How many resolutions are supported in this format
4326                 */
4327         CLEAR(vfrmszenum);
4328         vfrmszenum.index = res_cnt;
4329         vfrmszenum.pixel_format = fmt_desc->fcc;
4330         while(0 == _camerasrc_ioctl(handle,  VIDIOC_ENUM_FRAMESIZES, &vfrmszenum))
4331         {
4332                 fmt_desc->resolutions[res_cnt].w = vfrmszenum.discrete.width;
4333                 fmt_desc->resolutions[res_cnt].h = vfrmszenum.discrete.height;
4334
4335                 _camerasrc_add_total_resolution_info( caps_info, caps_info->fmt_desc[fmt_index].fcc_use,
4336                                 vfrmszenum.discrete.width, vfrmszenum.discrete.height );
4337
4338                 err = _camerasrc_query_pixfmt_timeperframe(handle, caps_info, fmt_index, res_cnt);
4339                 if(err != CAMERASRC_SUCCESS)
4340                 {
4341                         camsrc_info("timeperframe querying error, err = %d", err);
4342                         return err;
4343                 }
4344
4345                 res_cnt++;
4346                 vfrmszenum.index = res_cnt;
4347         }
4348
4349         if(res_cnt == 0)
4350         {
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;
4353         }
4354
4355         fmt_desc->num_resolution = res_cnt;
4356
4357         return CAMERASRC_SUCCESS;
4358 }
4359
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;
4364         int fmt_cnt = 0;
4365         char err_msg[CAMERASRC_ERRMSG_MAX_LEN] = {'\0',};
4366
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;
4372
4373         /*
4374          * Count how many formats are supported in this dev
4375          */
4376         CLEAR(vfmtdesc);
4377         CLEAR(vinput);
4378
4379         /*
4380          * What name of module is selected?
4381          */
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;
4386         }
4387         memcpy(caps_info->dev_name, vinput.name, 32);
4388
4389         vfmtdesc.index = 0;
4390         vfmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
4391         while(0 == _camerasrc_ioctl(handle,  VIDIOC_ENUM_FMT, &vfmtdesc))
4392         {
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;
4400                 /*
4401                         * Along the description of the format, we seperate them into each usecase
4402                         */
4403                 camsrc_info("description \"%s\"", vfmtdesc.description );
4404                 if(!strcmp("rec_prev", (const char*)(vfmtdesc.description)))
4405                 {
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++;
4409                 }
4410                 else if(!strcmp("cap_prev", (const char*)(vfmtdesc.description)))
4411                 {
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++;
4415                 }
4416                 else if(!strcmp("recording", (const char*)(vfmtdesc.description)))
4417                 {
4418                         caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_RECORDING;
4419                 }
4420                 else if(!strcmp("capture", (const char*)(vfmtdesc.description)))
4421                 {
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++;
4425                 }
4426                 else if(!strcmp("cont_cap", (const char*)(vfmtdesc.description)))
4427                 {
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++;
4431                 }
4432                 else
4433                 {
4434                         caps_info->fmt_desc[fmt_cnt].fcc_use = CAMERASRC_FCC_USE_NONE;
4435                 }
4436                 err = _camerasrc_query_pixfmt_resolution(handle, caps_info, fmt_cnt);
4437                 if(err != CAMERASRC_SUCCESS)
4438                 {
4439                         camsrc_info("pixel format querying error, err = %x", err);
4440                 }
4441                 fmt_cnt++;
4442                 vfmtdesc.index = fmt_cnt;
4443                 vfmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
4444         }
4445
4446
4447         /*
4448                 * memory allocation as counted num
4449                 */
4450         camsrc_info("Total supported format = %d", fmt_cnt);
4451         caps_info->num_fmt_desc = fmt_cnt;
4452
4453         /*
4454                 * If no formats supported
4455                 */
4456         if(fmt_cnt == 0)
4457         {
4458                 camsrc_info("no format supported");
4459                 return CAMERASRC_ERR_DEVICE_NOT_SUPPORT;
4460         }
4461         return CAMERASRC_SUCCESS;
4462 }
4463
4464
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;
4468
4469         camsrc_info("enter");
4470
4471         if(handle == NULL) {
4472                 camsrc_error("handle is null");
4473                 return CAMERASRC_ERR_NULL_POINTER;
4474         }
4475
4476         p = CAMERASRC_HANDLE(handle);
4477
4478         err = _camerasrc_query_basic_dev_info(p, caps_info);
4479
4480         err = CAMERASRC_SUCCESS;
4481         camsrc_info("leave");
4482
4483         return err;
4484 }
4485
4486 int _camerasrc_query_ctrl_menu (camerasrc_handle_t* handle, struct v4l2_queryctrl queryctrl, camerasrc_ctrl_info_t* ctrl_info)
4487 {
4488         struct v4l2_querymenu querymenu;
4489
4490         camsrc_info("  Menu items:");
4491
4492         memset (&querymenu, 0, sizeof (querymenu));
4493         querymenu.id = queryctrl.id;
4494
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);
4502                 } else {
4503                         camsrc_error("VIDIOC_QUERYMENU error");
4504                         return CAMERASRC_ERR_IO_CONTROL;
4505                 }
4506         }
4507         return CAMERASRC_SUCCESS;
4508 }
4509
4510 static int _find_camsrc_ctrl_id(camerasrc_handle_t* handle, int v4l2_cid)
4511 {
4512         int i = 0;
4513         int tmp_id = 0;
4514         for(i=0; i<CAMERASRC_CTRL_NUM; i++)
4515         {
4516                 tmp_id = _CAMERASRC_GET_CID(i, handle->cur_dev_id);
4517                 if(tmp_id == v4l2_cid)
4518                         return i;
4519         }
4520
4521         return -1;
4522 }
4523
4524 int _camerasrc_query_misc_dev_info(camerasrc_handle_t* handle, camerasrc_ctrl_list_info_t* ctrl_list_info)
4525 {
4526         struct v4l2_queryctrl queryctrl;
4527
4528         int i = 0;
4529         int ctrl_cnt = 0;
4530
4531
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)
4536                 {
4537                         continue;
4538                 }
4539                 if (0 == _camerasrc_ioctl (handle, VIDIOC_QUERYCTRL, &queryctrl)) {
4540                         if (queryctrl.flags & V4L2_CTRL_FLAG_DISABLED)
4541                         {
4542                                 camsrc_info("ID [%8x] disabled", queryctrl.id);
4543                                 /*continue;*/
4544                         }
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)
4549                         {
4550                                 camsrc_warning("This control is not included in camsrc ctrl ID error");
4551                         }
4552                         switch(queryctrl.type)
4553                         {
4554                                 case V4L2_CTRL_TYPE_INTEGER:
4555                                         ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_RANGE;
4556                                         break;
4557                                 case V4L2_CTRL_TYPE_BOOLEAN:
4558                                         ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_BOOL;
4559                                         break;
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]));
4563                                         break;
4564                                 default:
4565                                         ctrl_list_info->ctrl_info[ctrl_cnt].ctrl_type = CTRL_TYPE_UNKNOWN;
4566                                         break;
4567                         }
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);
4574                 } else {
4575                         if (errno == EINVAL)
4576                                 continue;
4577                         camsrc_error("VIDIOC_QUERYCTRL error");
4578                         return CAMERASRC_ERR_IO_CONTROL;
4579                 }
4580                 ctrl_cnt++;
4581         }
4582         ctrl_list_info->num_ctrl_list_info = ctrl_cnt;
4583         return CAMERASRC_SUCCESS;
4584 }
4585
4586
4587 int camerasrc_query_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info)
4588 {
4589         camerasrc_handle_t* p = NULL;
4590         int err = CAMERASRC_ERR_UNKNOWN;
4591
4592         camsrc_info("enter");
4593
4594         if(handle == NULL) {
4595                 camsrc_error("handle is null");
4596                 return CAMERASRC_ERR_NULL_POINTER;
4597         }
4598
4599         p = CAMERASRC_HANDLE(handle);
4600
4601         err = _camerasrc_query_misc_dev_info(p, ctrl_list_info);
4602
4603         err = CAMERASRC_SUCCESS;
4604
4605         camsrc_info("leave");
4606
4607         return err;
4608 }
4609
4610
4611 int camerasrc_query_misc_dev_ctrl_info(camsrc_handle_t handle, camerasrc_ctrl_t ctrl_id, camerasrc_ctrl_info_t* ctrl_info)
4612 {
4613         struct v4l2_queryctrl queryctrl;
4614
4615         CLEAR(queryctrl);
4616
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)
4620                 {
4621                         camsrc_info("ID [%8x] disabled", queryctrl.id);
4622                 }
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)
4627                 {
4628                         camsrc_warning("This control is not included in camsrc ctrl ID error");
4629                 }
4630                 switch(queryctrl.type)
4631                 {
4632                         case V4L2_CTRL_TYPE_INTEGER:
4633                                 ctrl_info->ctrl_type = CTRL_TYPE_RANGE;
4634                                 break;
4635                         case V4L2_CTRL_TYPE_BOOLEAN:
4636                                 ctrl_info->ctrl_type = CTRL_TYPE_BOOL;
4637                                 break;
4638                         case V4L2_CTRL_TYPE_MENU:
4639                                 ctrl_info->ctrl_type = CTRL_TYPE_ARRAY;
4640                                 _camerasrc_query_ctrl_menu (handle, queryctrl, ctrl_info);
4641                                 break;
4642                         default:
4643                                 ctrl_info->ctrl_type = CTRL_TYPE_UNKNOWN;
4644                                 break;
4645                 }
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);
4652         } else {
4653                 camsrc_error("VIDIOC_QUERYCTRL error");
4654                 return CAMERASRC_ERR_IO_CONTROL;
4655         }
4656         return CAMERASRC_SUCCESS;
4657 }
4658
4659
4660 int camerasrc_dump_misc_dev_info(camsrc_handle_t handle, camerasrc_ctrl_list_info_t* ctrl_list_info)
4661 {
4662         camsrc_info("enter");
4663         int i=0;
4664         int j=0;
4665
4666         camsrc_info("============================================================");
4667         for(i = 0; i < ctrl_list_info->num_ctrl_list_info; i++)
4668         {
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)
4673                 {
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++)
4676                         {
4677                                 camsrc_info("\t\t    * %s", ctrl_list_info->ctrl_info[i].ctrl_menu[j].menu_name);
4678                         }
4679                 }
4680         }
4681         camsrc_info("============================================================");
4682         camsrc_info("leave");
4683         return CAMERASRC_SUCCESS;
4684 }
4685
4686
4687 int camerasrc_dump_basic_dev_info(camsrc_handle_t handle, camerasrc_caps_info_t* caps_info) {
4688         camsrc_info("enter");
4689         int i,j,k;
4690
4691         camsrc_info("===============================================================");
4692         for(i = 0; i< caps_info->num_fmt_desc; i++)
4693         {
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++)
4702                 {
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++)
4707                         {
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);
4709                         }
4710                 }
4711         }
4712         camsrc_info("===============================================================");
4713         camsrc_info("total supported preview resolution");
4714         for( i = 0 ; i < caps_info->num_preview_resolution ; i++ )
4715         {
4716                 camsrc_info("%5dx%5d", caps_info->preview_resolution_width[i], caps_info->preview_resolution_height[i]);
4717
4718         }
4719         camsrc_info("===============================================================");
4720         camsrc_info("total supported capture resolution");
4721         for( i = 0 ; i < caps_info->num_capture_resolution ; i++ )
4722         {
4723                 camsrc_info("%5dx%5d", caps_info->capture_resolution_width[i], caps_info->capture_resolution_height[i]);
4724
4725         }
4726         camsrc_info("===============================================================");
4727         camsrc_info("total supported preview fourcc");
4728         for( i = 0 ; i < caps_info->num_preview_fmt ; i++ )
4729         {
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]);
4736         }
4737         camsrc_info("===============================================================");
4738         camsrc_info("total supported capture fourcc");
4739         for( i = 0 ; i < caps_info->num_capture_fmt ; i++ )
4740         {
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]);
4747         }
4748         camsrc_info("===============================================================");
4749         camsrc_info("total supported fps");
4750         for( i = 0 ; i < caps_info->num_fps ; i++ )
4751         {
4752                 camsrc_info("%3d/%3d", caps_info->fps[i].numerator, caps_info->fps[i].denominator);
4753         }
4754         camsrc_info("===============================================================");
4755         camsrc_info("leave");
4756         return CAMERASRC_SUCCESS;
4757 }
4758
4759
4760 int camerasrc_dump_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info)
4761 {
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");
4767         } else {
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");
4786         }
4787
4788         if (extra_info->detection_caps) {
4789                 camsrc_info(" Facedetection can be supported");
4790         } else {
4791                 camsrc_info(" Facedetection can't be supported");
4792         }
4793
4794         camsrc_info("===============================================================");
4795         camsrc_info("leave");
4796
4797         return CAMERASRC_SUCCESS;
4798 }
4799
4800 static int _camerasrc_query_extra_dev_info(camerasrc_handle_t* handle, camerasrc_extra_info_t* extra_info)
4801 {
4802         struct v4l2_capability capability;
4803
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)
4807                 {
4808                         /* Strobe supported */
4809                         struct v4l2_strobe strobecaps;
4810                         if (0 == _camerasrc_ioctl (handle, VIDIOC_G_STROBE, &strobecaps))
4811                         {
4812                                 extra_info->strobe_caps = strobecaps.capabilities;
4813                         }
4814                         else
4815                         {
4816                                 camsrc_error("VIDIOC_G_STROBE error");
4817                                 return CAMERASRC_ERR_IO_CONTROL;
4818                         }
4819                 }
4820                 else
4821                 {
4822                         /* Strobe NOT supported */
4823                         camsrc_error("STROBE not supported");
4824                         extra_info->strobe_caps = 0;
4825                 }
4826
4827                 if((capability.capabilities & V4L2_CAP_OBJ_RECOGNITION) != 0)
4828                 {
4829                         /* Recognition supported */
4830                         extra_info->detection_caps = 1;
4831                 }
4832                 else
4833                 {
4834                         camsrc_error("FACEDETECTION not supported");
4835                         extra_info->detection_caps = 0;
4836                         /* Recognition NOT supported */
4837                 }
4838
4839                 return CAMERASRC_SUCCESS;
4840         } else {
4841                 camsrc_error("VIDIOC_QUERYCAP error");
4842
4843                 return CAMERASRC_ERR_IO_CONTROL;
4844         }
4845 }
4846
4847
4848 int camerasrc_query_extra_dev_info(camsrc_handle_t handle, camerasrc_extra_info_t* extra_info)
4849 {
4850         camerasrc_handle_t* p = NULL;
4851         int err = CAMERASRC_ERR_UNKNOWN;
4852
4853         camsrc_info("enter");
4854
4855         if(handle == NULL) {
4856                 camsrc_error("handle is null");
4857                 return CAMERASRC_ERR_NULL_POINTER;
4858         }
4859
4860         p = CAMERASRC_HANDLE(handle);
4861
4862         err = _camerasrc_query_extra_dev_info(p, extra_info);
4863
4864         err = CAMERASRC_SUCCESS;
4865         camsrc_info("leave");
4866
4867         return err;
4868 }
4869
4870 /* END For Query functionalities */