1 /* 2 * Copyright 2008, The Android Open Source Project 3 * Copyright 2010, Samsung Electronics Co. LTD 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /* 19 ************************************ 20 * Filename: SecCamera.cpp 21 * Author: Sachin P. Kamat 22 * Purpose: This file interacts with the Camera and JPEG drivers. 23 ************************************* 24 */ 25 26 //#define LOG_NDEBUG 0 27 #define LOG_TAG "SecCamera" 28 29 #include <utils/Log.h> 30 31 #include <math.h> 32 #include <string.h> 33 #include <stdlib.h> 34 #include <sys/poll.h> 35 #include "SecCamera.h" 36 #include "cutils/properties.h" 37 38 using namespace android; 39 40 #define CHECK(return_value) \ 41 if (return_value < 0) { \ 42 LOGE("%s::%d fail. errno: %s, m_camera_id = %d\n", \ 43 __func__, __LINE__, strerror(errno), m_camera_id); \ 44 return -1; \ 45 } 46 47 48 #define CHECK_PTR(return_value) \ 49 if (return_value < 0) { \ 50 LOGE("%s::%d fail, errno: %s, m_camera_id = %d\n", \ 51 __func__,__LINE__, strerror(errno), m_camera_id); \ 52 return NULL; \ 53 } 54 55 #define ALIGN_TO_32B(x) ((((x) + (1 << 5) - 1) >> 5) << 5) 56 #define ALIGN_TO_128B(x) ((((x) + (1 << 7) - 1) >> 7) << 7) 57 #define ALIGN_TO_8KB(x) ((((x) + (1 << 13) - 1) >> 13) << 13) 58 59 namespace android { 60 61 // ====================================================================== 62 // Camera controls 63 64 static struct timeval time_start; 65 static struct timeval time_stop; 66 67 unsigned long measure_time(struct timeval *start, struct timeval *stop) 68 { 69 unsigned long sec, usec, time; 70 71 sec = stop->tv_sec - start->tv_sec; 72 73 if (stop->tv_usec >= start->tv_usec) { 74 usec = stop->tv_usec - start->tv_usec; 75 } else { 76 usec = stop->tv_usec + 1000000 - start->tv_usec; 77 sec--; 78 } 79 80 time = (sec * 1000000) + usec; 81 82 return time; 83 } 84 85 static int get_pixel_depth(unsigned int fmt) 86 { 87 int depth = 0; 88 89 switch (fmt) { 90 case V4L2_PIX_FMT_NV12: 91 depth = 12; 92 break; 93 case V4L2_PIX_FMT_NV12T: 94 depth = 12; 95 break; 96 case V4L2_PIX_FMT_NV21: 97 depth = 12; 98 break; 99 case V4L2_PIX_FMT_YUV420: 100 depth = 12; 101 break; 102 103 case V4L2_PIX_FMT_RGB565: 104 case V4L2_PIX_FMT_YUYV: 105 case V4L2_PIX_FMT_YVYU: 106 case V4L2_PIX_FMT_UYVY: 107 case V4L2_PIX_FMT_VYUY: 108 case V4L2_PIX_FMT_NV16: 109 case V4L2_PIX_FMT_NV61: 110 case V4L2_PIX_FMT_YUV422P: 111 depth = 16; 112 break; 113 114 case V4L2_PIX_FMT_RGB32: 115 depth = 32; 116 break; 117 } 118 119 return depth; 120 } 121 122 #define ALIGN_W(x) (((x) + 0x7F) & (~0x7F)) // Set as multiple of 128 123 #define ALIGN_H(x) (((x) + 0x1F) & (~0x1F)) // Set as multiple of 32 124 #define ALIGN_BUF(x) (((x) + 0x1FFF)& (~0x1FFF)) // Set as multiple of 8K 125 126 static int fimc_poll(struct pollfd *events) 127 { 128 int ret; 129 130 /* 10 second delay is because sensor can take a long time 131 * to do auto focus and capture in dark settings 132 */ 133 ret = poll(events, 1, 10000); 134 if (ret < 0) { 135 LOGE("ERR(%s):poll error\n", __func__); 136 return ret; 137 } 138 139 if (ret == 0) { 140 LOGE("ERR(%s):No data in 10 secs..\n", __func__); 141 return ret; 142 } 143 144 return ret; 145 } 146 147 int SecCamera::previewPoll(bool preview) 148 { 149 int ret; 150 151 if (preview) { 152 #ifdef ENABLE_ESD_PREVIEW_CHECK 153 int status = 0; 154 155 if (!(++m_esd_check_count % 60)) { 156 status = getCameraSensorESDStatus(); 157 m_esd_check_count = 0; 158 if (status) { 159 LOGE("ERR(%s) ESD status(%d)", __func__, status); 160 return status; 161 } 162 } 163 #endif 164 165 ret = poll(&m_events_c, 1, 1000); 166 } else { 167 ret = poll(&m_events_c2, 1, 1000); 168 } 169 170 if (ret < 0) { 171 LOGE("ERR(%s):poll error\n", __func__); 172 return ret; 173 } 174 175 if (ret == 0) { 176 LOGE("ERR(%s):No data in 1 secs.. Camera Device Reset \n", __func__); 177 return ret; 178 } 179 180 return ret; 181 } 182 183 static int fimc_v4l2_querycap(int fp) 184 { 185 struct v4l2_capability cap; 186 int ret = 0; 187 188 ret = ioctl(fp, VIDIOC_QUERYCAP, &cap); 189 190 if (ret < 0) { 191 LOGE("ERR(%s):VIDIOC_QUERYCAP failed\n", __func__); 192 return -1; 193 } 194 195 if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { 196 LOGE("ERR(%s):no capture devices\n", __func__); 197 return -1; 198 } 199 200 return ret; 201 } 202 203 static const __u8* fimc_v4l2_enuminput(int fp, int index) 204 { 205 static struct v4l2_input input; 206 207 input.index = index; 208 if (ioctl(fp, VIDIOC_ENUMINPUT, &input) != 0) { 209 LOGE("ERR(%s):No matching index found\n", __func__); 210 return NULL; 211 } 212 LOGI("Name of input channel[%d] is %s\n", input.index, input.name); 213 214 return input.name; 215 } 216 217 218 static int fimc_v4l2_s_input(int fp, int index) 219 { 220 struct v4l2_input input; 221 int ret; 222 223 input.index = index; 224 225 ret = ioctl(fp, VIDIOC_S_INPUT, &input); 226 if (ret < 0) { 227 LOGE("ERR(%s):VIDIOC_S_INPUT failed\n", __func__); 228 return ret; 229 } 230 231 return ret; 232 } 233 234 static int fimc_v4l2_s_fmt(int fp, int width, int height, unsigned int fmt, int flag_capture) 235 { 236 struct v4l2_format v4l2_fmt; 237 struct v4l2_pix_format pixfmt; 238 int ret; 239 240 v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 241 242 memset(&pixfmt, 0, sizeof(pixfmt)); 243 244 pixfmt.width = width; 245 pixfmt.height = height; 246 pixfmt.pixelformat = fmt; 247 248 pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8; 249 250 pixfmt.field = V4L2_FIELD_NONE; 251 252 v4l2_fmt.fmt.pix = pixfmt; 253 254 /* Set up for capture */ 255 ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt); 256 if (ret < 0) { 257 LOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__); 258 return -1; 259 } 260 261 return 0; 262 } 263 264 static int fimc_v4l2_s_fmt_cap(int fp, int width, int height, unsigned int fmt) 265 { 266 struct v4l2_format v4l2_fmt; 267 struct v4l2_pix_format pixfmt; 268 int ret; 269 270 memset(&pixfmt, 0, sizeof(pixfmt)); 271 272 v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 273 274 pixfmt.width = width; 275 pixfmt.height = height; 276 pixfmt.pixelformat = fmt; 277 if (fmt == V4L2_PIX_FMT_JPEG) { 278 pixfmt.colorspace = V4L2_COLORSPACE_JPEG; 279 } 280 281 pixfmt.sizeimage = (width * height * get_pixel_depth(fmt)) / 8; 282 283 v4l2_fmt.fmt.pix = pixfmt; 284 285 //LOGE("ori_w %d, ori_h %d, w %d, h %d\n", width, height, v4l2_fmt.fmt.pix.width, v4l2_fmt.fmt.pix.height); 286 287 /* Set up for capture */ 288 ret = ioctl(fp, VIDIOC_S_FMT, &v4l2_fmt); 289 if (ret < 0) { 290 LOGE("ERR(%s):VIDIOC_S_FMT failed\n", __func__); 291 return ret; 292 } 293 294 return ret; 295 } 296 297 static int fimc_v4l2_enum_fmt(int fp, unsigned int fmt) 298 { 299 struct v4l2_fmtdesc fmtdesc; 300 int found = 0; 301 302 fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 303 fmtdesc.index = 0; 304 305 while (ioctl(fp, VIDIOC_ENUM_FMT, &fmtdesc) == 0) { 306 if (fmtdesc.pixelformat == fmt) { 307 LOGV("passed fmt = %#x found pixel format[%d]: %s\n", fmt, fmtdesc.index, fmtdesc.description); 308 found = 1; 309 break; 310 } 311 312 fmtdesc.index++; 313 } 314 315 if (!found) { 316 LOGE("unsupported pixel format\n"); 317 return -1; 318 } 319 320 return 0; 321 } 322 323 static int fimc_v4l2_reqbufs(int fp, enum v4l2_buf_type type, int nr_bufs) 324 { 325 struct v4l2_requestbuffers req; 326 int ret; 327 328 req.count = nr_bufs; 329 req.type = type; 330 req.memory = V4L2_MEMORY_MMAP; 331 332 ret = ioctl(fp, VIDIOC_REQBUFS, &req); 333 if (ret < 0) { 334 LOGE("ERR(%s):VIDIOC_REQBUFS failed\n", __func__); 335 return -1; 336 } 337 338 return req.count; 339 } 340 341 static int fimc_v4l2_querybuf(int fp, struct fimc_buffer *buffer, enum v4l2_buf_type type) 342 { 343 struct v4l2_buffer v4l2_buf; 344 int ret; 345 346 LOGI("%s :", __func__); 347 348 v4l2_buf.type = type; 349 v4l2_buf.memory = V4L2_MEMORY_MMAP; 350 v4l2_buf.index = 0; 351 352 ret = ioctl(fp , VIDIOC_QUERYBUF, &v4l2_buf); 353 if (ret < 0) { 354 LOGE("ERR(%s):VIDIOC_QUERYBUF failed\n", __func__); 355 return -1; 356 } 357 358 buffer->length = v4l2_buf.length; 359 if ((buffer->start = (char *)mmap(0, v4l2_buf.length, 360 PROT_READ | PROT_WRITE, MAP_SHARED, 361 fp, v4l2_buf.m.offset)) < 0) { 362 LOGE("%s %d] mmap() failed\n",__func__, __LINE__); 363 return -1; 364 } 365 366 LOGI("%s: buffer->start = %p v4l2_buf.length = %d", 367 __func__, buffer->start, v4l2_buf.length); 368 369 return 0; 370 } 371 372 static int fimc_v4l2_streamon(int fp) 373 { 374 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 375 int ret; 376 377 ret = ioctl(fp, VIDIOC_STREAMON, &type); 378 if (ret < 0) { 379 LOGE("ERR(%s):VIDIOC_STREAMON failed\n", __func__); 380 return ret; 381 } 382 383 return ret; 384 } 385 386 static int fimc_v4l2_streamoff(int fp) 387 { 388 enum v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 389 int ret; 390 391 LOGV("%s :", __func__); 392 ret = ioctl(fp, VIDIOC_STREAMOFF, &type); 393 if (ret < 0) { 394 LOGE("ERR(%s):VIDIOC_STREAMOFF failed\n", __func__); 395 return ret; 396 } 397 398 return ret; 399 } 400 401 static int fimc_v4l2_qbuf(int fp, int index) 402 { 403 struct v4l2_buffer v4l2_buf; 404 int ret; 405 406 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 407 v4l2_buf.memory = V4L2_MEMORY_MMAP; 408 v4l2_buf.index = index; 409 410 ret = ioctl(fp, VIDIOC_QBUF, &v4l2_buf); 411 if (ret < 0) { 412 LOGE("ERR(%s):VIDIOC_QBUF failed\n", __func__); 413 return ret; 414 } 415 416 return 0; 417 } 418 419 static int fimc_v4l2_dqbuf(int fp) 420 { 421 struct v4l2_buffer v4l2_buf; 422 int ret; 423 424 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 425 v4l2_buf.memory = V4L2_MEMORY_MMAP; 426 427 ret = ioctl(fp, VIDIOC_DQBUF, &v4l2_buf); 428 if (ret < 0) { 429 LOGE("ERR(%s):VIDIOC_DQBUF failed, dropped frame\n", __func__); 430 return ret; 431 } 432 433 return v4l2_buf.index; 434 } 435 436 static int fimc_v4l2_g_ctrl(int fp, unsigned int id) 437 { 438 struct v4l2_control ctrl; 439 int ret; 440 441 ctrl.id = id; 442 443 ret = ioctl(fp, VIDIOC_G_CTRL, &ctrl); 444 if (ret < 0) { 445 LOGE("ERR(%s): VIDIOC_G_CTRL(id = 0x%x (%d)) failed, ret = %d\n", 446 __func__, id, id-V4L2_CID_PRIVATE_BASE, ret); 447 return ret; 448 } 449 450 return ctrl.value; 451 } 452 453 static int fimc_v4l2_s_ctrl(int fp, unsigned int id, unsigned int value) 454 { 455 struct v4l2_control ctrl; 456 int ret; 457 458 ctrl.id = id; 459 ctrl.value = value; 460 461 ret = ioctl(fp, VIDIOC_S_CTRL, &ctrl); 462 if (ret < 0) { 463 LOGE("ERR(%s):VIDIOC_S_CTRL(id = %#x (%d), value = %d) failed ret = %d\n", 464 __func__, id, id-V4L2_CID_PRIVATE_BASE, value, ret); 465 466 return ret; 467 } 468 469 return ctrl.value; 470 } 471 472 static int fimc_v4l2_s_ext_ctrl(int fp, unsigned int id, void *value) 473 { 474 struct v4l2_ext_controls ctrls; 475 struct v4l2_ext_control ctrl; 476 int ret; 477 478 ctrl.id = id; 479 ctrl.reserved = value; 480 481 ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA; 482 ctrls.count = 1; 483 ctrls.controls = &ctrl; 484 485 ret = ioctl(fp, VIDIOC_S_EXT_CTRLS, &ctrls); 486 if (ret < 0) 487 LOGE("ERR(%s):VIDIOC_S_EXT_CTRLS failed\n", __func__); 488 489 return ret; 490 } 491 492 static int fimc_v4l2_g_parm(int fp, struct v4l2_streamparm *streamparm) 493 { 494 int ret; 495 496 streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 497 498 ret = ioctl(fp, VIDIOC_G_PARM, streamparm); 499 if (ret < 0) { 500 LOGE("ERR(%s):VIDIOC_G_PARM failed\n", __func__); 501 return -1; 502 } 503 504 LOGV("%s : timeperframe: numerator %d, denominator %d\n", __func__, 505 streamparm->parm.capture.timeperframe.numerator, 506 streamparm->parm.capture.timeperframe.denominator); 507 508 return 0; 509 } 510 511 static int fimc_v4l2_s_parm(int fp, struct v4l2_streamparm *streamparm) 512 { 513 int ret; 514 515 streamparm->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 516 517 ret = ioctl(fp, VIDIOC_S_PARM, streamparm); 518 if (ret < 0) { 519 LOGE("ERR(%s):VIDIOC_S_PARM failed\n", __func__); 520 return ret; 521 } 522 523 return 0; 524 } 525 526 // ====================================================================== 527 // Constructor & Destructor 528 529 SecCamera::SecCamera() : 530 m_flag_init(0), 531 m_camera_id(CAMERA_ID_BACK), 532 m_cam_fd(-1), 533 m_cam_fd2(-1), 534 m_preview_v4lformat(V4L2_PIX_FMT_NV21), 535 m_preview_width (0), 536 m_preview_height (0), 537 m_preview_max_width (MAX_BACK_CAMERA_PREVIEW_WIDTH), 538 m_preview_max_height (MAX_BACK_CAMERA_PREVIEW_HEIGHT), 539 m_snapshot_v4lformat(-1), 540 m_snapshot_width (0), 541 m_snapshot_height (0), 542 m_snapshot_max_width (MAX_BACK_CAMERA_SNAPSHOT_WIDTH), 543 m_snapshot_max_height (MAX_BACK_CAMERA_SNAPSHOT_HEIGHT), 544 m_angle(-1), 545 m_anti_banding(-1), 546 m_wdr(-1), 547 m_anti_shake(-1), 548 m_zoom_level(-1), 549 m_object_tracking(-1), 550 m_smart_auto(-1), 551 m_beauty_shot(-1), 552 m_vintage_mode(-1), 553 m_face_detect(-1), 554 m_gps_enabled(false), 555 m_gps_latitude(-1), 556 m_gps_longitude(-1), 557 m_gps_altitude(-1), 558 m_gps_timestamp(-1), 559 m_vtmode(0), 560 m_sensor_mode(-1), 561 m_shot_mode(-1), 562 m_exif_orientation(-1), 563 m_blur_level(-1), 564 m_chk_dataline(-1), 565 m_video_gamma(-1), 566 m_slow_ae(-1), 567 m_camera_af_flag(-1), 568 m_flag_camera_start(0), 569 m_jpeg_thumbnail_width (0), 570 m_jpeg_thumbnail_height(0), 571 m_jpeg_quality(100) 572 #ifdef ENABLE_ESD_PREVIEW_CHECK 573 , 574 m_esd_check_count(0) 575 #endif // ENABLE_ESD_PREVIEW_CHECK 576 { 577 m_params = (struct sec_cam_parm*)&m_streamparm.parm.raw_data; 578 struct v4l2_captureparm capture; 579 m_params->capture.timeperframe.numerator = 1; 580 m_params->capture.timeperframe.denominator = 0; 581 m_params->contrast = -1; 582 m_params->effects = -1; 583 m_params->brightness = -1; 584 m_params->flash_mode = -1; 585 m_params->focus_mode = -1; 586 m_params->iso = -1; 587 m_params->metering = -1; 588 m_params->saturation = -1; 589 m_params->scene_mode = -1; 590 m_params->sharpness = -1; 591 m_params->white_balance = -1; 592 593 memset(&m_capture_buf, 0, sizeof(m_capture_buf)); 594 595 LOGV("%s :", __func__); 596 } 597 598 SecCamera::~SecCamera() 599 { 600 LOGV("%s :", __func__); 601 } 602 603 int SecCamera::initCamera(int index) 604 { 605 LOGV("%s :", __func__); 606 int ret = 0; 607 608 if (!m_flag_init) { 609 /* Arun C 610 * Reset the lense position only during camera starts; don't do 611 * reset between shot to shot 612 */ 613 m_camera_af_flag = -1; 614 615 m_cam_fd = open(CAMERA_DEV_NAME, O_RDWR); 616 if (m_cam_fd < 0) { 617 LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME, strerror(errno)); 618 return -1; 619 } 620 LOGV("%s: open(%s) --> m_cam_fd %d", __FUNCTION__, CAMERA_DEV_NAME, m_cam_fd); 621 622 LOGE("initCamera: m_cam_fd(%d), m_jpeg_fd(%d)", m_cam_fd, m_jpeg_fd); 623 624 ret = fimc_v4l2_querycap(m_cam_fd); 625 CHECK(ret); 626 if (!fimc_v4l2_enuminput(m_cam_fd, index)) 627 return -1; 628 ret = fimc_v4l2_s_input(m_cam_fd, index); 629 CHECK(ret); 630 631 m_cam_fd2 = open(CAMERA_DEV_NAME2, O_RDWR); 632 LOGV("%s: open(%s) --> m_cam_fd2 = %d", __FUNCTION__, CAMERA_DEV_NAME2, m_cam_fd2); 633 if (m_cam_fd2 < 0) { 634 LOGE("ERR(%s):Cannot open %s (error : %s)\n", __func__, CAMERA_DEV_NAME2, strerror(errno)); 635 return -1; 636 } 637 638 LOGE("initCamera: m_cam_fd2(%d)", m_cam_fd2); 639 640 ret = fimc_v4l2_querycap(m_cam_fd2); 641 CHECK(ret); 642 if (!fimc_v4l2_enuminput(m_cam_fd2, index)) 643 return -1; 644 ret = fimc_v4l2_s_input(m_cam_fd2, index); 645 CHECK(ret); 646 647 m_camera_id = index; 648 649 switch (m_camera_id) { 650 case CAMERA_ID_FRONT: 651 m_preview_max_width = MAX_FRONT_CAMERA_PREVIEW_WIDTH; 652 m_preview_max_height = MAX_FRONT_CAMERA_PREVIEW_HEIGHT; 653 m_snapshot_max_width = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH; 654 m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT; 655 break; 656 657 case CAMERA_ID_BACK: 658 m_preview_max_width = MAX_BACK_CAMERA_PREVIEW_WIDTH; 659 m_preview_max_height = MAX_BACK_CAMERA_PREVIEW_HEIGHT; 660 m_snapshot_max_width = MAX_BACK_CAMERA_SNAPSHOT_WIDTH; 661 m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT; 662 break; 663 } 664 665 setExifFixedAttribute(); 666 667 m_flag_init = 1; 668 LOGI("%s : initialized", __FUNCTION__); 669 } 670 return 0; 671 } 672 673 void SecCamera::resetCamera() 674 { 675 LOGV("%s :", __func__); 676 DeinitCamera(); 677 initCamera(m_camera_id); 678 } 679 680 void SecCamera::DeinitCamera() 681 { 682 LOGV("%s :", __func__); 683 684 if (m_flag_init) { 685 686 stopRecord(); 687 688 /* close m_cam_fd after stopRecord() because stopRecord() 689 * uses m_cam_fd to change frame rate 690 */ 691 LOGI("DeinitCamera: m_cam_fd(%d)", m_cam_fd); 692 if (m_cam_fd > -1) { 693 close(m_cam_fd); 694 m_cam_fd = -1; 695 } 696 697 LOGI("DeinitCamera: m_cam_fd2(%d)", m_cam_fd2); 698 if (m_cam_fd2 > -1) { 699 close(m_cam_fd2); 700 m_cam_fd2 = -1; 701 } 702 703 m_flag_init = 0; 704 } 705 else LOGI("%s : already deinitialized", __FUNCTION__); 706 } 707 708 709 int SecCamera::getCameraFd(void) 710 { 711 return m_cam_fd; 712 } 713 714 // ====================================================================== 715 // Preview 716 717 int SecCamera::startPreview(void) 718 { 719 v4l2_streamparm streamparm; 720 struct sec_cam_parm *parms; 721 parms = (struct sec_cam_parm*)&streamparm.parm.raw_data; 722 LOGV("%s :", __func__); 723 724 // aleady started 725 if (m_flag_camera_start > 0) { 726 LOGE("ERR(%s):Preview was already started\n", __func__); 727 return 0; 728 } 729 730 if (m_cam_fd <= 0) { 731 LOGE("ERR(%s):Camera was closed\n", __func__); 732 return -1; 733 } 734 735 memset(&m_events_c, 0, sizeof(m_events_c)); 736 m_events_c.fd = m_cam_fd; 737 m_events_c.events = POLLIN | POLLERR; 738 739 /* enum_fmt, s_fmt sample */ 740 int ret = fimc_v4l2_enum_fmt(m_cam_fd,m_preview_v4lformat); 741 CHECK(ret); 742 ret = fimc_v4l2_s_fmt(m_cam_fd, m_preview_width,m_preview_height,m_preview_v4lformat, 0); 743 CHECK(ret); 744 745 ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); 746 CHECK(ret); 747 748 LOGV("%s : m_preview_width: %d m_preview_height: %d m_angle: %d\n", 749 __func__, m_preview_width, m_preview_height, m_angle); 750 751 ret = fimc_v4l2_s_ctrl(m_cam_fd, 752 V4L2_CID_CAMERA_CHECK_DATALINE, m_chk_dataline); 753 CHECK(ret); 754 755 if (m_camera_id == CAMERA_ID_FRONT) { 756 /* VT mode setting */ 757 ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VT_MODE, m_vtmode); 758 CHECK(ret); 759 } 760 761 /* start with all buffers in queue */ 762 for (int i = 0; i < MAX_BUFFERS; i++) { 763 ret = fimc_v4l2_qbuf(m_cam_fd, i); 764 CHECK(ret); 765 } 766 767 ret = fimc_v4l2_streamon(m_cam_fd); 768 CHECK(ret); 769 770 m_flag_camera_start = 1; 771 772 ret = fimc_v4l2_s_parm(m_cam_fd, &m_streamparm); 773 CHECK(ret); 774 775 if (m_camera_id == CAMERA_ID_FRONT) { 776 /* Blur setting */ 777 LOGV("m_blur_level = %d", m_blur_level); 778 ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR, 779 m_blur_level); 780 CHECK(ret); 781 } 782 783 // It is a delay for a new frame, not to show the previous bigger ugly picture frame. 784 ret = fimc_poll(&m_events_c); 785 CHECK(ret); 786 ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_RETURN_FOCUS, 0); 787 CHECK(ret); 788 789 LOGV("%s: got the first frame of the preview\n", __func__); 790 791 return 0; 792 } 793 794 int SecCamera::stopPreview(void) 795 { 796 int ret; 797 798 LOGV("%s :", __func__); 799 800 if (m_flag_camera_start == 0) { 801 LOGW("%s: doing nothing because m_flag_camera_start is zero", __func__); 802 return 0; 803 } 804 805 if (m_params->flash_mode == FLASH_MODE_TORCH) 806 setFlashMode(FLASH_MODE_OFF); 807 808 if (m_cam_fd <= 0) { 809 LOGE("ERR(%s):Camera was closed\n", __func__); 810 return -1; 811 } 812 813 ret = fimc_v4l2_streamoff(m_cam_fd); 814 CHECK(ret); 815 816 m_flag_camera_start = 0; 817 818 return ret; 819 } 820 821 //Recording 822 int SecCamera::startRecord(void) 823 { 824 int ret, i; 825 826 LOGV("%s :", __func__); 827 828 // aleady started 829 if (m_flag_record_start > 0) { 830 LOGE("ERR(%s):Preview was already started\n", __func__); 831 return 0; 832 } 833 834 if (m_cam_fd2 <= 0) { 835 LOGE("ERR(%s):Camera was closed\n", __func__); 836 return -1; 837 } 838 839 /* enum_fmt, s_fmt sample */ 840 ret = fimc_v4l2_enum_fmt(m_cam_fd2, V4L2_PIX_FMT_NV12T); 841 CHECK(ret); 842 843 LOGI("%s: m_recording_width = %d, m_recording_height = %d\n", 844 __func__, m_recording_width, m_recording_height); 845 846 ret = fimc_v4l2_s_fmt(m_cam_fd2, m_recording_width, 847 m_recording_height, V4L2_PIX_FMT_NV12T, 0); 848 CHECK(ret); 849 850 ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, 851 m_params->capture.timeperframe.denominator); 852 CHECK(ret); 853 854 ret = fimc_v4l2_reqbufs(m_cam_fd2, V4L2_BUF_TYPE_VIDEO_CAPTURE, MAX_BUFFERS); 855 CHECK(ret); 856 857 /* start with all buffers in queue */ 858 for (i = 0; i < MAX_BUFFERS; i++) { 859 ret = fimc_v4l2_qbuf(m_cam_fd2, i); 860 CHECK(ret); 861 } 862 863 ret = fimc_v4l2_streamon(m_cam_fd2); 864 CHECK(ret); 865 866 // Get and throw away the first frame since it is often garbled. 867 memset(&m_events_c2, 0, sizeof(m_events_c2)); 868 m_events_c2.fd = m_cam_fd2; 869 m_events_c2.events = POLLIN | POLLERR; 870 ret = fimc_poll(&m_events_c2); 871 CHECK(ret); 872 873 m_flag_record_start = 1; 874 875 return 0; 876 } 877 878 int SecCamera::stopRecord(void) 879 { 880 int ret; 881 882 LOGV("%s :", __func__); 883 884 if (m_flag_record_start == 0) { 885 LOGW("%s: doing nothing because m_flag_record_start is zero", __func__); 886 return 0; 887 } 888 889 if (m_cam_fd2 <= 0) { 890 LOGE("ERR(%s):Camera was closed\n", __func__); 891 return -1; 892 } 893 894 m_flag_record_start = 0; 895 896 ret = fimc_v4l2_streamoff(m_cam_fd2); 897 CHECK(ret); 898 899 ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, 900 FRAME_RATE_AUTO); 901 CHECK(ret); 902 903 return 0; 904 } 905 906 unsigned int SecCamera::getRecPhyAddrY(int index) 907 { 908 unsigned int addr_y; 909 910 addr_y = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_Y, index); 911 CHECK((int)addr_y); 912 return addr_y; 913 } 914 915 unsigned int SecCamera::getRecPhyAddrC(int index) 916 { 917 unsigned int addr_c; 918 919 addr_c = fimc_v4l2_s_ctrl(m_cam_fd2, V4L2_CID_PADDR_CBCR, index); 920 CHECK((int)addr_c); 921 return addr_c; 922 } 923 924 unsigned int SecCamera::getPhyAddrY(int index) 925 { 926 unsigned int addr_y; 927 928 addr_y = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_Y, index); 929 CHECK((int)addr_y); 930 return addr_y; 931 } 932 933 unsigned int SecCamera::getPhyAddrC(int index) 934 { 935 unsigned int addr_c; 936 937 addr_c = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_PADDR_CBCR, index); 938 CHECK((int)addr_c); 939 return addr_c; 940 } 941 942 void SecCamera::pausePreview() 943 { 944 fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0); 945 } 946 947 int SecCamera::getPreview() 948 { 949 int index; 950 int ret; 951 952 if (m_flag_camera_start == 0 || previewPoll(true) == 0) { 953 LOGE("ERR(%s):Start Camera Device Reset \n", __func__); 954 /* GAUDI Project([arun.c (at) samsung.com]) 2010.05.20. [Implemented ESD code] */ 955 /* 956 * When there is no data for more than 1 second from the camera we inform 957 * the FIMC driver by calling fimc_v4l2_s_input() with a special value = 1000 958 * FIMC driver identify that there is something wrong with the camera 959 * and it restarts the sensor. 960 */ 961 stopPreview(); 962 /* Reset Only Camera Device */ 963 ret = fimc_v4l2_querycap(m_cam_fd); 964 CHECK(ret); 965 if (fimc_v4l2_enuminput(m_cam_fd, m_camera_id)) 966 return -1; 967 ret = fimc_v4l2_s_input(m_cam_fd, 1000); 968 CHECK(ret); 969 ret = startPreview(); 970 if (ret < 0) { 971 LOGE("ERR(%s): startPreview() return %d\n", __func__, ret); 972 return 0; 973 } 974 } 975 976 index = fimc_v4l2_dqbuf(m_cam_fd); 977 if (!(0 <= index && index < MAX_BUFFERS)) { 978 LOGE("ERR(%s):wrong index = %d\n", __func__, index); 979 return -1; 980 } 981 982 ret = fimc_v4l2_qbuf(m_cam_fd, index); 983 CHECK(ret); 984 985 return index; 986 } 987 988 int SecCamera::getRecordFrame() 989 { 990 if (m_flag_record_start == 0) { 991 LOGE("%s: m_flag_record_start is 0", __func__); 992 return -1; 993 } 994 995 previewPoll(false); 996 return fimc_v4l2_dqbuf(m_cam_fd2); 997 } 998 999 int SecCamera::releaseRecordFrame(int index) 1000 { 1001 if (!m_flag_record_start) { 1002 /* this can happen when recording frames are returned after 1003 * the recording is stopped at the driver level. we don't 1004 * need to return the buffers in this case and we've seen 1005 * cases where fimc could crash if we called qbuf and it 1006 * wasn't expecting it. 1007 */ 1008 LOGI("%s: recording not in progress, ignoring", __func__); 1009 return 0; 1010 } 1011 1012 return fimc_v4l2_qbuf(m_cam_fd2, index); 1013 } 1014 1015 int SecCamera::setPreviewSize(int width, int height, int pixel_format) 1016 { 1017 LOGV("%s(width(%d), height(%d), format(%d))", __func__, width, height, pixel_format); 1018 1019 int v4lpixelformat = pixel_format; 1020 1021 #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 1022 if (v4lpixelformat == V4L2_PIX_FMT_YUV420) 1023 LOGV("PreviewFormat:V4L2_PIX_FMT_YUV420"); 1024 else if (v4lpixelformat == V4L2_PIX_FMT_NV12) 1025 LOGV("PreviewFormat:V4L2_PIX_FMT_NV12"); 1026 else if (v4lpixelformat == V4L2_PIX_FMT_NV12T) 1027 LOGV("PreviewFormat:V4L2_PIX_FMT_NV12T"); 1028 else if (v4lpixelformat == V4L2_PIX_FMT_NV21) 1029 LOGV("PreviewFormat:V4L2_PIX_FMT_NV21"); 1030 else if (v4lpixelformat == V4L2_PIX_FMT_YUV422P) 1031 LOGV("PreviewFormat:V4L2_PIX_FMT_YUV422P"); 1032 else if (v4lpixelformat == V4L2_PIX_FMT_YUYV) 1033 LOGV("PreviewFormat:V4L2_PIX_FMT_YUYV"); 1034 else if (v4lpixelformat == V4L2_PIX_FMT_RGB565) 1035 LOGV("PreviewFormat:V4L2_PIX_FMT_RGB565"); 1036 else 1037 LOGV("PreviewFormat:UnknownFormat"); 1038 #endif 1039 m_preview_width = width; 1040 m_preview_height = height; 1041 m_preview_v4lformat = v4lpixelformat; 1042 1043 return 0; 1044 } 1045 1046 int SecCamera::getPreviewSize(int *width, int *height, int *frame_size) 1047 { 1048 *width = m_preview_width; 1049 *height = m_preview_height; 1050 *frame_size = m_frameSize(m_preview_v4lformat, m_preview_width, m_preview_height); 1051 1052 return 0; 1053 } 1054 1055 int SecCamera::getPreviewMaxSize(int *width, int *height) 1056 { 1057 *width = m_preview_max_width; 1058 *height = m_preview_max_height; 1059 1060 return 0; 1061 } 1062 1063 int SecCamera::getPreviewPixelFormat(void) 1064 { 1065 return m_preview_v4lformat; 1066 } 1067 1068 1069 // ====================================================================== 1070 // Snapshot 1071 /* 1072 * Devide getJpeg() as two funcs, setSnapshotCmd() & getJpeg() because of the shutter sound timing. 1073 * Here, just send the capture cmd to camera ISP to start JPEG capture. 1074 */ 1075 int SecCamera::setSnapshotCmd(void) 1076 { 1077 LOGV("%s :", __func__); 1078 1079 int ret = 0; 1080 1081 LOG_TIME_DEFINE(0) 1082 LOG_TIME_DEFINE(1) 1083 1084 if (m_cam_fd <= 0) { 1085 LOGE("ERR(%s):Camera was closed\n", __func__); 1086 return 0; 1087 } 1088 1089 if (m_flag_camera_start > 0) { 1090 LOG_TIME_START(0) 1091 LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__); 1092 stopPreview(); 1093 LOG_TIME_END(0) 1094 } 1095 1096 memset(&m_events_c, 0, sizeof(m_events_c)); 1097 m_events_c.fd = m_cam_fd; 1098 m_events_c.events = POLLIN | POLLERR; 1099 1100 LOG_TIME_START(1) // prepare 1101 int nframe = 1; 1102 1103 ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat); 1104 CHECK(ret); 1105 ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, V4L2_PIX_FMT_JPEG); 1106 CHECK(ret); 1107 ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); 1108 CHECK(ret); 1109 ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1110 CHECK(ret); 1111 1112 ret = fimc_v4l2_qbuf(m_cam_fd, 0); 1113 CHECK(ret); 1114 1115 ret = fimc_v4l2_streamon(m_cam_fd); 1116 CHECK(ret); 1117 LOG_TIME_END(1) 1118 1119 return 0; 1120 } 1121 1122 int SecCamera::endSnapshot(void) 1123 { 1124 int ret; 1125 1126 LOGI("%s :", __func__); 1127 if (m_capture_buf.start) { 1128 munmap(m_capture_buf.start, m_capture_buf.length); 1129 LOGI("munmap():virt. addr %p size = %d\n", 1130 m_capture_buf.start, m_capture_buf.length); 1131 m_capture_buf.start = NULL; 1132 m_capture_buf.length = 0; 1133 } 1134 return 0; 1135 } 1136 1137 /* 1138 * Set Jpeg quality & exif info and get JPEG data from camera ISP 1139 */ 1140 unsigned char* SecCamera::getJpeg(int *jpeg_size, unsigned int *phyaddr) 1141 { 1142 LOGV("%s :", __func__); 1143 1144 int index, ret = 0; 1145 unsigned char *addr; 1146 1147 LOG_TIME_DEFINE(2) 1148 1149 // capture 1150 ret = fimc_poll(&m_events_c); 1151 CHECK_PTR(ret); 1152 index = fimc_v4l2_dqbuf(m_cam_fd); 1153 if (index != 0) { 1154 LOGE("ERR(%s):wrong index = %d\n", __func__, index); 1155 return NULL; 1156 } 1157 1158 *jpeg_size = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_SIZE); 1159 CHECK_PTR(*jpeg_size); 1160 1161 int main_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_MAIN_OFFSET); 1162 CHECK_PTR(main_offset); 1163 m_postview_offset = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET); 1164 CHECK_PTR(m_postview_offset); 1165 1166 ret = fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0); 1167 CHECK_PTR(ret); 1168 LOGV("\nsnapshot dqueued buffer = %d snapshot_width = %d snapshot_height = %d, size = %d\n\n", 1169 index, m_snapshot_width, m_snapshot_height, *jpeg_size); 1170 1171 addr = (unsigned char*)(m_capture_buf.start) + main_offset; 1172 *phyaddr = getPhyAddrY(index) + m_postview_offset; 1173 1174 LOG_TIME_START(2) // post 1175 ret = fimc_v4l2_streamoff(m_cam_fd); 1176 CHECK_PTR(ret); 1177 LOG_TIME_END(2) 1178 1179 return addr; 1180 } 1181 1182 int SecCamera::getExif(unsigned char *pExifDst, unsigned char *pThumbSrc) 1183 { 1184 JpegEncoder jpgEnc; 1185 1186 LOGV("%s : m_jpeg_thumbnail_width = %d, height = %d", 1187 __func__, m_jpeg_thumbnail_width, m_jpeg_thumbnail_height); 1188 if ((m_jpeg_thumbnail_width > 0) && (m_jpeg_thumbnail_height > 0)) { 1189 int inFormat = JPG_MODESEL_YCBCR; 1190 int outFormat = JPG_422; 1191 switch (m_snapshot_v4lformat) { 1192 case V4L2_PIX_FMT_NV12: 1193 case V4L2_PIX_FMT_NV21: 1194 case V4L2_PIX_FMT_NV12T: 1195 case V4L2_PIX_FMT_YUV420: 1196 outFormat = JPG_420; 1197 break; 1198 case V4L2_PIX_FMT_YUYV: 1199 case V4L2_PIX_FMT_UYVY: 1200 case V4L2_PIX_FMT_YUV422P: 1201 outFormat = JPG_422; 1202 break; 1203 } 1204 1205 if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS) 1206 return -1; 1207 1208 if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS) 1209 return -1; 1210 1211 if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, JPG_QUALITY_LEVEL_2) != JPG_SUCCESS) 1212 return -1; 1213 1214 int thumbWidth, thumbHeight, thumbSrcSize; 1215 getThumbnailConfig(&thumbWidth, &thumbHeight, &thumbSrcSize); 1216 if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, thumbWidth) != JPG_SUCCESS) 1217 return -1; 1218 1219 if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, thumbHeight) != JPG_SUCCESS) 1220 return -1; 1221 1222 char *pInBuf = (char *)jpgEnc.getInBuf(thumbSrcSize); 1223 if (pInBuf == NULL) 1224 return -1; 1225 memcpy(pInBuf, pThumbSrc, thumbSrcSize); 1226 1227 unsigned int thumbSize; 1228 1229 jpgEnc.encode(&thumbSize, NULL); 1230 1231 LOGV("%s : enableThumb set to true", __func__); 1232 mExifInfo.enableThumb = true; 1233 } else { 1234 LOGV("%s : enableThumb set to false", __func__); 1235 mExifInfo.enableThumb = false; 1236 } 1237 1238 unsigned int exifSize; 1239 1240 setExifChangedAttribute(); 1241 1242 LOGV("%s: calling jpgEnc.makeExif, mExifInfo.width set to %d, height to %d\n", 1243 __func__, mExifInfo.width, mExifInfo.height); 1244 1245 jpgEnc.makeExif(pExifDst, &mExifInfo, &exifSize, true); 1246 1247 return exifSize; 1248 } 1249 1250 void SecCamera::getPostViewConfig(int *width, int *height, int *size) 1251 { 1252 if (m_preview_width == 1024) { 1253 *width = BACK_CAMERA_POSTVIEW_WIDE_WIDTH; 1254 *height = BACK_CAMERA_POSTVIEW_HEIGHT; 1255 *size = BACK_CAMERA_POSTVIEW_WIDE_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8; 1256 } else { 1257 *width = BACK_CAMERA_POSTVIEW_WIDTH; 1258 *height = BACK_CAMERA_POSTVIEW_HEIGHT; 1259 *size = BACK_CAMERA_POSTVIEW_WIDTH * BACK_CAMERA_POSTVIEW_HEIGHT * BACK_CAMERA_POSTVIEW_BPP / 8; 1260 } 1261 LOGV("[5B] m_preview_width : %d, mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d", 1262 m_preview_width, *width, *height, *size); 1263 } 1264 1265 void SecCamera::getThumbnailConfig(int *width, int *height, int *size) 1266 { 1267 if (m_camera_id == CAMERA_ID_BACK) { 1268 *width = BACK_CAMERA_THUMBNAIL_WIDTH; 1269 *height = BACK_CAMERA_THUMBNAIL_HEIGHT; 1270 *size = BACK_CAMERA_THUMBNAIL_WIDTH * BACK_CAMERA_THUMBNAIL_HEIGHT 1271 * BACK_CAMERA_THUMBNAIL_BPP / 8; 1272 } else { 1273 *width = FRONT_CAMERA_THUMBNAIL_WIDTH; 1274 *height = FRONT_CAMERA_THUMBNAIL_HEIGHT; 1275 *size = FRONT_CAMERA_THUMBNAIL_WIDTH * FRONT_CAMERA_THUMBNAIL_HEIGHT 1276 * FRONT_CAMERA_THUMBNAIL_BPP / 8; 1277 } 1278 } 1279 1280 int SecCamera::getPostViewOffset(void) 1281 { 1282 return m_postview_offset; 1283 } 1284 1285 int SecCamera::getSnapshotAndJpeg(unsigned char *yuv_buf, unsigned char *jpeg_buf, 1286 unsigned int *output_size) 1287 { 1288 LOGV("%s :", __func__); 1289 1290 int index; 1291 //unsigned int addr; 1292 unsigned char *addr; 1293 int ret = 0; 1294 1295 LOG_TIME_DEFINE(0) 1296 LOG_TIME_DEFINE(1) 1297 LOG_TIME_DEFINE(2) 1298 LOG_TIME_DEFINE(3) 1299 LOG_TIME_DEFINE(4) 1300 LOG_TIME_DEFINE(5) 1301 1302 //fimc_v4l2_streamoff(m_cam_fd); [zzangdol] remove - it is separate in HWInterface with camera_id 1303 1304 if (m_cam_fd <= 0) { 1305 LOGE("ERR(%s):Camera was closed\n", __func__); 1306 return -1; 1307 } 1308 1309 if (m_flag_camera_start > 0) { 1310 LOG_TIME_START(0) 1311 LOGW("WARN(%s):Camera was in preview, should have been stopped\n", __func__); 1312 stopPreview(); 1313 LOG_TIME_END(0) 1314 } 1315 1316 memset(&m_events_c, 0, sizeof(m_events_c)); 1317 m_events_c.fd = m_cam_fd; 1318 m_events_c.events = POLLIN | POLLERR; 1319 1320 #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 1321 if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420) 1322 LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV420"); 1323 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12) 1324 LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12"); 1325 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T) 1326 LOGV("SnapshotFormat:V4L2_PIX_FMT_NV12T"); 1327 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21) 1328 LOGV("SnapshotFormat:V4L2_PIX_FMT_NV21"); 1329 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P) 1330 LOGV("SnapshotFormat:V4L2_PIX_FMT_YUV422P"); 1331 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV) 1332 LOGV("SnapshotFormat:V4L2_PIX_FMT_YUYV"); 1333 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY) 1334 LOGV("SnapshotFormat:V4L2_PIX_FMT_UYVY"); 1335 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) 1336 LOGV("SnapshotFormat:V4L2_PIX_FMT_RGB565"); 1337 else 1338 LOGV("SnapshotFormat:UnknownFormat"); 1339 #endif 1340 1341 LOG_TIME_START(1) // prepare 1342 int nframe = 1; 1343 1344 ret = fimc_v4l2_enum_fmt(m_cam_fd,m_snapshot_v4lformat); 1345 CHECK(ret); 1346 ret = fimc_v4l2_s_fmt_cap(m_cam_fd, m_snapshot_width, m_snapshot_height, m_snapshot_v4lformat); 1347 CHECK(ret); 1348 ret = fimc_v4l2_reqbufs(m_cam_fd, V4L2_BUF_TYPE_VIDEO_CAPTURE, nframe); 1349 CHECK(ret); 1350 ret = fimc_v4l2_querybuf(m_cam_fd, &m_capture_buf, V4L2_BUF_TYPE_VIDEO_CAPTURE); 1351 CHECK(ret); 1352 1353 ret = fimc_v4l2_qbuf(m_cam_fd, 0); 1354 CHECK(ret); 1355 1356 ret = fimc_v4l2_streamon(m_cam_fd); 1357 CHECK(ret); 1358 LOG_TIME_END(1) 1359 1360 LOG_TIME_START(2) // capture 1361 fimc_poll(&m_events_c); 1362 index = fimc_v4l2_dqbuf(m_cam_fd); 1363 fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_STREAM_PAUSE, 0); 1364 LOGV("\nsnapshot dequeued buffer = %d snapshot_width = %d snapshot_height = %d\n\n", 1365 index, m_snapshot_width, m_snapshot_height); 1366 1367 LOG_TIME_END(2) 1368 1369 LOGI("%s : calling memcpy from m_capture_buf", __func__); 1370 memcpy(yuv_buf, (unsigned char*)m_capture_buf.start, m_snapshot_width * m_snapshot_height * 2); 1371 LOG_TIME_START(5) // post 1372 fimc_v4l2_streamoff(m_cam_fd); 1373 LOG_TIME_END(5) 1374 1375 LOG_CAMERA("getSnapshotAndJpeg intervals : stopPreview(%lu), prepare(%lu)," 1376 " capture(%lu), memcpy(%lu), yuv2Jpeg(%lu), post(%lu) us", 1377 LOG_TIME(0), LOG_TIME(1), LOG_TIME(2), LOG_TIME(3), LOG_TIME(4), LOG_TIME(5)); 1378 /* JPEG encoding */ 1379 JpegEncoder jpgEnc; 1380 int inFormat = JPG_MODESEL_YCBCR; 1381 int outFormat = JPG_422; 1382 1383 switch (m_snapshot_v4lformat) { 1384 case V4L2_PIX_FMT_NV12: 1385 case V4L2_PIX_FMT_NV21: 1386 case V4L2_PIX_FMT_NV12T: 1387 case V4L2_PIX_FMT_YUV420: 1388 outFormat = JPG_420; 1389 break; 1390 case V4L2_PIX_FMT_YUYV: 1391 case V4L2_PIX_FMT_UYVY: 1392 case V4L2_PIX_FMT_YUV422P: 1393 default: 1394 outFormat = JPG_422; 1395 break; 1396 } 1397 1398 if (jpgEnc.setConfig(JPEG_SET_ENCODE_IN_FORMAT, inFormat) != JPG_SUCCESS) 1399 LOGE("[JPEG_SET_ENCODE_IN_FORMAT] Error\n"); 1400 1401 if (jpgEnc.setConfig(JPEG_SET_SAMPING_MODE, outFormat) != JPG_SUCCESS) 1402 LOGE("[JPEG_SET_SAMPING_MODE] Error\n"); 1403 1404 image_quality_type_t jpegQuality; 1405 if (m_jpeg_quality >= 90) 1406 jpegQuality = JPG_QUALITY_LEVEL_1; 1407 else if (m_jpeg_quality >= 80) 1408 jpegQuality = JPG_QUALITY_LEVEL_2; 1409 else if (m_jpeg_quality >= 70) 1410 jpegQuality = JPG_QUALITY_LEVEL_3; 1411 else 1412 jpegQuality = JPG_QUALITY_LEVEL_4; 1413 1414 if (jpgEnc.setConfig(JPEG_SET_ENCODE_QUALITY, jpegQuality) != JPG_SUCCESS) 1415 LOGE("[JPEG_SET_ENCODE_QUALITY] Error\n"); 1416 if (jpgEnc.setConfig(JPEG_SET_ENCODE_WIDTH, m_snapshot_width) != JPG_SUCCESS) 1417 LOGE("[JPEG_SET_ENCODE_WIDTH] Error\n"); 1418 1419 if (jpgEnc.setConfig(JPEG_SET_ENCODE_HEIGHT, m_snapshot_height) != JPG_SUCCESS) 1420 LOGE("[JPEG_SET_ENCODE_HEIGHT] Error\n"); 1421 1422 unsigned int snapshot_size = m_snapshot_width * m_snapshot_height * 2; 1423 unsigned char *pInBuf = (unsigned char *)jpgEnc.getInBuf(snapshot_size); 1424 1425 if (pInBuf == NULL) { 1426 LOGE("JPEG input buffer is NULL!!\n"); 1427 return -1; 1428 } 1429 memcpy(pInBuf, yuv_buf, snapshot_size); 1430 1431 setExifChangedAttribute(); 1432 jpgEnc.encode(output_size, NULL); 1433 1434 uint64_t outbuf_size; 1435 unsigned char *pOutBuf = (unsigned char *)jpgEnc.getOutBuf(&outbuf_size); 1436 1437 if (pOutBuf == NULL) { 1438 LOGE("JPEG output buffer is NULL!!\n"); 1439 return -1; 1440 } 1441 1442 memcpy(jpeg_buf, pOutBuf, outbuf_size); 1443 1444 return 0; 1445 } 1446 1447 1448 int SecCamera::setSnapshotSize(int width, int height) 1449 { 1450 LOGV("%s(width(%d), height(%d))", __func__, width, height); 1451 1452 m_snapshot_width = width; 1453 m_snapshot_height = height; 1454 1455 return 0; 1456 } 1457 1458 int SecCamera::getSnapshotSize(int *width, int *height, int *frame_size) 1459 { 1460 *width = m_snapshot_width; 1461 *height = m_snapshot_height; 1462 1463 int frame = 0; 1464 1465 frame = m_frameSize(m_snapshot_v4lformat, m_snapshot_width, m_snapshot_height); 1466 1467 // set it big. 1468 if (frame == 0) 1469 frame = m_snapshot_width * m_snapshot_height * BPP; 1470 1471 *frame_size = frame; 1472 1473 return 0; 1474 } 1475 1476 int SecCamera::getSnapshotMaxSize(int *width, int *height) 1477 { 1478 switch (m_camera_id) { 1479 case CAMERA_ID_FRONT: 1480 m_snapshot_max_width = MAX_FRONT_CAMERA_SNAPSHOT_WIDTH; 1481 m_snapshot_max_height = MAX_FRONT_CAMERA_SNAPSHOT_HEIGHT; 1482 break; 1483 1484 default: 1485 case CAMERA_ID_BACK: 1486 m_snapshot_max_width = MAX_BACK_CAMERA_SNAPSHOT_WIDTH; 1487 m_snapshot_max_height = MAX_BACK_CAMERA_SNAPSHOT_HEIGHT; 1488 break; 1489 } 1490 1491 *width = m_snapshot_max_width; 1492 *height = m_snapshot_max_height; 1493 1494 return 0; 1495 } 1496 1497 int SecCamera::setSnapshotPixelFormat(int pixel_format) 1498 { 1499 int v4lpixelformat= pixel_format; 1500 1501 if (m_snapshot_v4lformat != v4lpixelformat) { 1502 m_snapshot_v4lformat = v4lpixelformat; 1503 } 1504 1505 #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 1506 if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV420) 1507 LOGE("%s : SnapshotFormat:V4L2_PIX_FMT_YUV420", __func__); 1508 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12) 1509 LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12", __func__); 1510 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV12T) 1511 LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV12T", __func__); 1512 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_NV21) 1513 LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_NV21", __func__); 1514 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUV422P) 1515 LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUV422P", __func__); 1516 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_YUYV) 1517 LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_YUYV", __func__); 1518 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_UYVY) 1519 LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_UYVY", __func__); 1520 else if (m_snapshot_v4lformat == V4L2_PIX_FMT_RGB565) 1521 LOGD("%s : SnapshotFormat:V4L2_PIX_FMT_RGB565", __func__); 1522 else 1523 LOGD("SnapshotFormat:UnknownFormat"); 1524 #endif 1525 return 0; 1526 } 1527 1528 int SecCamera::getSnapshotPixelFormat(void) 1529 { 1530 return m_snapshot_v4lformat; 1531 } 1532 1533 // ====================================================================== 1534 // Settings 1535 1536 int SecCamera::getCameraId(void) 1537 { 1538 return m_camera_id; 1539 } 1540 1541 // ----------------------------------- 1542 1543 int SecCamera::setAutofocus(void) 1544 { 1545 LOGV("%s :", __func__); 1546 1547 if (m_cam_fd <= 0) { 1548 LOGE("ERR(%s):Camera was closed\n", __func__); 1549 return -1; 1550 } 1551 1552 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) { 1553 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__); 1554 return -1; 1555 } 1556 1557 return 0; 1558 } 1559 1560 int SecCamera::getAutoFocusResult(void) 1561 { 1562 int af_result, count, ret; 1563 1564 for (count = 0; count < FIRST_AF_SEARCH_COUNT; count++) { 1565 ret = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT_FIRST); 1566 if (ret != AF_PROGRESS) 1567 break; 1568 usleep(AF_DELAY); 1569 } 1570 if ((count >= FIRST_AF_SEARCH_COUNT) || (ret != AF_SUCCESS)) { 1571 LOGV("%s : 1st AF timed out, failed, or was canceled", __func__); 1572 af_result = 0; 1573 goto finish_auto_focus; 1574 } 1575 1576 for (count = 0; count < SECOND_AF_SEARCH_COUNT; count++) { 1577 ret = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT_SECOND); 1578 /* low byte is garbage. done when high byte is 0x0 */ 1579 if (!(ret & 0xff00)) 1580 break; 1581 usleep(AF_DELAY); 1582 } 1583 if (count >= SECOND_AF_SEARCH_COUNT) { 1584 LOGV("%s : 2nd AF timed out, failed, or was canceled", __func__); 1585 af_result = 0; 1586 goto finish_auto_focus; 1587 } 1588 1589 af_result = 1; 1590 LOGV("%s : AF was successful, returning %d", __func__, af_result); 1591 1592 finish_auto_focus: 1593 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FINISH_AUTO_FOCUS, 0) < 0) { 1594 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_PRE_FLASH", __func__); 1595 return -1; 1596 } 1597 return af_result; 1598 } 1599 1600 int SecCamera::cancelAutofocus(void) 1601 { 1602 LOGV("%s :", __func__); 1603 1604 if (m_cam_fd <= 0) { 1605 LOGE("ERR(%s):Camera was closed\n", __func__); 1606 return -1; 1607 } 1608 1609 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) { 1610 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_AUTO_FOCUS", __func__); 1611 return -1; 1612 } 1613 1614 return 0; 1615 } 1616 1617 // ----------------------------------- 1618 1619 int SecCamera::zoomIn(void) 1620 { 1621 LOGV("%s :", __func__); 1622 return 0; 1623 } 1624 1625 int SecCamera::zoomOut(void) 1626 { 1627 LOGV("%s :", __func__); 1628 return 0; 1629 } 1630 1631 // ----------------------------------- 1632 1633 int SecCamera::SetRotate(int angle) 1634 { 1635 LOGE("%s(angle(%d))", __func__, angle); 1636 1637 if (m_angle != angle) { 1638 switch (angle) { 1639 case -360: 1640 case 0: 1641 case 360: 1642 m_angle = 0; 1643 break; 1644 1645 case -270: 1646 case 90: 1647 m_angle = 90; 1648 break; 1649 1650 case -180: 1651 case 180: 1652 m_angle = 180; 1653 break; 1654 1655 case -90: 1656 case 270: 1657 m_angle = 270; 1658 break; 1659 1660 default: 1661 LOGE("ERR(%s):Invalid angle(%d)", __func__, angle); 1662 return -1; 1663 } 1664 1665 if (m_flag_camera_start) { 1666 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_ROTATION, angle) < 0) { 1667 LOGE("ERR(%s):Fail on V4L2_CID_ROTATION", __func__); 1668 return -1; 1669 } 1670 } 1671 } 1672 1673 return 0; 1674 } 1675 1676 int SecCamera::getRotate(void) 1677 { 1678 LOGV("%s : angle(%d)", __func__, m_angle); 1679 return m_angle; 1680 } 1681 1682 int SecCamera::setFrameRate(int frame_rate) 1683 { 1684 LOGV("%s(FrameRate(%d))", __func__, frame_rate); 1685 1686 if (frame_rate < FRAME_RATE_AUTO || FRAME_RATE_MAX < frame_rate ) 1687 LOGE("ERR(%s):Invalid frame_rate(%d)", __func__, frame_rate); 1688 1689 if (m_params->capture.timeperframe.denominator != (unsigned)frame_rate) { 1690 m_params->capture.timeperframe.denominator = frame_rate; 1691 if (m_flag_camera_start) { 1692 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FRAME_RATE, frame_rate) < 0) { 1693 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FRAME_RATE", __func__); 1694 return -1; 1695 } 1696 } 1697 } 1698 1699 return 0; 1700 } 1701 1702 // ----------------------------------- 1703 1704 int SecCamera::setVerticalMirror(void) 1705 { 1706 LOGV("%s :", __func__); 1707 1708 if (m_cam_fd <= 0) { 1709 LOGE("ERR(%s):Camera was closed\n", __func__); 1710 return -1; 1711 } 1712 1713 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_VFLIP, 0) < 0) { 1714 LOGE("ERR(%s):Fail on V4L2_CID_VFLIP", __func__); 1715 return -1; 1716 } 1717 1718 return 0; 1719 } 1720 1721 int SecCamera::setHorizontalMirror(void) 1722 { 1723 LOGV("%s :", __func__); 1724 1725 if (m_cam_fd <= 0) { 1726 LOGE("ERR(%s):Camera was closed\n", __func__); 1727 return -1; 1728 } 1729 1730 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_HFLIP, 0) < 0) { 1731 LOGE("ERR(%s):Fail on V4L2_CID_HFLIP", __func__); 1732 return -1; 1733 } 1734 1735 return 0; 1736 } 1737 1738 // ----------------------------------- 1739 1740 int SecCamera::setWhiteBalance(int white_balance) 1741 { 1742 LOGV("%s(white_balance(%d))", __func__, white_balance); 1743 1744 if (white_balance <= WHITE_BALANCE_BASE || WHITE_BALANCE_MAX <= white_balance) { 1745 LOGE("ERR(%s):Invalid white_balance(%d)", __func__, white_balance); 1746 return -1; 1747 } 1748 1749 if (m_params->white_balance != white_balance) { 1750 m_params->white_balance = white_balance; 1751 if (m_flag_camera_start) { 1752 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WHITE_BALANCE, white_balance) < 0) { 1753 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WHITE_BALANCE", __func__); 1754 return -1; 1755 } 1756 } 1757 } 1758 1759 return 0; 1760 } 1761 1762 int SecCamera::getWhiteBalance(void) 1763 { 1764 LOGV("%s : white_balance(%d)", __func__, m_params->white_balance); 1765 return m_params->white_balance; 1766 } 1767 1768 // ----------------------------------- 1769 1770 int SecCamera::setBrightness(int brightness) 1771 { 1772 LOGV("%s(brightness(%d))", __func__, brightness); 1773 1774 brightness += EV_DEFAULT; 1775 1776 if (brightness < EV_MINUS_4 || EV_PLUS_4 < brightness) { 1777 LOGE("ERR(%s):Invalid brightness(%d)", __func__, brightness); 1778 return -1; 1779 } 1780 1781 if (m_params->brightness != brightness) { 1782 m_params->brightness = brightness; 1783 if (m_flag_camera_start) { 1784 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BRIGHTNESS, brightness) < 0) { 1785 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BRIGHTNESS", __func__); 1786 return -1; 1787 } 1788 } 1789 } 1790 1791 return 0; 1792 } 1793 1794 int SecCamera::getBrightness(void) 1795 { 1796 LOGV("%s : brightness(%d)", __func__, m_params->brightness); 1797 return m_params->brightness; 1798 } 1799 1800 // ----------------------------------- 1801 1802 int SecCamera::setImageEffect(int image_effect) 1803 { 1804 LOGV("%s(image_effect(%d))", __func__, image_effect); 1805 1806 if (image_effect <= IMAGE_EFFECT_BASE || IMAGE_EFFECT_MAX <= image_effect) { 1807 LOGE("ERR(%s):Invalid image_effect(%d)", __func__, image_effect); 1808 return -1; 1809 } 1810 1811 if (m_params->effects != image_effect) { 1812 m_params->effects = image_effect; 1813 if (m_flag_camera_start) { 1814 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_EFFECT, image_effect) < 0) { 1815 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_EFFECT", __func__); 1816 return -1; 1817 } 1818 } 1819 } 1820 1821 return 0; 1822 } 1823 1824 int SecCamera::getImageEffect(void) 1825 { 1826 LOGV("%s : image_effect(%d)", __func__, m_params->effects); 1827 return m_params->effects; 1828 } 1829 1830 // ====================================================================== 1831 int SecCamera::setAntiBanding(int anti_banding) 1832 { 1833 LOGV("%s(anti_banding(%d))", __func__, anti_banding); 1834 1835 if (anti_banding < ANTI_BANDING_AUTO || ANTI_BANDING_OFF < anti_banding) { 1836 LOGE("ERR(%s):Invalid anti_banding (%d)", __func__, anti_banding); 1837 return -1; 1838 } 1839 1840 if (m_anti_banding != anti_banding) { 1841 m_anti_banding = anti_banding; 1842 if (m_flag_camera_start) { 1843 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_BANDING, anti_banding) < 0) { 1844 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_BANDING", __func__); 1845 return -1; 1846 } 1847 } 1848 } 1849 1850 return 0; 1851 } 1852 1853 //====================================================================== 1854 int SecCamera::setSceneMode(int scene_mode) 1855 { 1856 LOGV("%s(scene_mode(%d))", __func__, scene_mode); 1857 1858 if (scene_mode <= SCENE_MODE_BASE || SCENE_MODE_MAX <= scene_mode) { 1859 LOGE("ERR(%s):Invalid scene_mode (%d)", __func__, scene_mode); 1860 return -1; 1861 } 1862 1863 if (m_params->scene_mode != scene_mode) { 1864 m_params->scene_mode = scene_mode; 1865 if (m_flag_camera_start) { 1866 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SCENE_MODE, scene_mode) < 0) { 1867 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SCENE_MODE", __func__); 1868 return -1; 1869 } 1870 } 1871 } 1872 1873 return 0; 1874 } 1875 1876 int SecCamera::getSceneMode(void) 1877 { 1878 return m_params->scene_mode; 1879 } 1880 1881 //====================================================================== 1882 1883 int SecCamera::setFlashMode(int flash_mode) 1884 { 1885 LOGV("%s(flash_mode(%d))", __func__, flash_mode); 1886 1887 if (flash_mode <= FLASH_MODE_BASE || FLASH_MODE_MAX <= flash_mode) { 1888 LOGE("ERR(%s):Invalid flash_mode (%d)", __func__, flash_mode); 1889 return -1; 1890 } 1891 1892 if (m_params->flash_mode != flash_mode) { 1893 m_params->flash_mode = flash_mode; 1894 if (m_flag_camera_start) { 1895 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FLASH_MODE, flash_mode) < 0) { 1896 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FLASH_MODE", __func__); 1897 return -1; 1898 } 1899 } 1900 } 1901 1902 return 0; 1903 } 1904 1905 int SecCamera::getFlashMode(void) 1906 { 1907 return m_params->flash_mode; 1908 } 1909 1910 //====================================================================== 1911 1912 int SecCamera::setISO(int iso_value) 1913 { 1914 LOGV("%s(iso_value(%d))", __func__, iso_value); 1915 if (iso_value < ISO_AUTO || ISO_MAX <= iso_value) { 1916 LOGE("ERR(%s):Invalid iso_value (%d)", __func__, iso_value); 1917 return -1; 1918 } 1919 1920 if (m_params->iso != iso_value) { 1921 m_params->iso = iso_value; 1922 if (m_flag_camera_start) { 1923 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ISO, iso_value) < 0) { 1924 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ISO", __func__); 1925 return -1; 1926 } 1927 } 1928 } 1929 1930 return 0; 1931 } 1932 1933 int SecCamera::getISO(void) 1934 { 1935 return m_params->iso; 1936 } 1937 1938 //====================================================================== 1939 1940 int SecCamera::setContrast(int contrast_value) 1941 { 1942 LOGV("%s(contrast_value(%d))", __func__, contrast_value); 1943 1944 if (contrast_value < CONTRAST_MINUS_2 || CONTRAST_MAX <= contrast_value) { 1945 LOGE("ERR(%s):Invalid contrast_value (%d)", __func__, contrast_value); 1946 return -1; 1947 } 1948 1949 if (m_params->contrast != contrast_value) { 1950 m_params->contrast = contrast_value; 1951 if (m_flag_camera_start) { 1952 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CONTRAST, contrast_value) < 0) { 1953 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CONTRAST", __func__); 1954 return -1; 1955 } 1956 } 1957 } 1958 1959 return 0; 1960 } 1961 1962 int SecCamera::getContrast(void) 1963 { 1964 return m_params->contrast; 1965 } 1966 1967 //====================================================================== 1968 1969 int SecCamera::setSaturation(int saturation_value) 1970 { 1971 LOGV("%s(saturation_value(%d))", __func__, saturation_value); 1972 1973 if (saturation_value <SATURATION_MINUS_2 || SATURATION_MAX<= saturation_value) { 1974 LOGE("ERR(%s):Invalid saturation_value (%d)", __func__, saturation_value); 1975 return -1; 1976 } 1977 1978 if (m_params->saturation != saturation_value) { 1979 m_params->saturation = saturation_value; 1980 if (m_flag_camera_start) { 1981 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SATURATION, saturation_value) < 0) { 1982 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SATURATION", __func__); 1983 return -1; 1984 } 1985 } 1986 } 1987 1988 return 0; 1989 } 1990 1991 int SecCamera::getSaturation(void) 1992 { 1993 return m_params->saturation; 1994 } 1995 1996 //====================================================================== 1997 1998 int SecCamera::setSharpness(int sharpness_value) 1999 { 2000 LOGV("%s(sharpness_value(%d))", __func__, sharpness_value); 2001 2002 if (sharpness_value < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= sharpness_value) { 2003 LOGE("ERR(%s):Invalid sharpness_value (%d)", __func__, sharpness_value); 2004 return -1; 2005 } 2006 2007 if (m_params->sharpness != sharpness_value) { 2008 m_params->sharpness = sharpness_value; 2009 if (m_flag_camera_start) { 2010 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SHARPNESS, sharpness_value) < 0) { 2011 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SHARPNESS", __func__); 2012 return -1; 2013 } 2014 } 2015 } 2016 2017 return 0; 2018 } 2019 2020 int SecCamera::getSharpness(void) 2021 { 2022 return m_params->sharpness; 2023 } 2024 2025 //====================================================================== 2026 2027 int SecCamera::setWDR(int wdr_value) 2028 { 2029 LOGV("%s(wdr_value(%d))", __func__, wdr_value); 2030 2031 if (wdr_value < WDR_OFF || WDR_MAX <= wdr_value) { 2032 LOGE("ERR(%s):Invalid wdr_value (%d)", __func__, wdr_value); 2033 return -1; 2034 } 2035 2036 if (m_wdr != wdr_value) { 2037 m_wdr = wdr_value; 2038 if (m_flag_camera_start) { 2039 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_WDR, wdr_value) < 0) { 2040 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_WDR", __func__); 2041 return -1; 2042 } 2043 } 2044 } 2045 2046 return 0; 2047 } 2048 2049 int SecCamera::getWDR(void) 2050 { 2051 return m_wdr; 2052 } 2053 2054 //====================================================================== 2055 2056 int SecCamera::setAntiShake(int anti_shake) 2057 { 2058 LOGV("%s(anti_shake(%d))", __func__, anti_shake); 2059 2060 if (anti_shake < ANTI_SHAKE_OFF || ANTI_SHAKE_MAX <= anti_shake) { 2061 LOGE("ERR(%s):Invalid anti_shake (%d)", __func__, anti_shake); 2062 return -1; 2063 } 2064 2065 if (m_anti_shake != anti_shake) { 2066 m_anti_shake = anti_shake; 2067 if (m_flag_camera_start) { 2068 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ANTI_SHAKE, anti_shake) < 0) { 2069 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ANTI_SHAKE", __func__); 2070 return -1; 2071 } 2072 } 2073 } 2074 2075 return 0; 2076 } 2077 2078 int SecCamera::getAntiShake(void) 2079 { 2080 return m_anti_shake; 2081 } 2082 2083 //====================================================================== 2084 2085 2086 int SecCamera::setMetering(int metering_value) 2087 { 2088 LOGV("%s(metering (%d))", __func__, metering_value); 2089 2090 if (metering_value <= METERING_BASE || METERING_MAX <= metering_value) { 2091 LOGE("ERR(%s):Invalid metering_value (%d)", __func__, metering_value); 2092 return -1; 2093 } 2094 2095 if (m_params->metering != metering_value) { 2096 m_params->metering = metering_value; 2097 if (m_flag_camera_start) { 2098 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_METERING, metering_value) < 0) { 2099 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_METERING", __func__); 2100 return -1; 2101 } 2102 } 2103 } 2104 2105 return 0; 2106 } 2107 2108 int SecCamera::getMetering(void) 2109 { 2110 return m_params->metering; 2111 } 2112 2113 //====================================================================== 2114 2115 int SecCamera::setJpegQuality(int jpeg_quality) 2116 { 2117 LOGV("%s(jpeg_quality (%d))", __func__, jpeg_quality); 2118 2119 if (jpeg_quality < JPEG_QUALITY_ECONOMY || JPEG_QUALITY_MAX <= jpeg_quality) { 2120 LOGE("ERR(%s):Invalid jpeg_quality (%d)", __func__, jpeg_quality); 2121 return -1; 2122 } 2123 2124 if (m_jpeg_quality != jpeg_quality) { 2125 m_jpeg_quality = jpeg_quality; 2126 if (m_flag_camera_start && (m_camera_id == CAMERA_ID_BACK)) { 2127 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAM_JPEG_QUALITY, jpeg_quality) < 0) { 2128 LOGE("ERR(%s):Fail on V4L2_CID_CAM_JPEG_QUALITY", __func__); 2129 return -1; 2130 } 2131 } 2132 } 2133 2134 return 0; 2135 } 2136 2137 int SecCamera::getJpegQuality(void) 2138 { 2139 return m_jpeg_quality; 2140 } 2141 2142 //====================================================================== 2143 2144 int SecCamera::setZoom(int zoom_level) 2145 { 2146 LOGV("%s(zoom_level (%d))", __func__, zoom_level); 2147 2148 if (zoom_level < ZOOM_LEVEL_0 || ZOOM_LEVEL_MAX <= zoom_level) { 2149 LOGE("ERR(%s):Invalid zoom_level (%d)", __func__, zoom_level); 2150 return -1; 2151 } 2152 2153 if (m_zoom_level != zoom_level) { 2154 m_zoom_level = zoom_level; 2155 if (m_flag_camera_start) { 2156 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_ZOOM, zoom_level) < 0) { 2157 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_ZOOM", __func__); 2158 return -1; 2159 } 2160 } 2161 } 2162 2163 return 0; 2164 } 2165 2166 int SecCamera::getZoom(void) 2167 { 2168 return m_zoom_level; 2169 } 2170 2171 //====================================================================== 2172 2173 int SecCamera::setObjectTracking(int object_tracking) 2174 { 2175 LOGV("%s(object_tracking (%d))", __func__, object_tracking); 2176 2177 if (object_tracking < OBJECT_TRACKING_OFF || OBJECT_TRACKING_MAX <= object_tracking) { 2178 LOGE("ERR(%s):Invalid object_tracking (%d)", __func__, object_tracking); 2179 return -1; 2180 } 2181 2182 if (m_object_tracking != object_tracking) { 2183 m_object_tracking = object_tracking; 2184 } 2185 2186 return 0; 2187 } 2188 2189 int SecCamera::getObjectTracking(void) 2190 { 2191 return m_object_tracking; 2192 } 2193 2194 int SecCamera::getObjectTrackingStatus(void) 2195 { 2196 int obj_status = 0; 2197 obj_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_STATUS); 2198 return obj_status; 2199 } 2200 2201 int SecCamera::setObjectTrackingStartStop(int start_stop) 2202 { 2203 LOGV("%s(object_tracking_start_stop (%d))", __func__, start_stop); 2204 2205 if (m_object_tracking_start_stop != start_stop) { 2206 m_object_tracking_start_stop = start_stop; 2207 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, start_stop) < 0) { 2208 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP", __func__); 2209 return -1; 2210 } 2211 } 2212 2213 return 0; 2214 } 2215 2216 int SecCamera::setTouchAFStartStop(int start_stop) 2217 { 2218 LOGV("%s(touch_af_start_stop (%d))", __func__, start_stop); 2219 2220 if (m_touch_af_start_stop != start_stop) { 2221 m_touch_af_start_stop = start_stop; 2222 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, start_stop) < 0) { 2223 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_TOUCH_AF_START_STOP", __func__); 2224 return -1; 2225 } 2226 } 2227 2228 return 0; 2229 } 2230 2231 //====================================================================== 2232 2233 int SecCamera::setSmartAuto(int smart_auto) 2234 { 2235 LOGV("%s(smart_auto (%d))", __func__, smart_auto); 2236 2237 if (smart_auto < SMART_AUTO_OFF || SMART_AUTO_MAX <= smart_auto) { 2238 LOGE("ERR(%s):Invalid smart_auto (%d)", __func__, smart_auto); 2239 return -1; 2240 } 2241 2242 if (m_smart_auto != smart_auto) { 2243 m_smart_auto = smart_auto; 2244 if (m_flag_camera_start) { 2245 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO, smart_auto) < 0) { 2246 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SMART_AUTO", __func__); 2247 return -1; 2248 } 2249 } 2250 } 2251 2252 return 0; 2253 } 2254 2255 int SecCamera::getSmartAuto(void) 2256 { 2257 return m_smart_auto; 2258 } 2259 2260 int SecCamera::getAutosceneStatus(void) 2261 { 2262 int autoscene_status = -1; 2263 2264 if (getSmartAuto() == SMART_AUTO_ON) { 2265 autoscene_status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS); 2266 2267 if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) { 2268 LOGE("ERR(%s):Invalid getAutosceneStatus (%d)", __func__, autoscene_status); 2269 return -1; 2270 } 2271 } 2272 //LOGV("%s : autoscene_status (%d)", __func__, autoscene_status); 2273 return autoscene_status; 2274 } 2275 //====================================================================== 2276 2277 int SecCamera::setBeautyShot(int beauty_shot) 2278 { 2279 LOGV("%s(beauty_shot (%d))", __func__, beauty_shot); 2280 2281 if (beauty_shot < BEAUTY_SHOT_OFF || BEAUTY_SHOT_MAX <= beauty_shot) { 2282 LOGE("ERR(%s):Invalid beauty_shot (%d)", __func__, beauty_shot); 2283 return -1; 2284 } 2285 2286 if (m_beauty_shot != beauty_shot) { 2287 m_beauty_shot = beauty_shot; 2288 if (m_flag_camera_start) { 2289 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beauty_shot) < 0) { 2290 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BEAUTY_SHOT", __func__); 2291 return -1; 2292 } 2293 } 2294 2295 setFaceDetect(FACE_DETECTION_ON_BEAUTY); 2296 } 2297 2298 return 0; 2299 } 2300 2301 int SecCamera::getBeautyShot(void) 2302 { 2303 return m_beauty_shot; 2304 } 2305 2306 //====================================================================== 2307 2308 int SecCamera::setVintageMode(int vintage_mode) 2309 { 2310 LOGV("%s(vintage_mode(%d))", __func__, vintage_mode); 2311 2312 if (vintage_mode <= VINTAGE_MODE_BASE || VINTAGE_MODE_MAX <= vintage_mode) { 2313 LOGE("ERR(%s):Invalid vintage_mode (%d)", __func__, vintage_mode); 2314 return -1; 2315 } 2316 2317 if (m_vintage_mode != vintage_mode) { 2318 m_vintage_mode = vintage_mode; 2319 if (m_flag_camera_start) { 2320 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VINTAGE_MODE, vintage_mode) < 0) { 2321 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VINTAGE_MODE", __func__); 2322 return -1; 2323 } 2324 } 2325 } 2326 2327 return 0; 2328 } 2329 2330 int SecCamera::getVintageMode(void) 2331 { 2332 return m_vintage_mode; 2333 } 2334 2335 //====================================================================== 2336 2337 int SecCamera::setFocusMode(int focus_mode) 2338 { 2339 LOGV("%s(focus_mode(%d))", __func__, focus_mode); 2340 2341 if (FOCUS_MODE_MAX <= focus_mode) { 2342 LOGE("ERR(%s):Invalid focus_mode (%d)", __func__, focus_mode); 2343 return -1; 2344 } 2345 2346 if (m_params->focus_mode != focus_mode) { 2347 m_params->focus_mode = focus_mode; 2348 2349 if (m_flag_camera_start) { 2350 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, focus_mode) < 0) { 2351 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODE", __func__); 2352 return -1; 2353 } 2354 } 2355 } 2356 2357 return 0; 2358 } 2359 2360 int SecCamera::getFocusMode(void) 2361 { 2362 return m_params->focus_mode; 2363 } 2364 2365 //====================================================================== 2366 2367 int SecCamera::setFaceDetect(int face_detect) 2368 { 2369 LOGV("%s(face_detect(%d))", __func__, face_detect); 2370 2371 if (m_face_detect != face_detect) { 2372 m_face_detect = face_detect; 2373 if (m_flag_camera_start) { 2374 if (m_face_detect != FACE_DETECTION_OFF) { 2375 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FOCUS_MODE, FOCUS_MODE_AUTO) < 0) { 2376 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FOCUS_MODin face detecion", __func__); 2377 return -1; 2378 } 2379 } 2380 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACE_DETECTION, face_detect) < 0) { 2381 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACE_DETECTION", __func__); 2382 return -1; 2383 } 2384 } 2385 } 2386 2387 return 0; 2388 } 2389 2390 int SecCamera::getFaceDetect(void) 2391 { 2392 return m_face_detect; 2393 } 2394 2395 //====================================================================== 2396 2397 int SecCamera::setGPSLatitude(const char *gps_latitude) 2398 { 2399 LOGV("%s(gps_latitude(%s))", __func__, gps_latitude); 2400 if (gps_latitude == NULL) 2401 m_gps_enabled = false; 2402 else { 2403 m_gps_enabled = true; 2404 m_gps_latitude = lround(strtod(gps_latitude, NULL) * 10000000); 2405 } 2406 2407 LOGV("%s(m_gps_latitude(%ld))", __func__, m_gps_latitude); 2408 return 0; 2409 } 2410 2411 int SecCamera::setGPSLongitude(const char *gps_longitude) 2412 { 2413 LOGV("%s(gps_longitude(%s))", __func__, gps_longitude); 2414 if (gps_longitude == NULL) 2415 m_gps_enabled = false; 2416 else { 2417 m_gps_enabled = true; 2418 m_gps_longitude = lround(strtod(gps_longitude, NULL) * 10000000); 2419 } 2420 2421 LOGV("%s(m_gps_longitude(%ld))", __func__, m_gps_longitude); 2422 return 0; 2423 } 2424 2425 int SecCamera::setGPSAltitude(const char *gps_altitude) 2426 { 2427 LOGV("%s(gps_altitude(%s))", __func__, gps_altitude); 2428 if (gps_altitude == NULL) 2429 m_gps_altitude = 0; 2430 else { 2431 m_gps_altitude = lround(strtod(gps_altitude, NULL) * 100); 2432 } 2433 2434 LOGV("%s(m_gps_altitude(%ld))", __func__, m_gps_altitude); 2435 return 0; 2436 } 2437 2438 int SecCamera::setGPSTimeStamp(const char *gps_timestamp) 2439 { 2440 LOGV("%s(gps_timestamp(%s))", __func__, gps_timestamp); 2441 if (gps_timestamp == NULL) 2442 m_gps_timestamp = 0; 2443 else 2444 m_gps_timestamp = atol(gps_timestamp); 2445 2446 LOGV("%s(m_gps_timestamp(%ld))", __func__, m_gps_timestamp); 2447 return 0; 2448 } 2449 2450 int SecCamera::setGPSProcessingMethod(const char *gps_processing_method) 2451 { 2452 LOGV("%s(gps_processing_method(%s))", __func__, gps_processing_method); 2453 memset(mExifInfo.gps_processing_method, 0, sizeof(mExifInfo.gps_processing_method)); 2454 if (gps_processing_method != NULL) { 2455 size_t len = strlen(gps_processing_method); 2456 if (len > sizeof(mExifInfo.gps_processing_method)) { 2457 len = sizeof(mExifInfo.gps_processing_method); 2458 } 2459 memcpy(mExifInfo.gps_processing_method, gps_processing_method, len); 2460 } 2461 return 0; 2462 } 2463 2464 int SecCamera::setFaceDetectLockUnlock(int facedetect_lockunlock) 2465 { 2466 LOGV("%s(facedetect_lockunlock(%d))", __func__, facedetect_lockunlock); 2467 2468 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK, facedetect_lockunlock) < 0) { 2469 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK", __func__); 2470 return -1; 2471 } 2472 2473 return 0; 2474 } 2475 2476 int SecCamera::setObjectPosition(int x, int y) 2477 { 2478 LOGV("%s(setObjectPosition(x=%d, y=%d))", __func__, x, y); 2479 2480 if (m_preview_width ==640) 2481 x = x - 80; 2482 2483 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_X, x) < 0) { 2484 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_X", __func__); 2485 return -1; 2486 } 2487 2488 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_OBJECT_POSITION_Y, y) < 0) { 2489 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_OBJECT_POSITION_Y", __func__); 2490 return -1; 2491 } 2492 2493 return 0; 2494 } 2495 2496 //====================================================================== 2497 2498 int SecCamera::setGamma(int gamma) 2499 { 2500 LOGV("%s(gamma(%d))", __func__, gamma); 2501 2502 if (gamma < GAMMA_OFF || GAMMA_MAX <= gamma) { 2503 LOGE("ERR(%s):Invalid gamma (%d)", __func__, gamma); 2504 return -1; 2505 } 2506 2507 if (m_video_gamma != gamma) { 2508 m_video_gamma = gamma; 2509 if (m_flag_camera_start) { 2510 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) { 2511 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_GAMMA", __func__); 2512 return -1; 2513 } 2514 } 2515 } 2516 2517 return 0; 2518 } 2519 2520 //====================================================================== 2521 2522 int SecCamera::setSlowAE(int slow_ae) 2523 { 2524 LOGV("%s(slow_ae(%d))", __func__, slow_ae); 2525 2526 if (slow_ae < GAMMA_OFF || GAMMA_MAX <= slow_ae) { 2527 LOGE("ERR(%s):Invalid slow_ae (%d)", __func__, slow_ae); 2528 return -1; 2529 } 2530 2531 if (m_slow_ae!= slow_ae) { 2532 m_slow_ae = slow_ae; 2533 if (m_flag_camera_start) { 2534 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) { 2535 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_SET_SLOW_AE", __func__); 2536 return -1; 2537 } 2538 } 2539 } 2540 2541 return 0; 2542 } 2543 2544 //====================================================================== 2545 int SecCamera::setRecordingSize(int width, int height) 2546 { 2547 LOGV("%s(width(%d), height(%d))", __func__, width, height); 2548 2549 m_recording_width = width; 2550 m_recording_height = height; 2551 2552 return 0; 2553 } 2554 2555 //====================================================================== 2556 2557 int SecCamera::setExifOrientationInfo(int orientationInfo) 2558 { 2559 LOGV("%s(orientationInfo(%d))", __func__, orientationInfo); 2560 2561 if (orientationInfo < 0) { 2562 LOGE("ERR(%s):Invalid orientationInfo (%d)", __func__, orientationInfo); 2563 return -1; 2564 } 2565 m_exif_orientation = orientationInfo; 2566 2567 return 0; 2568 } 2569 2570 //====================================================================== 2571 int SecCamera::setBatchReflection() 2572 { 2573 if (m_flag_camera_start) { 2574 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_BATCH_REFLECTION, 1) < 0) { 2575 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_BATCH_REFLECTION", __func__); 2576 return -1; 2577 } 2578 } 2579 2580 return 0; 2581 } 2582 2583 /*Video call*/ 2584 int SecCamera::setVTmode(int vtmode) 2585 { 2586 LOGV("%s(vtmode (%d))", __func__, vtmode); 2587 2588 if (vtmode < VT_MODE_OFF || VT_MODE_MAX <= vtmode) { 2589 LOGE("ERR(%s):Invalid vtmode (%d)", __func__, vtmode); 2590 return -1; 2591 } 2592 2593 if (m_vtmode != vtmode) { 2594 m_vtmode = vtmode; 2595 } 2596 2597 return 0; 2598 } 2599 2600 /* Camcorder fix fps */ 2601 int SecCamera::setSensorMode(int sensor_mode) 2602 { 2603 LOGV("%s(sensor_mode (%d))", __func__, sensor_mode); 2604 2605 if (sensor_mode < SENSOR_MODE_CAMERA || SENSOR_MODE_MOVIE < sensor_mode) { 2606 LOGE("ERR(%s):Invalid sensor mode (%d)", __func__, sensor_mode); 2607 return -1; 2608 } 2609 2610 if (m_sensor_mode != sensor_mode) { 2611 m_sensor_mode = sensor_mode; 2612 } 2613 2614 return 0; 2615 } 2616 2617 /* Shot mode */ 2618 /* SINGLE = 0 2619 * CONTINUOUS = 1 2620 * PANORAMA = 2 2621 * SMILE = 3 2622 * SELF = 6 2623 */ 2624 int SecCamera::setShotMode(int shot_mode) 2625 { 2626 LOGV("%s(shot_mode (%d))", __func__, shot_mode); 2627 if (shot_mode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shot_mode) { 2628 LOGE("ERR(%s):Invalid shot_mode (%d)", __func__, shot_mode); 2629 return -1; 2630 } 2631 m_shot_mode = shot_mode; 2632 2633 return 0; 2634 } 2635 2636 int SecCamera::getVTmode(void) 2637 { 2638 return m_vtmode; 2639 } 2640 2641 int SecCamera::setBlur(int blur_level) 2642 { 2643 LOGV("%s(level (%d))", __func__, blur_level); 2644 2645 if (blur_level < BLUR_LEVEL_0 || BLUR_LEVEL_MAX <= blur_level) { 2646 LOGE("ERR(%s):Invalid level (%d)", __func__, blur_level); 2647 return -1; 2648 } 2649 2650 if (m_blur_level != blur_level) { 2651 m_blur_level = blur_level; 2652 if (m_flag_camera_start) { 2653 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_VGA_BLUR, blur_level) < 0) { 2654 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_VGA_BLUR", __func__); 2655 return -1; 2656 } 2657 } 2658 } 2659 return 0; 2660 } 2661 2662 int SecCamera::getBlur(void) 2663 { 2664 return m_blur_level; 2665 } 2666 2667 int SecCamera::setDataLineCheck(int chk_dataline) 2668 { 2669 LOGV("%s(chk_dataline (%d))", __func__, chk_dataline); 2670 2671 if (chk_dataline < CHK_DATALINE_OFF || CHK_DATALINE_MAX <= chk_dataline) { 2672 LOGE("ERR(%s):Invalid chk_dataline (%d)", __func__, chk_dataline); 2673 return -1; 2674 } 2675 2676 m_chk_dataline = chk_dataline; 2677 2678 return 0; 2679 } 2680 2681 int SecCamera::getDataLineCheck(void) 2682 { 2683 return m_chk_dataline; 2684 } 2685 2686 int SecCamera::setDataLineCheckStop(void) 2687 { 2688 LOGV("%s", __func__); 2689 2690 if (m_flag_camera_start) { 2691 if (fimc_v4l2_s_ctrl(m_cam_fd, V4L2_CID_CAMERA_CHECK_DATALINE_STOP, 1) < 0) { 2692 LOGE("ERR(%s):Fail on V4L2_CID_CAMERA_CHECK_DATALINE_STOP", __func__); 2693 return -1; 2694 } 2695 } 2696 return 0; 2697 } 2698 2699 const __u8* SecCamera::getCameraSensorName(void) 2700 { 2701 LOGV("%s", __func__); 2702 2703 return fimc_v4l2_enuminput(m_cam_fd, getCameraId()); 2704 } 2705 2706 #ifdef ENABLE_ESD_PREVIEW_CHECK 2707 int SecCamera::getCameraSensorESDStatus(void) 2708 { 2709 LOGV("%s", __func__); 2710 2711 // 0 : normal operation, 1 : abnormal operation 2712 int status = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_ESD_INT); 2713 2714 return status; 2715 } 2716 #endif // ENABLE_ESD_PREVIEW_CHECK 2717 2718 // ====================================================================== 2719 // Jpeg 2720 2721 int SecCamera::setJpegThumbnailSize(int width, int height) 2722 { 2723 LOGV("%s(width(%d), height(%d))", __func__, width, height); 2724 2725 m_jpeg_thumbnail_width = width; 2726 m_jpeg_thumbnail_height = height; 2727 2728 return 0; 2729 } 2730 2731 int SecCamera::getJpegThumbnailSize(int *width, int *height) 2732 { 2733 if (width) 2734 *width = m_jpeg_thumbnail_width; 2735 if (height) 2736 *height = m_jpeg_thumbnail_height; 2737 2738 return 0; 2739 } 2740 2741 void SecCamera::setExifFixedAttribute() 2742 { 2743 char property[PROPERTY_VALUE_MAX]; 2744 2745 //2 0th IFD TIFF Tags 2746 //3 Maker 2747 property_get("ro.product.brand", property, EXIF_DEF_MAKER); 2748 strncpy((char *)mExifInfo.maker, property, 2749 sizeof(mExifInfo.maker) - 1); 2750 mExifInfo.maker[sizeof(mExifInfo.maker) - 1] = '\0'; 2751 //3 Model 2752 property_get("ro.product.model", property, EXIF_DEF_MODEL); 2753 strncpy((char *)mExifInfo.model, property, 2754 sizeof(mExifInfo.model) - 1); 2755 mExifInfo.model[sizeof(mExifInfo.model) - 1] = '\0'; 2756 //3 Software 2757 property_get("ro.build.id", property, EXIF_DEF_SOFTWARE); 2758 strncpy((char *)mExifInfo.software, property, 2759 sizeof(mExifInfo.software) - 1); 2760 mExifInfo.software[sizeof(mExifInfo.software) - 1] = '\0'; 2761 2762 //3 YCbCr Positioning 2763 mExifInfo.ycbcr_positioning = EXIF_DEF_YCBCR_POSITIONING; 2764 2765 //2 0th IFD Exif Private Tags 2766 //3 F Number 2767 mExifInfo.fnumber.num = EXIF_DEF_FNUMBER_NUM; 2768 mExifInfo.fnumber.den = EXIF_DEF_FNUMBER_DEN; 2769 //3 Exposure Program 2770 mExifInfo.exposure_program = EXIF_DEF_EXPOSURE_PROGRAM; 2771 //3 Exif Version 2772 memcpy(mExifInfo.exif_version, EXIF_DEF_EXIF_VERSION, sizeof(mExifInfo.exif_version)); 2773 //3 Aperture 2774 uint32_t av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num/mExifInfo.fnumber.den); 2775 mExifInfo.aperture.num = av*EXIF_DEF_APEX_DEN; 2776 mExifInfo.aperture.den = EXIF_DEF_APEX_DEN; 2777 //3 Maximum lens aperture 2778 mExifInfo.max_aperture.num = mExifInfo.aperture.num; 2779 mExifInfo.max_aperture.den = mExifInfo.aperture.den; 2780 //3 Lens Focal Length 2781 if (m_camera_id == CAMERA_ID_BACK) 2782 mExifInfo.focal_length.num = BACK_CAMERA_FOCAL_LENGTH; 2783 else 2784 mExifInfo.focal_length.num = FRONT_CAMERA_FOCAL_LENGTH; 2785 2786 mExifInfo.focal_length.den = EXIF_DEF_FOCAL_LEN_DEN; 2787 //3 User Comments 2788 strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS); 2789 //3 Color Space information 2790 mExifInfo.color_space = EXIF_DEF_COLOR_SPACE; 2791 //3 Exposure Mode 2792 mExifInfo.exposure_mode = EXIF_DEF_EXPOSURE_MODE; 2793 2794 //2 0th IFD GPS Info Tags 2795 unsigned char gps_version[4] = { 0x02, 0x02, 0x00, 0x00 }; 2796 memcpy(mExifInfo.gps_version_id, gps_version, sizeof(gps_version)); 2797 2798 //2 1th IFD TIFF Tags 2799 mExifInfo.compression_scheme = EXIF_DEF_COMPRESSION; 2800 mExifInfo.x_resolution.num = EXIF_DEF_RESOLUTION_NUM; 2801 mExifInfo.x_resolution.den = EXIF_DEF_RESOLUTION_DEN; 2802 mExifInfo.y_resolution.num = EXIF_DEF_RESOLUTION_NUM; 2803 mExifInfo.y_resolution.den = EXIF_DEF_RESOLUTION_DEN; 2804 mExifInfo.resolution_unit = EXIF_DEF_RESOLUTION_UNIT; 2805 } 2806 2807 void SecCamera::setExifChangedAttribute() 2808 { 2809 //2 0th IFD TIFF Tags 2810 //3 Width 2811 mExifInfo.width = m_snapshot_width; 2812 //3 Height 2813 mExifInfo.height = m_snapshot_height; 2814 //3 Orientation 2815 switch (m_exif_orientation) { 2816 case 0: 2817 mExifInfo.orientation = EXIF_ORIENTATION_UP; 2818 break; 2819 case 90: 2820 mExifInfo.orientation = EXIF_ORIENTATION_90; 2821 break; 2822 case 180: 2823 mExifInfo.orientation = EXIF_ORIENTATION_180; 2824 break; 2825 case 270: 2826 mExifInfo.orientation = EXIF_ORIENTATION_270; 2827 break; 2828 default: 2829 mExifInfo.orientation = EXIF_ORIENTATION_UP; 2830 break; 2831 } 2832 //3 Date time 2833 time_t rawtime; 2834 struct tm *timeinfo; 2835 time(&rawtime); 2836 timeinfo = localtime(&rawtime); 2837 strftime((char *)mExifInfo.date_time, 20, "%Y:%m:%d %H:%M:%S", timeinfo); 2838 2839 //2 0th IFD Exif Private Tags 2840 //3 Exposure Time 2841 int shutterSpeed = fimc_v4l2_g_ctrl(m_cam_fd, 2842 V4L2_CID_CAMERA_GET_SHT_TIME); 2843 /* TBD - front camera needs to be fixed to support this g_ctrl, 2844 it current returns a negative err value, so avoid putting 2845 odd value into exif for now */ 2846 if (shutterSpeed < 0) { 2847 LOGE("%s: error %d getting shutterSpeed, camera_id = %d, using 100", 2848 __func__, shutterSpeed, m_camera_id); 2849 shutterSpeed = 100; 2850 } 2851 mExifInfo.exposure_time.num = 1; 2852 // x us -> 1/x s */ 2853 mExifInfo.exposure_time.den = (uint32_t)(1000000 / shutterSpeed); 2854 2855 //3 ISO Speed Rating 2856 int iso = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_ISO); 2857 /* TBD - front camera needs to be fixed to support this g_ctrl, 2858 it current returns a negative err value, so avoid putting 2859 odd value into exif for now */ 2860 if (iso < 0) { 2861 LOGE("%s: error %d getting iso, camera_id = %d, using 100", 2862 __func__, iso, m_camera_id); 2863 iso = ISO_100; 2864 } 2865 switch(iso) { 2866 case ISO_50: 2867 mExifInfo.iso_speed_rating = 50; 2868 break; 2869 case ISO_100: 2870 mExifInfo.iso_speed_rating = 100; 2871 break; 2872 case ISO_200: 2873 mExifInfo.iso_speed_rating = 200; 2874 break; 2875 case ISO_400: 2876 mExifInfo.iso_speed_rating = 400; 2877 break; 2878 case ISO_800: 2879 mExifInfo.iso_speed_rating = 800; 2880 break; 2881 case ISO_1600: 2882 mExifInfo.iso_speed_rating = 1600; 2883 break; 2884 default: 2885 mExifInfo.iso_speed_rating = 100; 2886 break; 2887 } 2888 2889 uint32_t av, tv, bv, sv, ev; 2890 av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num / mExifInfo.fnumber.den); 2891 tv = APEX_EXPOSURE_TO_SHUTTER((double)mExifInfo.exposure_time.num / mExifInfo.exposure_time.den); 2892 sv = APEX_ISO_TO_FILMSENSITIVITY(mExifInfo.iso_speed_rating); 2893 bv = av + tv - sv; 2894 ev = av + tv; 2895 LOGD("Shutter speed=%d us, iso=%d\n", shutterSpeed, mExifInfo.iso_speed_rating); 2896 LOGD("AV=%d, TV=%d, SV=%d\n", av, tv, sv); 2897 2898 //3 Shutter Speed 2899 mExifInfo.shutter_speed.num = tv*EXIF_DEF_APEX_DEN; 2900 mExifInfo.shutter_speed.den = EXIF_DEF_APEX_DEN; 2901 //3 Brightness 2902 mExifInfo.brightness.num = bv*EXIF_DEF_APEX_DEN; 2903 mExifInfo.brightness.den = EXIF_DEF_APEX_DEN; 2904 //3 Exposure Bias 2905 if (m_params->scene_mode == SCENE_MODE_BEACH_SNOW) { 2906 mExifInfo.exposure_bias.num = EXIF_DEF_APEX_DEN; 2907 mExifInfo.exposure_bias.den = EXIF_DEF_APEX_DEN; 2908 } else { 2909 mExifInfo.exposure_bias.num = 0; 2910 mExifInfo.exposure_bias.den = 0; 2911 } 2912 //3 Metering Mode 2913 switch (m_params->metering) { 2914 case METERING_SPOT: 2915 mExifInfo.metering_mode = EXIF_METERING_SPOT; 2916 break; 2917 case METERING_MATRIX: 2918 mExifInfo.metering_mode = EXIF_METERING_AVERAGE; 2919 break; 2920 case METERING_CENTER: 2921 mExifInfo.metering_mode = EXIF_METERING_CENTER; 2922 break; 2923 default : 2924 mExifInfo.metering_mode = EXIF_METERING_AVERAGE; 2925 break; 2926 } 2927 2928 //3 Flash 2929 int flash = fimc_v4l2_g_ctrl(m_cam_fd, V4L2_CID_CAMERA_GET_FLASH_ONOFF); 2930 if (flash < 0) 2931 mExifInfo.flash = EXIF_DEF_FLASH; 2932 else 2933 mExifInfo.flash = flash; 2934 2935 //3 White Balance 2936 if (m_params->white_balance == WHITE_BALANCE_AUTO) 2937 mExifInfo.white_balance = EXIF_WB_AUTO; 2938 else 2939 mExifInfo.white_balance = EXIF_WB_MANUAL; 2940 //3 Scene Capture Type 2941 switch (m_params->scene_mode) { 2942 case SCENE_MODE_PORTRAIT: 2943 mExifInfo.scene_capture_type = EXIF_SCENE_PORTRAIT; 2944 break; 2945 case SCENE_MODE_LANDSCAPE: 2946 mExifInfo.scene_capture_type = EXIF_SCENE_LANDSCAPE; 2947 break; 2948 case SCENE_MODE_NIGHTSHOT: 2949 mExifInfo.scene_capture_type = EXIF_SCENE_NIGHT; 2950 break; 2951 default: 2952 mExifInfo.scene_capture_type = EXIF_SCENE_STANDARD; 2953 break; 2954 } 2955 2956 //2 0th IFD GPS Info Tags 2957 if (m_gps_enabled) { 2958 if (m_gps_latitude >= 0) 2959 strcpy((char *)mExifInfo.gps_latitude_ref, "N"); 2960 else 2961 strcpy((char *)mExifInfo.gps_latitude_ref, "S"); 2962 2963 if (m_gps_longitude >= 0) 2964 strcpy((char *)mExifInfo.gps_longitude_ref, "E"); 2965 else 2966 strcpy((char *)mExifInfo.gps_longitude_ref, "W"); 2967 2968 if (m_gps_altitude >= 0) 2969 mExifInfo.gps_altitude_ref = 0; 2970 else 2971 mExifInfo.gps_altitude_ref = 1; 2972 2973 mExifInfo.gps_latitude[0].num = (uint32_t)labs(m_gps_latitude); 2974 mExifInfo.gps_latitude[0].den = 10000000; 2975 mExifInfo.gps_latitude[1].num = 0; 2976 mExifInfo.gps_latitude[1].den = 1; 2977 mExifInfo.gps_latitude[2].num = 0; 2978 mExifInfo.gps_latitude[2].den = 1; 2979 2980 mExifInfo.gps_longitude[0].num = (uint32_t)labs(m_gps_longitude); 2981 mExifInfo.gps_longitude[0].den = 10000000; 2982 mExifInfo.gps_longitude[1].num = 0; 2983 mExifInfo.gps_longitude[1].den = 1; 2984 mExifInfo.gps_longitude[2].num = 0; 2985 mExifInfo.gps_longitude[2].den = 1; 2986 2987 mExifInfo.gps_altitude.num = (uint32_t)labs(m_gps_altitude); 2988 mExifInfo.gps_altitude.den = 100; 2989 2990 struct tm tm_data; 2991 gmtime_r(&m_gps_timestamp, &tm_data); 2992 mExifInfo.gps_timestamp[0].num = tm_data.tm_hour; 2993 mExifInfo.gps_timestamp[0].den = 1; 2994 mExifInfo.gps_timestamp[1].num = tm_data.tm_min; 2995 mExifInfo.gps_timestamp[1].den = 1; 2996 mExifInfo.gps_timestamp[2].num = tm_data.tm_sec; 2997 mExifInfo.gps_timestamp[2].den = 1; 2998 snprintf((char*)mExifInfo.gps_datestamp, sizeof(mExifInfo.gps_datestamp), 2999 "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon + 1, tm_data.tm_mday); 3000 3001 mExifInfo.enableGps = true; 3002 } else { 3003 mExifInfo.enableGps = false; 3004 } 3005 3006 //2 1th IFD TIFF Tags 3007 mExifInfo.widthThumb = m_jpeg_thumbnail_width; 3008 mExifInfo.heightThumb = m_jpeg_thumbnail_height; 3009 } 3010 3011 // ====================================================================== 3012 // Conversions 3013 3014 inline int SecCamera::m_frameSize(int format, int width, int height) 3015 { 3016 int size = 0; 3017 3018 switch (format) { 3019 case V4L2_PIX_FMT_YUV420: 3020 case V4L2_PIX_FMT_NV12: 3021 case V4L2_PIX_FMT_NV21: 3022 size = (width * height * 3 / 2); 3023 break; 3024 3025 case V4L2_PIX_FMT_NV12T: 3026 size = ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)) + 3027 ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2)); 3028 break; 3029 3030 case V4L2_PIX_FMT_YUV422P: 3031 case V4L2_PIX_FMT_YUYV: 3032 case V4L2_PIX_FMT_UYVY: 3033 size = (width * height * 2); 3034 break; 3035 3036 default : 3037 LOGE("ERR(%s):Invalid V4L2 pixel format(%d)\n", __func__, format); 3038 case V4L2_PIX_FMT_RGB565: 3039 size = (width * height * BPP); 3040 break; 3041 } 3042 3043 return size; 3044 } 3045 3046 status_t SecCamera::dump(int fd) 3047 { 3048 const size_t SIZE = 256; 3049 char buffer[SIZE]; 3050 String8 result; 3051 snprintf(buffer, 255, "dump(%d)\n", fd); 3052 result.append(buffer); 3053 ::write(fd, result.string(), result.size()); 3054 return NO_ERROR; 3055 } 3056 3057 double SecCamera::jpeg_ratio = 0.7; 3058 int SecCamera::interleaveDataSize = 5242880; 3059 int SecCamera::jpegLineLength = 636; 3060 3061 }; // namespace android 3062
