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 toggle 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 * \file ExynosCamera.cpp 20 * \brief source file for CAMERA HAL MODULE 21 * \author thun.hwang(thun.hwang (at) samsung.com) 22 * \date 2010/06/03 23 * 24 * <b>Revision History: </b> 25 * - 2011/12/31 : thun.hwang(thun.hwang (at) samsung.com) \n 26 * Initial version 27 * 28 * - 2012/01/18 : Sangwoo, Park(sw5771.park (at) samsung.com) \n 29 * Adjust Doxygen Document 30 * 31 * - 2012/02/01 : Sangwoo, Park(sw5771.park (at) samsung.com) \n 32 * Adjust libv4l2 33 * Adjust struct ExynosCameraInfo 34 * External ISP feature 35 * 36 * - 2012/03/14 : sangwoo.park(sw5771.park (at) samsung.com) \n 37 * Change file, class name to ExynosXXX. 38 */ 39 40 /** 41 * @page ExynosCamera 42 * 43 * @section Introduction 44 * ExynosCamera is for camera preview,takePicture and recording. 45 * (Currently libseccamera is included in Android Camera HAL(libcamera.so). 46 * 47 * @section Copyright 48 * Copyright (c) 2008-2011 Samsung Electronics Co., Ltd.All rights reserved. \n 49 * Proprietary and Confidential 50 * 51 * @image html samsung.png 52 */ 53 54 //#define LOG_NDEBUG 0 55 #define LOG_TAG "ExynosCamera" 56 57 /* FIXME: This define will be removed when functions are stable */ 58 //#define USE_DIS 59 //#define USE_3DNR 60 //#define USE_ODC 61 62 #include <utils/Log.h> 63 64 #include "ExynosCamera.h" 65 #include "exynos_format.h" 66 67 using namespace android; 68 69 namespace android { 70 71 ExynosCameraInfo::ExynosCameraInfo() 72 { 73 previewW = 2560; 74 previewH = 1920; 75 previewColorFormat = V4L2_PIX_FMT_NV21; 76 videoW = 1920; 77 videoH = 1080; 78 prefVideoPreviewW = 640; 79 prefVideoPreviewH = 360; 80 videoColorFormat = V4L2_PIX_FMT_NV12M; 81 pictureW = 2560; 82 pictureH = 1920; 83 pictureColorFormat = V4L2_PIX_FMT_YUYV; 84 thumbnailW = 320; 85 thumbnailH = 240; 86 87 antiBandingList = 88 ExynosCamera::ANTIBANDING_OFF 89 | ExynosCamera::ANTIBANDING_50HZ 90 | ExynosCamera::ANTIBANDING_60HZ 91 | ExynosCamera::ANTIBANDING_OFF; 92 antiBanding = ExynosCamera::ANTIBANDING_OFF; 93 94 effectList = 95 ExynosCamera::EFFECT_NONE 96 | ExynosCamera::EFFECT_MONO 97 | ExynosCamera::EFFECT_NEGATIVE 98 | ExynosCamera::EFFECT_SOLARIZE 99 | ExynosCamera::EFFECT_SEPIA 100 | ExynosCamera::EFFECT_POSTERIZE 101 | ExynosCamera::EFFECT_WHITEBOARD 102 | ExynosCamera::EFFECT_BLACKBOARD 103 | ExynosCamera::EFFECT_AQUA; 104 effect = ExynosCamera::EFFECT_NONE; 105 106 flashModeList = 107 ExynosCamera::FLASH_MODE_OFF 108 | ExynosCamera::FLASH_MODE_AUTO 109 | ExynosCamera::FLASH_MODE_ON 110 | ExynosCamera::FLASH_MODE_RED_EYE 111 | ExynosCamera::FLASH_MODE_TORCH; 112 flashMode = ExynosCamera::FLASH_MODE_OFF; 113 114 focusModeList = 115 ExynosCamera::FOCUS_MODE_AUTO 116 | ExynosCamera::FOCUS_MODE_INFINITY 117 | ExynosCamera::FOCUS_MODE_MACRO 118 | ExynosCamera::FOCUS_MODE_FIXED 119 | ExynosCamera::FOCUS_MODE_EDOF 120 | ExynosCamera::FOCUS_MODE_CONTINUOUS_VIDEO 121 | ExynosCamera::FOCUS_MODE_CONTINUOUS_PICTURE 122 | ExynosCamera::FOCUS_MODE_TOUCH; 123 focusMode = ExynosCamera::FOCUS_MODE_AUTO; 124 125 sceneModeList = 126 ExynosCamera::SCENE_MODE_AUTO 127 | ExynosCamera::SCENE_MODE_ACTION 128 | ExynosCamera::SCENE_MODE_PORTRAIT 129 | ExynosCamera::SCENE_MODE_LANDSCAPE 130 | ExynosCamera::SCENE_MODE_NIGHT 131 | ExynosCamera::SCENE_MODE_NIGHT_PORTRAIT 132 | ExynosCamera::SCENE_MODE_THEATRE 133 | ExynosCamera::SCENE_MODE_BEACH 134 | ExynosCamera::SCENE_MODE_SNOW 135 | ExynosCamera::SCENE_MODE_SUNSET 136 | ExynosCamera::SCENE_MODE_STEADYPHOTO 137 | ExynosCamera::SCENE_MODE_FIREWORKS 138 | ExynosCamera::SCENE_MODE_SPORTS 139 | ExynosCamera::SCENE_MODE_PARTY 140 | ExynosCamera::SCENE_MODE_CANDLELIGHT; 141 sceneMode = ExynosCamera::SCENE_MODE_AUTO; 142 143 whiteBalanceList = 144 ExynosCamera::WHITE_BALANCE_AUTO 145 | ExynosCamera::WHITE_BALANCE_INCANDESCENT 146 | ExynosCamera::WHITE_BALANCE_FLUORESCENT 147 | ExynosCamera::WHITE_BALANCE_WARM_FLUORESCENT 148 | ExynosCamera::WHITE_BALANCE_DAYLIGHT 149 | ExynosCamera::WHITE_BALANCE_CLOUDY_DAYLIGHT 150 | ExynosCamera::WHITE_BALANCE_TWILIGHT 151 | ExynosCamera::WHITE_BALANCE_SHADE; 152 whiteBalance = ExynosCamera::WHITE_BALANCE_AUTO; 153 154 autoWhiteBalanceLockSupported = false; 155 autoWhiteBalanceLock = false; 156 157 rotation = 0; 158 minExposure = -2; 159 maxExposure = 2; 160 exposure = 0; 161 162 autoExposureLockSupported = false; 163 autoExposureLock = false; 164 165 fps = 30; 166 focalLengthNum = 9; 167 focalLengthDen = 10; 168 supportVideoStabilization = false; 169 applyVideoStabilization = false; 170 videoStabilization = false; 171 maxNumMeteringAreas = 0; 172 maxNumDetectedFaces = 0; 173 maxNumFocusAreas = 0; 174 maxZoom = ZOOM_LEVEL_MAX; 175 hwZoomSupported = false; 176 zoom = 0; 177 gpsAltitude = 0; 178 gpsLatitude = 0; 179 gpsLongitude = 0; 180 gpsTimestamp = 0; 181 182 // Additional API default Value. 183 angle = 0; 184 antiShake = false; 185 beautyShot = false; 186 brightness = 0; 187 contrast = ExynosCamera::CONTRAST_DEFAULT; 188 gamma = false; 189 hue = 2; // 2 is default; 190 iso = 0; 191 metering = ExynosCamera::METERING_MODE_CENTER; 192 objectTracking = false; 193 objectTrackingStart = false; 194 saturation = 0; 195 sharpness = 0; 196 shotMode = ExynosCamera::SHOT_MODE_SINGLE; 197 slowAE = false; 198 smartAuto = false; 199 touchAfStart = false; 200 wdr = false; 201 tdnr = false; 202 odc = false; 203 } 204 205 ExynosCameraInfoM5M0::ExynosCameraInfoM5M0() 206 { 207 previewW = 1280; 208 previewH = 720; 209 previewColorFormat = V4L2_PIX_FMT_YVU420M; 210 videoW = 1280; 211 videoH = 720; 212 prefVideoPreviewW = 640; 213 prefVideoPreviewH = 360; 214 videoColorFormat = V4L2_PIX_FMT_NV12M; 215 pictureW = 1280; 216 pictureH = 720; 217 pictureColorFormat = V4L2_PIX_FMT_YUYV; 218 thumbnailW = 320; 219 thumbnailH = 240; 220 221 antiBandingList = ExynosCamera::ANTIBANDING_OFF; 222 antiBanding = ExynosCamera::ANTIBANDING_OFF; 223 224 effectList = 225 ExynosCamera::EFFECT_NONE 226 | ExynosCamera::EFFECT_MONO 227 | ExynosCamera::EFFECT_NEGATIVE 228 //| ExynosCamera::EFFECT_SOLARIZE 229 | ExynosCamera::EFFECT_SEPIA 230 //| ExynosCamera::EFFECT_POSTERIZE 231 //| ExynosCamera::EFFECT_WHITEBOARD 232 //| ExynosCamera::EFFECT_BLACKBOARD 233 | ExynosCamera::EFFECT_AQUA; 234 effect = ExynosCamera::EFFECT_NONE; 235 236 flashModeList = 237 ExynosCamera::FLASH_MODE_OFF 238 | ExynosCamera::FLASH_MODE_AUTO 239 | ExynosCamera::FLASH_MODE_ON 240 | ExynosCamera::FLASH_MODE_RED_EYE 241 | ExynosCamera::FLASH_MODE_TORCH; 242 flashMode = ExynosCamera::FLASH_MODE_OFF; 243 244 focusModeList = 245 ExynosCamera::FOCUS_MODE_AUTO 246 | ExynosCamera::FOCUS_MODE_INFINITY 247 | ExynosCamera::FOCUS_MODE_MACRO 248 //| ExynosCamera::FOCUS_MODE_FIXED 249 //| ExynosCamera::FOCUS_MODE_EDOF 250 //| ExynosCamera::FOCUS_MODE_CONTINUOUS_VIDEO 251 //| ExynosCamera::FOCUS_MODE_CONTINUOUS_PICTURE 252 //| ExynosCamera::FOCUS_MODE_TOUCH 253 ; 254 focusMode = ExynosCamera::FOCUS_MODE_AUTO; 255 256 sceneModeList = 257 ExynosCamera::SCENE_MODE_AUTO 258 //| ExynosCamera::SCENE_MODE_ACTION 259 | ExynosCamera::SCENE_MODE_PORTRAIT 260 | ExynosCamera::SCENE_MODE_LANDSCAPE 261 | ExynosCamera::SCENE_MODE_NIGHT 262 //| ExynosCamera::SCENE_MODE_NIGHT_PORTRAIT 263 //| ExynosCamera::SCENE_MODE_THEATRE 264 | ExynosCamera::SCENE_MODE_BEACH 265 | ExynosCamera::SCENE_MODE_SNOW 266 | ExynosCamera::SCENE_MODE_SUNSET 267 //| ExynosCamera::SCENE_MODE_STEADYPHOTO 268 | ExynosCamera::SCENE_MODE_FIREWORKS 269 | ExynosCamera::SCENE_MODE_SPORTS 270 | ExynosCamera::SCENE_MODE_PARTY 271 | ExynosCamera::SCENE_MODE_CANDLELIGHT; 272 sceneMode = ExynosCamera::SCENE_MODE_AUTO; 273 274 whiteBalanceList = 275 ExynosCamera::WHITE_BALANCE_AUTO 276 | ExynosCamera::WHITE_BALANCE_INCANDESCENT 277 | ExynosCamera::WHITE_BALANCE_FLUORESCENT 278 //| ExynosCamera::WHITE_BALANCE_WARM_FLUORESCENT 279 | ExynosCamera::WHITE_BALANCE_DAYLIGHT 280 | ExynosCamera::WHITE_BALANCE_CLOUDY_DAYLIGHT 281 //| ExynosCamera::WHITE_BALANCE_TWILIGHT 282 //| ExynosCamera::WHITE_BALANCE_SHADE 283 ; 284 whiteBalance = ExynosCamera::WHITE_BALANCE_AUTO; 285 286 autoWhiteBalanceLockSupported = false; 287 autoWhiteBalanceLock = false; 288 289 rotation = 0; 290 minExposure = -2; 291 maxExposure = 2; 292 exposure = 0; 293 294 autoExposureLockSupported = false; 295 autoExposureLock = false; 296 297 fps = 30; 298 focalLengthNum = 343; 299 focalLengthDen = 100; 300 supportVideoStabilization = false; 301 applyVideoStabilization = false; 302 videoStabilization = false; 303 maxNumMeteringAreas = 64; 304 maxNumDetectedFaces = 16; 305 maxNumFocusAreas = 2; 306 maxZoom = ZOOM_LEVEL_MAX; 307 hwZoomSupported = false; 308 zoom = 0; 309 gpsAltitude = 0; 310 gpsLatitude = 0; 311 gpsLongitude = 0; 312 gpsTimestamp = 0; 313 } 314 315 ExynosCameraInfoS5K6A3::ExynosCameraInfoS5K6A3() 316 { 317 previewW = 1280; 318 previewH = 720; 319 previewColorFormat = V4L2_PIX_FMT_YVU420M; 320 videoW = 1280; 321 videoH = 720; 322 prefVideoPreviewW = 640; 323 prefVideoPreviewH = 360; 324 videoColorFormat = V4L2_PIX_FMT_NV12M; 325 pictureW = 1280; 326 pictureH = 720; 327 pictureColorFormat = V4L2_PIX_FMT_YUYV; 328 thumbnailW = 320; 329 thumbnailH = 240; 330 331 antiBandingList = 332 ExynosCamera::ANTIBANDING_OFF 333 | ExynosCamera::ANTIBANDING_50HZ 334 | ExynosCamera::ANTIBANDING_60HZ 335 | ExynosCamera::ANTIBANDING_OFF; 336 antiBanding = ExynosCamera::ANTIBANDING_OFF; 337 338 effectList = 339 ExynosCamera::EFFECT_NONE 340 | ExynosCamera::EFFECT_MONO 341 | ExynosCamera::EFFECT_NEGATIVE 342 //| ExynosCamera::EFFECT_SOLARIZE 343 | ExynosCamera::EFFECT_SEPIA 344 //| ExynosCamera::EFFECT_POSTERIZE 345 //| ExynosCamera::EFFECT_WHITEBOARD 346 //| ExynosCamera::EFFECT_BLACKBOARD 347 //| ExynosCamera::EFFECT_AQUA 348 ; 349 effect = ExynosCamera::EFFECT_NONE; 350 351 flashModeList = 352 ExynosCamera::FLASH_MODE_OFF 353 //| ExynosCamera::FLASH_MODE_AUTO 354 //| ExynosCamera::FLASH_MODE_ON 355 //| ExynosCamera::FLASH_MODE_RED_EYE 356 //| ExynosCamera::FLASH_MODE_TORCH 357 ; 358 flashMode = ExynosCamera::FLASH_MODE_OFF; 359 360 focusModeList = 361 // ExynosCamera::FOCUS_MODE_AUTO 362 //| ExynosCamera::FOCUS_MODE_INFINITY 363 //| ExynosCamera::FOCUS_MODE_MACRO 364 //| 365 ExynosCamera::FOCUS_MODE_FIXED 366 //| ExynosCamera::FOCUS_MODE_EDOF 367 //| ExynosCamera::FOCUS_MODE_CONTINUOUS_VIDEO 368 //| ExynosCamera::FOCUS_MODE_CONTINUOUS_PICTURE 369 //| ExynosCamera::FOCUS_MODE_TOUCH 370 ; 371 focusMode = ExynosCamera::FOCUS_MODE_FIXED; 372 373 sceneModeList = 374 ExynosCamera::SCENE_MODE_AUTO 375 //| ExynosCamera::SCENE_MODE_ACTION 376 | ExynosCamera::SCENE_MODE_PORTRAIT 377 | ExynosCamera::SCENE_MODE_LANDSCAPE 378 | ExynosCamera::SCENE_MODE_NIGHT 379 //| ExynosCamera::SCENE_MODE_NIGHT_PORTRAIT 380 //| ExynosCamera::SCENE_MODE_THEATRE 381 | ExynosCamera::SCENE_MODE_BEACH 382 | ExynosCamera::SCENE_MODE_SNOW 383 | ExynosCamera::SCENE_MODE_SUNSET 384 | ExynosCamera::SCENE_MODE_STEADYPHOTO 385 | ExynosCamera::SCENE_MODE_FIREWORKS 386 | ExynosCamera::SCENE_MODE_SPORTS 387 | ExynosCamera::SCENE_MODE_PARTY 388 | ExynosCamera::SCENE_MODE_CANDLELIGHT; 389 sceneMode = ExynosCamera::SCENE_MODE_AUTO; 390 391 whiteBalanceList = 392 ExynosCamera::WHITE_BALANCE_AUTO 393 | ExynosCamera::WHITE_BALANCE_INCANDESCENT 394 | ExynosCamera::WHITE_BALANCE_FLUORESCENT 395 //| ExynosCamera::WHITE_BALANCE_WARM_FLUORESCENT 396 | ExynosCamera::WHITE_BALANCE_DAYLIGHT 397 | ExynosCamera::WHITE_BALANCE_CLOUDY_DAYLIGHT 398 //| ExynosCamera::WHITE_BALANCE_TWILIGHT 399 //| ExynosCamera::WHITE_BALANCE_SHADE 400 ; 401 whiteBalance = ExynosCamera::WHITE_BALANCE_AUTO; 402 403 autoWhiteBalanceLockSupported = true; 404 autoWhiteBalanceLock = false; 405 406 rotation = 0; 407 minExposure = -2; 408 maxExposure = 2; 409 exposure = 0; 410 411 autoExposureLockSupported = true; 412 autoExposureLock = false; 413 414 fps = 30; 415 focalLengthNum = 9; 416 focalLengthDen = 10; 417 supportVideoStabilization = false; 418 applyVideoStabilization = false; 419 videoStabilization = false; 420 maxNumMeteringAreas = 64; 421 maxNumDetectedFaces = 16; 422 maxNumFocusAreas = 0; 423 maxZoom = ZOOM_LEVEL_MAX; 424 hwZoomSupported = false; 425 zoom = 0; 426 gpsAltitude = 0; 427 gpsLatitude = 0; 428 gpsLongitude = 0; 429 gpsTimestamp = 0; 430 } 431 432 ExynosCameraInfoS5K4E5::ExynosCameraInfoS5K4E5() 433 { 434 previewW = 1920; 435 previewH = 1080; 436 previewColorFormat = V4L2_PIX_FMT_YVU420M; 437 videoW = 1920; 438 videoH = 1080; 439 prefVideoPreviewW = 640; 440 prefVideoPreviewH = 360; 441 videoColorFormat = V4L2_PIX_FMT_NV12M; 442 pictureW = 2560; 443 pictureH = 1920; 444 pictureColorFormat = V4L2_PIX_FMT_YUYV; 445 thumbnailW = 320; 446 thumbnailH = 240; 447 448 antiBandingList = 449 ExynosCamera::ANTIBANDING_OFF 450 | ExynosCamera::ANTIBANDING_50HZ 451 | ExynosCamera::ANTIBANDING_60HZ 452 | ExynosCamera::ANTIBANDING_OFF; 453 antiBanding = ExynosCamera::ANTIBANDING_OFF; 454 455 effectList = 456 ExynosCamera::EFFECT_NONE 457 | ExynosCamera::EFFECT_MONO 458 | ExynosCamera::EFFECT_NEGATIVE 459 //| ExynosCamera::EFFECT_SOLARIZE 460 | ExynosCamera::EFFECT_SEPIA 461 //| ExynosCamera::EFFECT_POSTERIZE 462 //| ExynosCamera::EFFECT_WHITEBOARD 463 //| ExynosCamera::EFFECT_BLACKBOARD 464 //| ExynosCamera::EFFECT_AQUA 465 ; 466 effect = ExynosCamera::EFFECT_NONE; 467 468 flashModeList = 469 ExynosCamera::FLASH_MODE_OFF 470 | ExynosCamera::FLASH_MODE_AUTO 471 | ExynosCamera::FLASH_MODE_ON 472 //| ExynosCamera::FLASH_MODE_RED_EYE 473 | ExynosCamera::FLASH_MODE_TORCH; 474 flashMode = ExynosCamera::FLASH_MODE_OFF; 475 476 focusModeList = 477 ExynosCamera::FOCUS_MODE_AUTO 478 | ExynosCamera::FOCUS_MODE_INFINITY 479 | ExynosCamera::FOCUS_MODE_MACRO 480 //| ExynosCamera::FOCUS_MODE_FIXED 481 //| ExynosCamera::FOCUS_MODE_EDOF 482 | ExynosCamera::FOCUS_MODE_CONTINUOUS_VIDEO 483 // | ExynosCamera::FOCUS_MODE_CONTINUOUS_PICTURE 484 | ExynosCamera::FOCUS_MODE_TOUCH 485 ; 486 focusMode = ExynosCamera::FOCUS_MODE_AUTO; 487 488 sceneModeList = 489 ExynosCamera::SCENE_MODE_AUTO 490 //| ExynosCamera::SCENE_MODE_ACTION 491 | ExynosCamera::SCENE_MODE_PORTRAIT 492 | ExynosCamera::SCENE_MODE_LANDSCAPE 493 | ExynosCamera::SCENE_MODE_NIGHT 494 //| ExynosCamera::SCENE_MODE_NIGHT_PORTRAIT 495 //| ExynosCamera::SCENE_MODE_THEATRE 496 | ExynosCamera::SCENE_MODE_BEACH 497 | ExynosCamera::SCENE_MODE_SNOW 498 | ExynosCamera::SCENE_MODE_SUNSET 499 | ExynosCamera::SCENE_MODE_STEADYPHOTO 500 | ExynosCamera::SCENE_MODE_FIREWORKS 501 | ExynosCamera::SCENE_MODE_SPORTS 502 | ExynosCamera::SCENE_MODE_PARTY 503 | ExynosCamera::SCENE_MODE_CANDLELIGHT; 504 sceneMode = ExynosCamera::SCENE_MODE_AUTO; 505 506 whiteBalanceList = 507 ExynosCamera::WHITE_BALANCE_AUTO 508 | ExynosCamera::WHITE_BALANCE_INCANDESCENT 509 | ExynosCamera::WHITE_BALANCE_FLUORESCENT 510 //| ExynosCamera::WHITE_BALANCE_WARM_FLUORESCENT 511 | ExynosCamera::WHITE_BALANCE_DAYLIGHT 512 | ExynosCamera::WHITE_BALANCE_CLOUDY_DAYLIGHT 513 //| ExynosCamera::WHITE_BALANCE_TWILIGHT 514 //| ExynosCamera::WHITE_BALANCE_SHADE 515 ; 516 whiteBalance = ExynosCamera::WHITE_BALANCE_AUTO; 517 518 autoWhiteBalanceLockSupported = true; 519 autoWhiteBalanceLock = false; 520 521 rotation = 0; 522 minExposure = -2; 523 maxExposure = 2; 524 exposure = 0; 525 526 autoExposureLockSupported = true; 527 autoExposureLock = false; 528 529 fps = 30; 530 focalLengthNum = 9; 531 focalLengthDen = 10; 532 supportVideoStabilization = true; 533 applyVideoStabilization = false; 534 videoStabilization = false; 535 maxNumMeteringAreas = 64; 536 maxNumDetectedFaces = 16; 537 maxNumFocusAreas = 2; 538 maxZoom = ZOOM_LEVEL_MAX; 539 hwZoomSupported = false; 540 zoom = 0; 541 gpsAltitude = 0; 542 gpsLatitude = 0; 543 gpsLongitude = 0; 544 gpsTimestamp = 0; 545 } 546 547 ////////////////////////////////////////////////// 548 549 #define PFX_NODE "/dev/video" 550 551 #define M5MOLS_ENTITY_NAME "M5MOLS 5-001f" 552 #define PFX_SUBDEV_ENTITY_MIPI_CSIS "s5p-mipi-csis" 553 #define PFX_SUBDEV_ENTITY_FLITE "flite-subdev" 554 #define PFX_SUBDEV_ENTITY_GSC_CAP "gsc-cap-subdev" 555 #define PFX_VIDEODEV_ENTITY_FLITE "exynos-fimc-lite" 556 #define PFX_VIDEODEV_ENTITY_GSC_CAP "exynos-gsc" 557 558 #define MEDIA_DEV_INTERNAL_ISP "/dev/media2" 559 #define MEDIA_DEV_EXTERNAL_ISP "/dev/media1" 560 #define ISP_VD_NODE_OFFSET (40) //INTERNAL_ISP 561 #define FLITE_VD_NODE_OFFSET (36) //External ISP 562 563 #define VIDEO_NODE_PREVIEW_ID (3) 564 #define VIDEO_NODE_RECODING_ID (2) 565 #define VIDEO_NODE_SNAPSHOT_ID (1) 566 567 #define ISP_SENSOR_MAX_ENTITIES 1 568 #define ISP_SENSOR_PAD_SOURCE_FRONT 0 569 #define ISP_SENSOR_PADS_NUM 1 570 571 #define ISP_FRONT_MAX_ENTITIES 1 572 #define ISP_FRONT_PAD_SINK 0 573 #define ISP_FRONT_PAD_SOURCE_BACK 1 574 #define ISP_FRONT_PAD_SOURCE_BAYER 2 575 #define ISP_FRONT_PAD_SOURCE_SCALERC 3 576 #define ISP_FRONT_PADS_NUM 4 577 578 #define ISP_BACK_MAX_ENTITIES 1 579 #define ISP_BACK_PAD_SINK 0 580 #define ISP_BACK_PAD_SOURCE_3DNR 1 581 #define ISP_BACK_PAD_SOURCE_SCALERP 2 582 #define ISP_BACK_PADS_NUM 3 583 584 #define ISP_MODULE_NAME "exynos5-fimc-is" 585 #define ISP_SENSOR_ENTITY_NAME "exynos5-fimc-is-sensor" 586 #define ISP_FRONT_ENTITY_NAME "exynos5-fimc-is-front" 587 #define ISP_BACK_ENTITY_NAME "exynos5-fimc-is-back" 588 #define ISP_VIDEO_BAYER_NAME "exynos5-fimc-is-bayer" 589 #define ISP_VIDEO_SCALERC_NAME "exynos5-fimc-is-scalerc" 590 #define ISP_VIDEO_3DNR_NAME "exynos5-fimc-is-3dnr" 591 #define ISP_VIDEO_SCALERP_NAME "exynos5-fimc-is-scalerp" 592 593 #define MIPI_NUM 1 594 #define FLITE_NUM 1 595 #define GSC_NUM 0 596 597 #define PFX_SUBDEV_NODE "/dev/v4l-subdev" 598 599 /* 600 * V 4 L 2 F I M C E X T E N S I O N S 601 * 602 */ 603 #define V4L2_CID_ROTATION (V4L2_CID_PRIVATE_BASE + 0) 604 #define V4L2_CID_PADDR_Y (V4L2_CID_PRIVATE_BASE + 1) 605 #define V4L2_CID_PADDR_CB (V4L2_CID_PRIVATE_BASE + 2) 606 #define V4L2_CID_PADDR_CR (V4L2_CID_PRIVATE_BASE + 3) 607 #define V4L2_CID_PADDR_CBCR (V4L2_CID_PRIVATE_BASE + 4) 608 #define V4L2_CID_STREAM_PAUSE (V4L2_CID_PRIVATE_BASE + 53) 609 610 #define V4L2_CID_CAM_JPEG_MAIN_SIZE (V4L2_CID_PRIVATE_BASE + 32) 611 #define V4L2_CID_CAM_JPEG_MAIN_OFFSET (V4L2_CID_PRIVATE_BASE + 33) 612 #define V4L2_CID_CAM_JPEG_THUMB_SIZE (V4L2_CID_PRIVATE_BASE + 34) 613 #define V4L2_CID_CAM_JPEG_THUMB_OFFSET (V4L2_CID_PRIVATE_BASE + 35) 614 #define V4L2_CID_CAM_JPEG_POSTVIEW_OFFSET (V4L2_CID_PRIVATE_BASE + 36) 615 #define V4L2_CID_CAM_JPEG_QUALITY (V4L2_CID_PRIVATE_BASE + 37) 616 617 #define V4L2_PIX_FMT_YVYU v4l2_fourcc('Y', 'V', 'Y', 'U') 618 619 /* FOURCC for FIMC specific */ 620 #define V4L2_PIX_FMT_VYUY v4l2_fourcc('V', 'Y', 'U', 'Y') 621 #define V4L2_PIX_FMT_NV16 v4l2_fourcc('N', 'V', '1', '6') 622 #define V4L2_PIX_FMT_NV61 v4l2_fourcc('N', 'V', '6', '1') 623 #define V4L2_PIX_FMT_NV12T v4l2_fourcc('T', 'V', '1', '2') 624 625 /////////////////////////////////////////////////// 626 // Google Official API : Camera.Parameters 627 // http://developer.android.com/reference/android/hardware/Camera.Parameters.html 628 /////////////////////////////////////////////////// 629 630 ExynosCamera::ExynosCamera() : 631 m_flagCreate(false), 632 m_cameraId(CAMERA_ID_BACK), 633 m_defaultCameraInfo(NULL), 634 m_curCameraInfo(NULL), 635 m_jpegQuality(100), 636 m_jpegThumbnailQuality(100), 637 m_currentZoom(-1) 638 { 639 memset(&m_sensorDev, 0, sizeof(struct devInfo)); 640 memset(&m_mipiDev, 0, sizeof(struct devInfo)); 641 memset(&m_fliteDev, 0, sizeof(struct devInfo)); 642 memset(&m_gscPreviewDev, 0, sizeof(struct devInfo)); 643 memset(&m_gscVideoDev, 0, sizeof(struct devInfo)); 644 memset(&m_gscPictureDev, 0, sizeof(struct devInfo)); 645 646 m_previewDev = NULL; 647 m_videoDev = NULL; 648 m_pictureDev = NULL; 649 650 m_tryPreviewStop = true; 651 m_tryVideoStop = true; 652 m_tryPictureStop = true; 653 654 m_flagStartFaceDetection = false; 655 m_flagAutoFocusRunning = false; 656 657 m_sensorEntity = NULL; 658 m_mipiEntity = NULL; 659 m_fliteSdEntity = NULL; 660 m_fliteVdEntity = NULL; 661 m_gscSdEntity = NULL; 662 m_gscVdEntity = NULL; 663 m_ispSensorEntity = NULL; 664 m_ispFrontEntity = NULL; 665 m_ispBackEntity = NULL; 666 m_ispScalercEntity = NULL; 667 m_ispScalerpEntity = NULL; 668 m_isp3dnrEntity = NULL; 669 670 671 for (int i = 0; i < VIDEO_MAX_FRAME; i++) { 672 m_validPreviewBuf[i] = false; 673 m_validVideoBuf [i] = false; 674 m_validPictureBuf[i] = false; 675 } 676 677 memset((void *)m_cameraName, 0, 32); 678 679 m_internalISP = true; 680 m_media = NULL; 681 682 memset(&mExifInfo, 0, sizeof(mExifInfo)); 683 } 684 685 ExynosCamera::~ExynosCamera() 686 { 687 if (m_flagCreate == true) 688 destroy(); 689 } 690 691 bool ExynosCamera::create(int cameraId) 692 { 693 int ret = 0; 694 unsigned int i; 695 int devNum; 696 char node[30]; 697 698 struct media_link *links = NULL; 699 700 if (m_flagCreate == true) { 701 ALOGE("ERR(%s):Already created", __func__); 702 return false; 703 } 704 705 m_cameraId = cameraId; 706 707 ExynosBuffer nullBuf; 708 709 for (int i = 0; i < VIDEO_MAX_FRAME; i++) { 710 m_validPreviewBuf[i] = false; 711 m_validVideoBuf [i] = false; 712 m_validPictureBuf[i] = false; 713 714 m_previewBuf[i] = nullBuf; 715 m_videoBuf[i] = nullBuf; 716 m_pictureBuf[i] = nullBuf; 717 } 718 719 if (m_cameraId == CAMERA_ID_BACK) 720 m_internalISP = true; 721 // m_internalISP = false; // external ISP. 722 else 723 m_internalISP = true; 724 725 if (m_internalISP == true) { 726 ////////////////////////////// 727 // internal ISP 728 ////////////////////////////// 729 // media device open 730 m_media = exynos_media_open(MEDIA_DEV_INTERNAL_ISP); 731 if (m_media == NULL) { 732 ALOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno)); 733 goto err; 734 } 735 736 ////////////////// 737 // GET ENTITIES 738 ////////////////// 739 // ISP sensor subdev 740 memset(&node, 0x00, sizeof(node)); 741 strcpy(node, ISP_SENSOR_ENTITY_NAME); 742 m_ispSensorEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 743 744 // ISP front subdev 745 memset(&node, 0x00, sizeof(node)); 746 strcpy(node, ISP_FRONT_ENTITY_NAME); 747 m_ispFrontEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 748 749 // ISP back subdev 750 memset(&node, 0x00, sizeof(node)); 751 strcpy(node, ISP_BACK_ENTITY_NAME); 752 m_ispBackEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 753 754 // ISP ScalerC video node 755 memset(&node, 0x00, sizeof(node)); 756 strcpy(node, ISP_VIDEO_SCALERC_NAME); 757 m_ispScalercEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 758 759 // ISP ScalerP video node 760 memset(&node, 0x00, sizeof(node)); 761 strcpy(node, ISP_VIDEO_SCALERP_NAME); 762 m_ispScalerpEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 763 764 // ISP 3DNR video node 765 memset(&node, 0x00, sizeof(node)); 766 strcpy(node, ISP_VIDEO_3DNR_NAME); 767 m_isp3dnrEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 768 769 ALOGV("DEBUG(%s):m_ispSensorEntity : numlink : %d", __func__, m_ispSensorEntity->num_links); 770 ALOGV("DEBUG(%s):m_ispFrontEntity : numlink : %d", __func__, m_ispFrontEntity->num_links); 771 ALOGV("DEBUG(%s):m_ispBackEntity : numlink : %d", __func__, m_ispBackEntity->num_links); 772 ALOGV("DEBUG(%s):m_ispScalercEntity : numlink : %d", __func__, m_ispScalercEntity->num_links); 773 ALOGV("DEBUG(%s):m_ispScalerpEntity : numlink : %d", __func__, m_ispScalerpEntity->num_links); 774 ALOGV("DEBUG(%s):m_isp3dnrEntity : numlink : %d", __func__, m_isp3dnrEntity->num_links); 775 776 ////////////////// 777 // SETUP LINKS 778 ////////////////// 779 // SENSOR TO FRONT 780 links = m_ispSensorEntity->links; 781 if (links == NULL || 782 links->source->entity != m_ispSensorEntity || 783 links->sink->entity != m_ispFrontEntity) { 784 ALOGE("ERR(%s):Can not make link isp_sensor to isp_front", __func__); 785 goto err; 786 } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 787 ALOGE("ERR(%s):Can not make setup isp_sensor to isp_front", __func__); 788 goto err; 789 } 790 ALOGV("DEBUG(%s):[LINK SUCCESS] Sensor to front", __func__); 791 792 // FRONT TO BACK 793 for (i = 0; i < m_ispFrontEntity->num_links; i++) { 794 links = &m_ispFrontEntity->links[i]; 795 if (links == NULL || 796 links->source->entity != m_ispFrontEntity || 797 links->sink->entity != m_ispBackEntity) { 798 ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_ispFrontEntity : %p", __func__, i, 799 links->source->entity, m_ispFrontEntity); 800 ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_ispBackEntity : %p", __func__, i, 801 links->sink->entity, m_ispBackEntity); 802 continue; 803 } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 804 ALOGE("ERR(%s):Can not make setup isp_front to isp_back", __func__); 805 goto err; 806 } 807 } 808 ALOGV("DEBUG(%s):[LINK SUCCESS] front to back", __func__); 809 810 // BACK TO ScalerP Video 811 for (i = 0; i < m_ispBackEntity->num_links; i++) { 812 links = &m_ispBackEntity->links[i]; 813 if (links == NULL || 814 links->source->entity != m_ispBackEntity || 815 links->sink->entity != m_ispScalerpEntity) { 816 ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_ispBackEntity : %p", __func__, i, 817 links->source->entity, m_ispBackEntity); 818 ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_ispScalerpEntity : %p", __func__, i, 819 links->sink->entity, m_ispScalerpEntity); 820 continue; 821 } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 822 ALOGE("ERR(%s):Can not make setup isp_back to scalerP", __func__); 823 goto err; 824 } 825 } 826 ALOGV("DEBUG(%s):[LINK SUCCESS] back to scalerP", __func__); 827 828 sprintf(node, "%s%d", PFX_NODE, (ISP_VD_NODE_OFFSET + VIDEO_NODE_PREVIEW_ID)); 829 m_gscPreviewDev.fd = exynos_v4l2_open(node, O_RDWR, 0); 830 if (m_gscPreviewDev.fd <= 0) { 831 ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno)); 832 goto err; 833 } 834 m_previewDev = &m_gscPreviewDev; 835 836 sprintf(node, "%s%d", PFX_NODE, (ISP_VD_NODE_OFFSET + VIDEO_NODE_RECODING_ID)); 837 m_gscVideoDev.fd = exynos_v4l2_open(node, O_RDWR, 0); 838 if (m_gscVideoDev.fd <= 0) { 839 ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno)); 840 goto err; 841 } 842 m_videoDev = &m_gscVideoDev; 843 844 sprintf(node, "%s%d", PFX_NODE, (ISP_VD_NODE_OFFSET + VIDEO_NODE_SNAPSHOT_ID)); 845 m_gscPictureDev.fd = exynos_v4l2_open(node, O_RDWR, 0); 846 if (m_gscPictureDev.fd <= 0) { 847 ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno)); 848 goto err; 849 } 850 m_pictureDev = &m_gscPictureDev; 851 852 } else { 853 ////////////////////////////// 854 // external ISP 855 ////////////////////////////// 856 // media device open 857 m_media = exynos_media_open(MEDIA_DEV_EXTERNAL_ISP); 858 if (m_media == NULL) { 859 ALOGE("ERR(%s):Cannot open media device (error : %s)", __func__, strerror(errno)); 860 goto err; 861 } 862 863 ////////////////// 864 // GET ENTITIES 865 ////////////////// 866 // camera subdev 867 strcpy(node, M5MOLS_ENTITY_NAME); 868 ALOGV("DEBUG(%s):node : %s", __func__, node); 869 m_sensorEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 870 ALOGV("DEBUG(%s):m_sensorEntity : 0x%p", __func__, m_sensorEntity); 871 872 // mipi subdev 873 sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_MIPI_CSIS, MIPI_NUM); 874 ALOGV("DEBUG(%s):node : %s", __func__, node); 875 m_mipiEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 876 ALOGV("DEBUG(%s):m_mipiEntity : 0x%p", __func__, m_mipiEntity); 877 878 // fimc-lite subdev 879 sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_FLITE, FLITE_NUM); 880 ALOGV("DEBUG(%s):node : %s", __func__, node); 881 m_fliteSdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 882 ALOGV("DEBUG(%s):m_fliteSdEntity : 0x%p", __func__, m_fliteSdEntity); 883 884 // fimc-lite videodev 885 sprintf(node, "%s.%d", PFX_VIDEODEV_ENTITY_FLITE, FLITE_NUM); 886 ALOGV("DEBUG(%s):node : %s", __func__, node); 887 m_fliteVdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 888 ALOGV("DEBUG(%s):m_fliteVdEntity : 0x%p", __func__, m_fliteVdEntity); 889 890 // gscaler subdev 891 sprintf(node, "%s.%d", PFX_SUBDEV_ENTITY_GSC_CAP, GSC_NUM); 892 ALOGV("DEBUG(%s):node : %s", __func__, node); 893 m_gscSdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 894 ALOGV("DEBUG(%s):m_gscSdEntity : 0x%p", __func__, m_gscSdEntity); 895 896 // gscaler videodev 897 sprintf(node, "%s.%d", PFX_VIDEODEV_ENTITY_GSC_CAP, GSC_NUM); 898 ALOGV("DEBUG(%s):node : %s", __func__, node); 899 m_gscVdEntity = exynos_media_get_entity_by_name(m_media, node, strlen(node)); 900 ALOGV("DEBUG(%s):m_gscVdEntity : 0x%p", __func__, m_gscVdEntity); 901 902 ALOGV("DEBUG(%s):sensor_sd : numlink : %d", __func__, m_sensorEntity->num_links); 903 ALOGV("DEBUG(%s):mipi_sd : numlink : %d", __func__, m_mipiEntity->num_links); 904 ALOGV("DEBUG(%s):flite_sd : numlink : %d", __func__, m_fliteSdEntity->num_links); 905 ALOGV("DEBUG(%s):flite_vd : numlink : %d", __func__, m_fliteVdEntity->num_links); 906 ALOGV("DEBUG(%s):gsc_sd : numlink : %d", __func__, m_gscSdEntity->num_links); 907 ALOGV("DEBUG(%s):gsc_vd : numlink : %d", __func__, m_gscVdEntity->num_links); 908 909 ////////////////// 910 // SETUP LINKS 911 ////////////////// 912 // sensor subdev to mipi subdev 913 links = m_sensorEntity->links; 914 if (links == NULL || 915 links->source->entity != m_sensorEntity || 916 links->sink->entity != m_mipiEntity) { 917 ALOGE("ERR(%s):Cannot make link camera sensor to mipi", __func__); 918 goto err; 919 } 920 921 if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 922 ALOGE("ERR(%s):Cannot make setup camera sensor to mipi", __func__); 923 goto err; 924 } 925 ALOGV("DEBUG(%s):[LINK SUCCESS] sensor subdev to mipi subdev", __func__); 926 927 // mipi subdev to fimc-lite subdev 928 for (i = 0; i < m_mipiEntity->num_links; i++) { 929 links = &m_mipiEntity->links[i]; 930 ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_mipiEntity : %p", __func__, i, 931 links->source->entity, m_mipiEntity); 932 ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_fliteSdEntity : %p", __func__, i, 933 links->sink->entity, m_fliteSdEntity); 934 if (links == NULL || 935 links->source->entity != m_mipiEntity || 936 links->sink->entity != m_fliteSdEntity) { 937 continue; 938 } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 939 ALOGE("ERR(%s):Cannot make setup mipi subdev to fimc-lite subdev", __func__); 940 goto err; 941 } 942 } 943 ALOGV("DEBUG(%s):[LINK SUCCESS] mipi subdev to fimc-lite subdev", __func__); 944 945 // fimc-lite subdev TO fimc-lite video dev 946 for (i = 0; i < m_fliteSdEntity->num_links; i++) { 947 links = &m_fliteSdEntity->links[i]; 948 ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_fliteSdEntity : %p", __func__, i, 949 links->source->entity, m_fliteSdEntity); 950 ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_fliteVdEntity : %p", __func__, i, 951 links->sink->entity, m_fliteVdEntity); 952 if (links == NULL || 953 links->source->entity != m_fliteSdEntity || 954 links->sink->entity != m_fliteVdEntity) { 955 continue; 956 } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 957 ALOGE("ERR(%s):Cannot make setup fimc-lite subdev to fimc-lite video dev", __func__); 958 goto err; 959 } 960 } 961 ALOGV("DEBUG(%s):[LINK SUCCESS] fimc-lite subdev to fimc-lite video dev", __func__); 962 963 // fimc-lite subdev to gscaler subdev 964 for (i = 0; i < m_gscSdEntity->num_links; i++) { 965 links = &m_gscSdEntity->links[i]; 966 ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_fliteSdEntity : %p", __func__, i, 967 links->source->entity, m_fliteSdEntity); 968 ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_gscSdEntity : %p", __func__, i, 969 links->sink->entity, m_gscSdEntity); 970 if (links == NULL || 971 links->source->entity != m_fliteSdEntity || 972 links->sink->entity != m_gscSdEntity) { 973 continue; 974 } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 975 ALOGE("ERR(%s):Cannot make setup fimc-lite subdev to gscaler subdev", __func__); 976 goto err; 977 } 978 } 979 ALOGV("DEBUG(%s):[LINK SUCCESS] fimc-lite subdev to gscaler subdev", __func__); 980 981 // gscaler subdev to gscaler video dev 982 for (i = 0; i < m_gscVdEntity->num_links; i++) { 983 links = &m_gscVdEntity->links[i]; 984 ALOGV("DEBUG(%s):i=%d: links->source->entity : %p, m_gscSdEntity : %p", __func__, i, 985 links->source->entity, m_gscSdEntity); 986 ALOGV("DEBUG(%s):i=%d: links->sink->entity : %p, m_gscVdEntity : %p", __func__, i, 987 links->sink->entity, m_gscVdEntity); 988 if (links == NULL || 989 links->source->entity != m_gscSdEntity || 990 links->sink->entity != m_gscVdEntity) { 991 continue; 992 } else if (exynos_media_setup_link(m_media, links->source, links->sink, MEDIA_LNK_FL_ENABLED) < 0) { 993 ALOGE("ERR(%s):Cannot make setup gscaler subdev to gscaler video dev", __func__); 994 goto err; 995 } 996 } 997 ALOGV("DEBUG(%s):[LINK SUCCESS] gscaler subdev to gscaler video dev", __func__); 998 999 sprintf(node, "%s%d", PFX_NODE, (FLITE_VD_NODE_OFFSET + VIDEO_NODE_PREVIEW_ID)); 1000 m_fliteDev.fd = exynos_v4l2_open(node, O_RDWR, 0); 1001 if (m_fliteDev.fd <= 0) { 1002 ALOGE("ERR(%s):exynos_v4l2_open(%s) fail (error : %s)", __func__, node, strerror(errno)); 1003 goto err; 1004 } 1005 m_previewDev = &m_fliteDev; 1006 m_videoDev = &m_fliteDev; 1007 m_pictureDev = &m_fliteDev; 1008 } 1009 1010 m_previewDev->flagStart = false; 1011 m_videoDev->flagStart = false; 1012 m_pictureDev->flagStart = false; 1013 1014 m_tryPreviewStop = true; 1015 m_tryVideoStop = true; 1016 m_tryPictureStop = true; 1017 1018 m_flagStartFaceDetection = false; 1019 m_flagAutoFocusRunning = false; 1020 1021 if (exynos_v4l2_enuminput(m_previewDev->fd, m_cameraId, m_cameraName) == false) { 1022 ALOGE("ERR(%s):exynos_v4l2_enuminput(%d, %s) fail", __func__, m_cameraId, m_cameraName); 1023 goto err; 1024 } 1025 1026 // HACK 1027 if (m_cameraId == CAMERA_ID_BACK) 1028 strcpy(m_cameraName, "S5K4E5"); 1029 else 1030 strcpy(m_cameraName, "S5K6A3"); 1031 1032 if (exynos_v4l2_s_input(m_previewDev->fd, m_cameraId) < 0) { 1033 ALOGE("ERR(%s):exynos_v4l2_s_input() fail", __func__); 1034 goto err; 1035 } 1036 1037 if (strcmp((const char*)m_cameraName, "S5K4E5") == 0) { 1038 m_defaultCameraInfo = new ExynosCameraInfoS5K4E5; 1039 m_curCameraInfo = new ExynosCameraInfoS5K4E5; 1040 } else if (strcmp((const char*)m_cameraName, "S5K6A3") == 0) { 1041 m_defaultCameraInfo = new ExynosCameraInfoS5K6A3; 1042 m_curCameraInfo = new ExynosCameraInfoS5K6A3; 1043 } else if (strcmp((const char*)m_cameraName, "M5M0") == 0) { 1044 m_defaultCameraInfo = new ExynosCameraInfoM5M0; 1045 m_curCameraInfo = new ExynosCameraInfoM5M0; 1046 } else { 1047 ALOGE("ERR(%s):invalid camera Name (%s) fail", __func__, m_cameraName); 1048 goto err; 1049 } 1050 1051 m_setExifFixedAttribute(); 1052 1053 m_flagCreate = true; 1054 return true; 1055 1056 err: 1057 if (m_defaultCameraInfo) 1058 delete m_defaultCameraInfo; 1059 m_defaultCameraInfo = NULL; 1060 1061 if (m_curCameraInfo) 1062 delete m_curCameraInfo; 1063 m_curCameraInfo = NULL; 1064 1065 if (0 < m_videoDev->fd) 1066 exynos_v4l2_close(m_videoDev->fd); 1067 m_videoDev->fd = 0; 1068 1069 if (0 < m_pictureDev->fd) 1070 exynos_v4l2_close(m_pictureDev->fd); 1071 m_pictureDev->fd = 0; 1072 1073 if (0 < m_previewDev->fd) 1074 exynos_v4l2_close(m_previewDev->fd); 1075 m_previewDev->fd = 0; 1076 1077 if (m_media) 1078 exynos_media_close(m_media); 1079 m_media = NULL; 1080 1081 return false; 1082 } 1083 1084 bool ExynosCamera::destroy(void) 1085 { 1086 if (m_flagCreate == false) { 1087 ALOGE("ERR(%s):Not yet created", __func__); 1088 return false; 1089 } 1090 1091 if (m_pictureDev->flagStart == true) 1092 stopPicture(); 1093 1094 if (m_videoDev->flagStart == true) 1095 stopVideo(); 1096 1097 if (m_previewDev->flagStart == true) 1098 stopPreview(); 1099 1100 if (m_defaultCameraInfo) 1101 delete m_defaultCameraInfo; 1102 m_defaultCameraInfo = NULL; 1103 1104 if (m_curCameraInfo) 1105 delete m_curCameraInfo; 1106 m_curCameraInfo = NULL; 1107 1108 // close m_previewDev->fd after stopVideo() because stopVideo() 1109 // uses m_previewDev->fd to change frame rate 1110 if (0 < m_videoDev->fd) 1111 exynos_v4l2_close(m_videoDev->fd); 1112 m_videoDev->fd = 0; 1113 1114 if (0 < m_pictureDev->fd) 1115 exynos_v4l2_close(m_pictureDev->fd); 1116 m_pictureDev->fd = 0; 1117 1118 if (0 < m_previewDev->fd) 1119 exynos_v4l2_close(m_previewDev->fd); 1120 m_previewDev->fd = 0; 1121 1122 if (m_media) 1123 exynos_media_close(m_media); 1124 m_media = NULL; 1125 1126 m_flagCreate = false; 1127 1128 return true; 1129 } 1130 1131 bool ExynosCamera::flagCreate(void) 1132 { 1133 return m_flagCreate; 1134 } 1135 1136 int ExynosCamera::getCameraId(void) 1137 { 1138 return m_cameraId; 1139 } 1140 1141 char *ExynosCamera::getCameraName(void) 1142 { 1143 return m_cameraName; 1144 } 1145 1146 int ExynosCamera::getPreviewFd(void) 1147 { 1148 return m_previewDev->fd; 1149 } 1150 1151 int ExynosCamera::getPictureFd(void) 1152 { 1153 return m_pictureDev->fd; 1154 } 1155 1156 int ExynosCamera::getVideoFd(void) 1157 { 1158 return m_videoDev->fd; 1159 } 1160 1161 bool ExynosCamera::startPreview(void) 1162 { 1163 if (m_flagCreate == false) { 1164 ALOGE("ERR(%s):Not yet Created", __func__); 1165 return false; 1166 } 1167 1168 if (m_previewDev->flagStart == false) { 1169 if (m_setWidthHeight(PREVIEW_MODE, 1170 m_previewDev->fd, 1171 &m_previewDev->events, 1172 m_curCameraInfo->previewW, 1173 m_curCameraInfo->previewH, 1174 m_curCameraInfo->previewColorFormat, 1175 m_previewBuf, 1176 m_validPreviewBuf) == false) { 1177 ALOGE("ERR(%s):m_setWidthHeight() fail", __func__); 1178 return false; 1179 } 1180 1181 if (setPreviewFrameRate(m_curCameraInfo->fps) == false) 1182 ALOGE("ERR(%s):Fail toggle setPreviewFrameRate(%d)", 1183 __func__, m_curCameraInfo->fps); 1184 1185 if (exynos_v4l2_streamon(m_previewDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) { 1186 ALOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__); 1187 return false; 1188 } 1189 1190 if (m_curCameraInfo->focusMode == FOCUS_MODE_CONTINUOUS_VIDEO 1191 || m_curCameraInfo->focusMode == FOCUS_MODE_CONTINUOUS_PICTURE) { 1192 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_CAF_START_STOP, CAF_START) < 0) { 1193 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 1194 return false; 1195 } 1196 } 1197 1198 m_tryPreviewStop = false; 1199 m_previewDev->flagStart = true; 1200 1201 /* TODO */ 1202 /* DIS is only supported BACK camera(4E5) currently. */ 1203 #ifdef USE_DIS 1204 bool toggle = getVideoStabilization(); 1205 1206 if (setVideoStabilization(toggle) == false) 1207 ALOGE("ERR(%s):setVideoStabilization() fail", __func__); 1208 #endif 1209 1210 #ifdef USE_3DNR 1211 if (m_recordingHint == true && getCameraId() == CAMERA_ID_BACK) { 1212 if (set3DNR(true) == false) 1213 ALOGE("ERR(%s):set3DNR() fail", __func__); 1214 } 1215 #endif 1216 1217 #ifdef USE_ODC 1218 if (setODC(true) == false) 1219 ALOGE("ERR(%s):setODC() fail", __func__); 1220 #endif 1221 } 1222 1223 return true; 1224 } 1225 1226 bool ExynosCamera::stopPreview(void) 1227 { 1228 if (m_flagCreate == false) { 1229 ALOGE("ERR(%s):Not yet Created", __func__); 1230 return false; 1231 } 1232 1233 if (m_previewDev->flagStart == true) { 1234 1235 if (m_curCameraInfo->flashMode == FLASH_MODE_TORCH) 1236 setFlashMode(FLASH_MODE_OFF); 1237 1238 m_tryPreviewStop = true; 1239 1240 // skip stopPreview 1241 if ( (m_previewDev == m_videoDev && m_tryVideoStop == false) 1242 || (m_previewDev == m_pictureDev && m_tryPictureStop == false)) 1243 return true; 1244 1245 /* TODO */ 1246 /* Can not use 3DNR, ODC and DIS function because HW problem at exynos5250 EVT0 */ 1247 #ifdef USE_3DNR 1248 if (set3DNR(false) == false) 1249 ALOGE("ERR(%s):set3DNR() fail", __func__); 1250 #endif 1251 1252 #ifdef USE_ODC 1253 if (setODC(false) == false) 1254 ALOGE("ERR(%s):setODC() fail", __func__); 1255 #endif 1256 1257 if (exynos_v4l2_streamoff(m_previewDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) { 1258 ALOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__); 1259 return false; 1260 } 1261 1262 struct v4l2_requestbuffers req; 1263 req.count = 0; 1264 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1265 req.memory = V4L2_MEMORY_DMABUF; 1266 1267 if (exynos_v4l2_reqbufs(m_previewDev->fd, &req) < 0) { 1268 ALOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__); 1269 return false; 1270 } 1271 1272 m_previewDev->flagStart = false; 1273 1274 m_flagStartFaceDetection = false; 1275 } 1276 1277 return true; 1278 } 1279 1280 bool ExynosCamera::flagStartPreview(void) 1281 { 1282 return m_previewDev->flagStart; 1283 } 1284 1285 int ExynosCamera::getPreviewMaxBuf(void) 1286 { 1287 return VIDEO_MAX_FRAME; 1288 } 1289 1290 bool ExynosCamera::setPreviewBuf(ExynosBuffer *buf) 1291 { 1292 if (m_flagCreate == false) { 1293 ALOGE("ERR(%s):Not yet created fail", __func__); 1294 return false; 1295 } 1296 1297 if (VIDEO_MAX_FRAME <= buf->reserved.p) { 1298 ALOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME); 1299 return false; 1300 } 1301 1302 m_previewBuf[buf->reserved.p] = *buf; 1303 1304 // HACK : Driver not yet support cb,cr of YV12 1305 m_previewBuf[buf->reserved.p].virt.extP[1] = buf->virt.extP[2]; 1306 m_previewBuf[buf->reserved.p].virt.extP[2] = buf->virt.extP[1]; 1307 1308 return true; 1309 } 1310 1311 bool ExynosCamera::getPreviewBuf(ExynosBuffer *buf) 1312 { 1313 if (m_flagCreate == false) { 1314 ALOGE("ERR(%s):Not yet created fail", __func__); 1315 return false; 1316 } 1317 1318 if (m_previewDev->flagStart == false) { 1319 ALOGE("ERR(%s):Not yet preview started fail", __func__); 1320 return false; 1321 } 1322 1323 struct v4l2_buffer v4l2_buf; 1324 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 1325 1326 v4l2_buf.m.planes = planes; 1327 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1328 v4l2_buf.memory = V4L2_MEMORY_DMABUF; 1329 v4l2_buf.length = 0; 1330 1331 for (int i = 0; i < 3; i++) { 1332 if (m_previewBuf[0].size.extS[i] != 0) 1333 v4l2_buf.length++; 1334 } 1335 1336 if (exynos_v4l2_dqbuf(m_previewDev->fd, &v4l2_buf) < 0) { 1337 ALOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__); 1338 return false; 1339 } 1340 1341 if (VIDEO_MAX_FRAME <= v4l2_buf.index) { 1342 ALOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index); 1343 return false; 1344 } 1345 1346 *buf = m_previewBuf[v4l2_buf.index]; 1347 1348 return true; 1349 } 1350 1351 bool ExynosCamera::putPreviewBuf(ExynosBuffer *buf) 1352 { 1353 if (m_flagCreate == false) { 1354 ALOGE("ERR(%s):Not yet created fail", __func__); 1355 return false; 1356 } 1357 1358 if (m_validPreviewBuf[buf->reserved.p] == false) { 1359 ALOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p); 1360 return false; 1361 } 1362 1363 struct v4l2_buffer v4l2_buf; 1364 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 1365 1366 v4l2_buf.m.planes = planes; 1367 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1368 v4l2_buf.memory = V4L2_MEMORY_DMABUF; 1369 v4l2_buf.index = buf->reserved.p; 1370 v4l2_buf.length = 0; 1371 1372 for (int i = 0; i < 3; i++) { 1373 v4l2_buf.m.planes[i].m.fd= m_previewBuf[buf->reserved.p].fd.extFd[i]; 1374 v4l2_buf.m.planes[i].length = m_previewBuf[buf->reserved.p].size.extS[i]; 1375 1376 if (m_previewBuf[buf->reserved.p].size.extS[i] != 0) 1377 v4l2_buf.length++; 1378 } 1379 1380 if (exynos_v4l2_qbuf(m_previewDev->fd, &v4l2_buf) < 0) { 1381 ALOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__); 1382 return false; 1383 } 1384 1385 return true; 1386 } 1387 1388 bool ExynosCamera::setVideoSize(int w, int h) 1389 { 1390 m_curCameraInfo->videoW = w; 1391 m_curCameraInfo->videoH = h; 1392 1393 #ifdef USE_3DNR_DMAOUT 1394 // HACK : Video 3dnr port support resize. So, we must make max size video w, h 1395 m_curCameraInfo->videoW = m_defaultCameraInfo->videoW; 1396 m_curCameraInfo->videoH = m_defaultCameraInfo->videoH; 1397 #endif 1398 return true; 1399 } 1400 1401 bool ExynosCamera::getVideoSize(int *w, int *h) 1402 { 1403 *w = m_curCameraInfo->videoW; 1404 *h = m_curCameraInfo->videoH; 1405 return true; 1406 } 1407 1408 bool ExynosCamera::setVideoFormat(int colorFormat) 1409 { 1410 m_curCameraInfo->videoColorFormat = colorFormat; 1411 return true; 1412 } 1413 1414 int ExynosCamera::getVideoFormat(void) 1415 { 1416 return m_curCameraInfo->videoColorFormat; 1417 } 1418 1419 bool ExynosCamera::startVideo(void) 1420 { 1421 if (m_flagCreate == false) { 1422 ALOGE("ERR(%s):Not yet Created", __func__); 1423 return false; 1424 } 1425 1426 #ifdef USE_3DNR_DMAOUT 1427 if (m_videoDev->flagStart == false) { 1428 if (m_setWidthHeight(VIDEO_MODE, 1429 m_videoDev->fd, 1430 &m_videoDev->events, 1431 m_curCameraInfo->videoW, 1432 m_curCameraInfo->videoH, 1433 m_curCameraInfo->videoColorFormat, 1434 m_videoBuf, 1435 m_validVideoBuf) == false) { 1436 ALOGE("ERR(%s):m_setWidthHeight() fail", __func__); 1437 return false; 1438 } 1439 1440 if (exynos_v4l2_streamon(m_videoDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) { 1441 ALOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__); 1442 return false; 1443 } 1444 1445 m_tryVideoStop = false; 1446 m_videoDev->flagStart = true; 1447 } 1448 #endif 1449 1450 return true; 1451 } 1452 1453 bool ExynosCamera::stopVideo(void) 1454 { 1455 if (m_flagCreate == false) { 1456 ALOGE("ERR(%s):Not yet Created", __func__); 1457 return false; 1458 } 1459 1460 if (m_videoDev->flagStart == true) { 1461 1462 m_tryVideoStop = true; 1463 1464 // skip stopVideo 1465 if ( (m_videoDev == m_previewDev && m_tryPreviewStop == false) 1466 || (m_videoDev == m_pictureDev && m_tryPictureStop == false)) 1467 return true; 1468 1469 if (exynos_v4l2_streamoff(m_videoDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) { 1470 ALOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__); 1471 return false; 1472 } 1473 struct v4l2_requestbuffers req; 1474 req.count = 0; 1475 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1476 req.memory = V4L2_MEMORY_DMABUF; 1477 1478 if (exynos_v4l2_reqbufs(m_videoDev->fd, &req) < 0) { 1479 ALOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__); 1480 return false; 1481 } 1482 1483 m_videoDev->flagStart = false; 1484 } 1485 1486 return true; 1487 } 1488 1489 bool ExynosCamera::flagStartVideo(void) 1490 { 1491 return m_videoDev->flagStart; 1492 } 1493 1494 int ExynosCamera::getVideoMaxBuf(void) 1495 { 1496 return VIDEO_MAX_FRAME; 1497 } 1498 1499 bool ExynosCamera::setVideoBuf(ExynosBuffer *buf) 1500 { 1501 if (m_flagCreate == false) { 1502 ALOGE("ERR(%s):Not yet created fail", __func__); 1503 return false; 1504 } 1505 1506 if (VIDEO_MAX_FRAME <= buf->reserved.p) { 1507 ALOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME); 1508 return false; 1509 } 1510 1511 m_videoBuf[buf->reserved.p] = *buf; 1512 return true; 1513 } 1514 1515 bool ExynosCamera::getVideoBuf(ExynosBuffer *buf) 1516 { 1517 if (m_flagCreate == false) { 1518 ALOGE("ERR(%s):Not yet created fail", __func__); 1519 return false; 1520 } 1521 1522 if (m_videoDev->flagStart == false) { 1523 ALOGE("ERR(%s):Not yet video started fail", __func__); 1524 return false; 1525 } 1526 1527 struct v4l2_buffer v4l2_buf; 1528 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 1529 1530 v4l2_buf.m.planes = planes; 1531 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1532 v4l2_buf.memory = V4L2_MEMORY_DMABUF; 1533 v4l2_buf.length = 0; 1534 1535 for (int i = 0; i < 3; i++) { 1536 if (m_videoBuf[0].size.extS[i] != 0) 1537 v4l2_buf.length++; 1538 } 1539 1540 if (exynos_v4l2_dqbuf(m_videoDev->fd, &v4l2_buf) < 0) { 1541 ALOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__); 1542 return false; 1543 } 1544 1545 if (VIDEO_MAX_FRAME <= v4l2_buf.index) { 1546 ALOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index); 1547 return false; 1548 } 1549 1550 *buf = m_videoBuf[v4l2_buf.index]; 1551 1552 return true; 1553 } 1554 1555 bool ExynosCamera::putVideoBuf(ExynosBuffer *buf) 1556 { 1557 if (m_flagCreate == false) { 1558 ALOGE("ERR(%s):Not yet created fail", __func__); 1559 return false; 1560 } 1561 1562 if (m_videoDev->flagStart == false) { 1563 /* this can happen when recording frames are returned after 1564 * the recording is stopped at the driver level. we don't 1565 * need to return the buffers in this case and we've seen 1566 * cases where fimc could crash if we called qbuf and it 1567 * wasn't expecting it. 1568 */ 1569 ALOGV("DEBUG(%s):recording not in progress, ignoring", __func__); 1570 return true; 1571 } 1572 1573 if (m_validVideoBuf[buf->reserved.p] == false) { 1574 ALOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p); 1575 return false; 1576 } 1577 1578 struct v4l2_buffer v4l2_buf; 1579 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 1580 1581 v4l2_buf.m.planes = planes; 1582 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1583 v4l2_buf.memory = V4L2_MEMORY_DMABUF; 1584 v4l2_buf.index = buf->reserved.p; 1585 v4l2_buf.length = 0; 1586 1587 for (int i = 0; i < 3; i++) { 1588 v4l2_buf.m.planes[i].m.fd = (unsigned long)m_videoBuf[buf->reserved.p].fd.extFd[i]; 1589 v4l2_buf.m.planes[i].length = m_videoBuf[buf->reserved.p].size.extS[i]; 1590 1591 if (m_videoBuf[buf->reserved.p].size.extS[i] != 0) 1592 v4l2_buf.length++; 1593 } 1594 1595 if (exynos_v4l2_qbuf(m_videoDev->fd, &v4l2_buf) < 0) { 1596 ALOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__); 1597 return false; 1598 } 1599 1600 return true; 1601 } 1602 1603 bool ExynosCamera::startPicture(void) 1604 { 1605 if (m_flagCreate == false) { 1606 ALOGE("ERR(%s):Not yet Created", __func__); 1607 return false; 1608 } 1609 1610 if (m_pictureDev->flagStart == false) { 1611 if (m_setWidthHeight(PICTURE_MODE, 1612 m_pictureDev->fd, 1613 &m_pictureDev->events, 1614 m_curCameraInfo->pictureW, 1615 m_curCameraInfo->pictureH, 1616 m_curCameraInfo->pictureColorFormat, 1617 m_pictureBuf, 1618 m_validPictureBuf) == false) { 1619 ALOGE("ERR(%s):m_setWidthHeight() fail", __func__); 1620 return false; 1621 } 1622 1623 if (exynos_v4l2_streamon(m_pictureDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) { 1624 ALOGE("ERR(%s):exynos_v4l2_streamon() fail", __func__); 1625 return false; 1626 } 1627 1628 m_tryPictureStop = false; 1629 m_pictureDev->flagStart = true; 1630 } 1631 1632 return true; 1633 } 1634 1635 bool ExynosCamera::stopPicture(void) 1636 { 1637 if (m_flagCreate == false) { 1638 ALOGE("ERR(%s):Not yet Created", __func__); 1639 return false; 1640 } 1641 1642 if (m_pictureDev->flagStart == true) { 1643 1644 m_tryPictureStop = true; 1645 1646 // skip stopPicture 1647 if ( (m_pictureDev == m_previewDev && m_tryPreviewStop == false) 1648 || (m_pictureDev == m_videoDev && m_tryVideoStop == false)) 1649 return true; 1650 1651 if (exynos_v4l2_streamoff(m_pictureDev->fd, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) < 0) { 1652 ALOGE("ERR(%s):exynos_v4l2_streamoff() fail", __func__); 1653 return false; 1654 } 1655 1656 struct v4l2_requestbuffers req; 1657 req.count = 0; 1658 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1659 req.memory = V4L2_MEMORY_DMABUF; 1660 1661 if (exynos_v4l2_reqbufs(m_pictureDev->fd, &req) < 0) { 1662 ALOGE("ERR(%s):exynos_v4l2_reqbufs() fail", __func__); 1663 return false; 1664 } 1665 1666 m_pictureDev->flagStart = false; 1667 } 1668 1669 return true; 1670 } 1671 1672 bool ExynosCamera::flagStartPicture(void) 1673 { 1674 return m_pictureDev->flagStart; 1675 } 1676 1677 int ExynosCamera::getPictureMaxBuf(void) 1678 { 1679 return VIDEO_MAX_FRAME; 1680 } 1681 1682 bool ExynosCamera::setPictureBuf(ExynosBuffer *buf) 1683 { 1684 if (m_flagCreate == false) { 1685 ALOGE("ERR(%s):Not yet created fail", __func__); 1686 return false; 1687 } 1688 1689 if (VIDEO_MAX_FRAME <= buf->reserved.p) { 1690 ALOGE("ERR(%s):index(%d) must smaller than %d", __func__, buf->reserved.p, VIDEO_MAX_FRAME); 1691 return false; 1692 } 1693 1694 m_pictureBuf[buf->reserved.p] = *buf; 1695 return true; 1696 } 1697 1698 bool ExynosCamera::getPictureBuf(ExynosBuffer *buf) 1699 { 1700 if (m_flagCreate == false) { 1701 ALOGE("ERR(%s):Not yet created fail", __func__); 1702 return false; 1703 } 1704 1705 if (m_pictureDev->flagStart == false) { 1706 ALOGE("ERR(%s):Not yet picture started fail", __func__); 1707 return false; 1708 } 1709 1710 struct v4l2_buffer v4l2_buf; 1711 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 1712 1713 v4l2_buf.m.planes = planes; 1714 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1715 v4l2_buf.memory = V4L2_MEMORY_DMABUF; 1716 v4l2_buf.length = 0; 1717 1718 for (int i = 0; i < 3; i++) { 1719 if (m_pictureBuf[0].size.extS[i] != 0) 1720 v4l2_buf.length++; 1721 } 1722 1723 if (exynos_v4l2_dqbuf(m_pictureDev->fd, &v4l2_buf) < 0) { 1724 ALOGE("ERR(%s):exynos_v4l2_dqbuf() fail", __func__); 1725 return false; 1726 } 1727 1728 if (VIDEO_MAX_FRAME <= v4l2_buf.index) { 1729 ALOGE("ERR(%s):wrong index = %d", __func__, v4l2_buf.index); 1730 return false; 1731 } 1732 1733 *buf = m_pictureBuf[v4l2_buf.index]; 1734 1735 return true; 1736 } 1737 1738 bool ExynosCamera::putPictureBuf(ExynosBuffer *buf) 1739 { 1740 if (m_flagCreate == false) { 1741 ALOGE("ERR(%s):Not yet created fail", __func__); 1742 return false; 1743 } 1744 1745 if (m_pictureDev->flagStart == false) { 1746 ALOGE("ERR(%s):Not yet picture started fail", __func__); 1747 return false; 1748 } 1749 1750 if (m_validPictureBuf[buf->reserved.p] == false) { 1751 ALOGE("ERR(%s):Invalid index(%d)", __func__, buf->reserved.p); 1752 return false; 1753 } 1754 1755 struct v4l2_buffer v4l2_buf; 1756 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 1757 1758 v4l2_buf.m.planes = planes; 1759 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 1760 v4l2_buf.memory = V4L2_MEMORY_DMABUF; 1761 v4l2_buf.index = buf->reserved.p; 1762 v4l2_buf.length = 0; 1763 1764 for (int i = 0; i < 3; i++) { 1765 v4l2_buf.m.planes[i].m.fd = (unsigned long)m_pictureBuf[buf->reserved.p].fd.extFd[i]; 1766 v4l2_buf.m.planes[i].length = m_pictureBuf[buf->reserved.p].size.extS[i]; 1767 1768 if (m_pictureBuf[buf->reserved.p].size.extS[i] != 0) 1769 v4l2_buf.length++; 1770 } 1771 1772 if (exynos_v4l2_qbuf(m_pictureDev->fd, &v4l2_buf) < 0) { 1773 ALOGE("ERR(%s):exynos_v4l2_qbuf() fail", __func__); 1774 return false; 1775 } 1776 1777 return true; 1778 } 1779 1780 bool ExynosCamera::yuv2Jpeg(ExynosBuffer *yuvBuf, 1781 ExynosBuffer *jpegBuf, 1782 ExynosRect *rect) 1783 { 1784 unsigned char *addr; 1785 1786 ExynosJpegEncoderForCamera jpegEnc; 1787 bool ret = false; 1788 1789 unsigned int *yuvSize = yuvBuf->size.extS; 1790 1791 if (jpegEnc.create()) { 1792 ALOGE("ERR(%s):jpegEnc.create() fail", __func__); 1793 goto jpeg_encode_done; 1794 } 1795 1796 if (jpegEnc.setQuality(m_jpegQuality)) { 1797 ALOGE("ERR(%s):jpegEnc.setQuality() fail", __func__); 1798 goto jpeg_encode_done; 1799 } 1800 1801 if (jpegEnc.setSize(rect->w, rect->h)) { 1802 ALOGE("ERR(%s):jpegEnc.setSize() fail", __func__); 1803 goto jpeg_encode_done; 1804 } 1805 1806 if (jpegEnc.setColorFormat(rect->colorFormat)) { 1807 ALOGE("ERR(%s):jpegEnc.setColorFormat() fail", __func__); 1808 goto jpeg_encode_done; 1809 } 1810 1811 if (jpegEnc.setJpegFormat(V4L2_PIX_FMT_JPEG_422)) { 1812 ALOGE("ERR(%s):jpegEnc.setJpegFormat() fail", __func__); 1813 goto jpeg_encode_done; 1814 } 1815 1816 if (m_curCameraInfo->thumbnailW != 0 && m_curCameraInfo->thumbnailH != 0) { 1817 mExifInfo.enableThumb = true; 1818 if (jpegEnc.setThumbnailSize(m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH)) { 1819 ALOGE("ERR(%s):jpegEnc.setThumbnailSize(%d, %d) fail", __func__, m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH); 1820 goto jpeg_encode_done; 1821 } 1822 1823 if (0 < m_jpegThumbnailQuality && m_jpegThumbnailQuality <= 100) { 1824 if (jpegEnc.setThumbnailQuality(m_jpegThumbnailQuality)) { 1825 ALOGE("ERR(%s):jpegEnc.setThumbnailSize(%d, %d) fail", __func__, m_curCameraInfo->thumbnailW, m_curCameraInfo->thumbnailH); 1826 goto jpeg_encode_done; 1827 } 1828 } 1829 1830 m_setExifChangedAttribute(&mExifInfo, rect); 1831 } else { 1832 mExifInfo.enableThumb = false; 1833 } 1834 1835 if (jpegEnc.setInBuf((char **)&(yuvBuf->virt.p), (int *)yuvSize)) { 1836 ALOGE("ERR(%s):jpegEnc.setInBuf() fail", __func__); 1837 goto jpeg_encode_done; 1838 } 1839 1840 if (jpegEnc.setOutBuf(jpegBuf->virt.p, jpegBuf->size.extS[0] + jpegBuf->size.extS[1] + jpegBuf->size.extS[2])) { 1841 ALOGE("ERR(%s):jpegEnc.setOutBuf() fail", __func__); 1842 goto jpeg_encode_done; 1843 } 1844 1845 if (jpegEnc.updateConfig()) { 1846 ALOGE("ERR(%s):jpegEnc.updateConfig() fail", __func__); 1847 goto jpeg_encode_done; 1848 } 1849 1850 if (jpegEnc.encode((int *)&jpegBuf->size.s, &mExifInfo)) { 1851 ALOGE("ERR(%s):jpegEnc.encode() fail", __func__); 1852 goto jpeg_encode_done; 1853 } 1854 1855 ret = true; 1856 1857 jpeg_encode_done: 1858 1859 if (jpegEnc.flagCreate() == true) 1860 jpegEnc.destroy(); 1861 1862 return ret; 1863 } 1864 1865 bool ExynosCamera::autoFocus(void) 1866 { 1867 if (m_previewDev->fd <= 0) { 1868 ALOGE("ERR(%s):Camera was closed", __func__); 1869 return false; 1870 } 1871 1872 if (m_flagAutoFocusRunning == true) { 1873 ALOGD("DEBUG(%s):m_flagAutoFocusRunning == true", __func__); 1874 return true; 1875 } 1876 1877 switch (m_curCameraInfo->focusMode) { 1878 case FOCUS_MODE_AUTO: 1879 case FOCUS_MODE_INFINITY: 1880 case FOCUS_MODE_MACRO: 1881 if (m_touchAFMode == true) { 1882 if (setFocusMode(FOCUS_MODE_TOUCH) == false) { 1883 ALOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__); 1884 return false; 1885 } 1886 } else { 1887 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_ON) < 0) { 1888 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 1889 return false; 1890 } 1891 } 1892 break; 1893 case FOCUS_MODE_CONTINUOUS_VIDEO: 1894 case FOCUS_MODE_CONTINUOUS_PICTURE: 1895 /* Doing nothing. Because we assume that continuous focus mode is 1896 always focused on. */ 1897 break; 1898 case FOCUS_MODE_TOUCH: 1899 if (setFocusMode(FOCUS_MODE_TOUCH) == false) { 1900 ALOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__); 1901 return false; 1902 } 1903 break; 1904 case FOCUS_MODE_FIXED: 1905 break; 1906 case FOCUS_MODE_EDOF: 1907 default: 1908 ALOGE("ERR(%s):Unsupported value(%d)", __func__, m_curCameraInfo->focusMode); 1909 return false; 1910 break; 1911 } 1912 1913 m_flagAutoFocusRunning = true; 1914 1915 return true; 1916 } 1917 1918 bool ExynosCamera::cancelAutoFocus(void) 1919 { 1920 if (m_previewDev->fd <= 0) { 1921 ALOGE("ERR(%s):Camera was closed", __func__); 1922 return false; 1923 } 1924 1925 if (m_flagAutoFocusRunning == false) { 1926 ALOGV("DEBUG(%s):m_flagAutoFocusRunning == false", __func__); 1927 return true; 1928 } 1929 1930 switch (m_curCameraInfo->focusMode) { 1931 case FOCUS_MODE_AUTO: 1932 case FOCUS_MODE_INFINITY: 1933 case FOCUS_MODE_MACRO: 1934 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_AUTO_FOCUS, AUTO_FOCUS_OFF) < 0) { 1935 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 1936 return false; 1937 } 1938 break; 1939 case FOCUS_MODE_CONTINUOUS_VIDEO: 1940 case FOCUS_MODE_CONTINUOUS_PICTURE: 1941 /* Doing nothing. Because we assume that continuous focus mode is 1942 always focused on. */ 1943 break; 1944 case FOCUS_MODE_TOUCH: 1945 if (setFocusMode(FOCUS_MODE_TOUCH) == false) { 1946 ALOGE("ERR(%s): %d: setFocusMode(FOCUS_MODE_TOUCH) fail", __func__, __LINE__); 1947 return false; 1948 } 1949 m_touchAFMode = false; 1950 break; 1951 case FOCUS_MODE_FIXED: 1952 break; 1953 case FOCUS_MODE_EDOF: 1954 default: 1955 ALOGE("ERR(%s):Unsupported value(%d)", __func__, m_curCameraInfo->focusMode); 1956 return false; 1957 break; 1958 } 1959 1960 m_flagAutoFocusRunning = false; 1961 1962 return true; 1963 } 1964 1965 int ExynosCamera::getFucusModeResult(void) 1966 { 1967 int ret = 0; 1968 1969 #define AF_WATING_TIME (100000) // 100msec 1970 #define TOTAL_AF_WATING_TIME (2000000) // 2000msec 1971 1972 for (unsigned int i = 0; i < TOTAL_AF_WATING_TIME; i += AF_WATING_TIME) { 1973 1974 if (m_flagAutoFocusRunning == false) 1975 return -1; 1976 1977 if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_AUTO_FOCUS_RESULT, &ret) < 0) { 1978 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__); 1979 return -1; 1980 } 1981 1982 if (strcmp((const char*)m_cameraName, "S5K4E5") == 0) { 1983 switch(ret) { 1984 case 0x00: // AF Running 1985 ret = 0; 1986 break; 1987 case 0x02: // AF succeed 1988 ret = 1; 1989 break; 1990 case 0x01: 1991 default : // AF fail 1992 ret = -1; 1993 break; 1994 } 1995 1996 if (ret != 0) 1997 break; 1998 1999 } else if (strcmp((const char*)m_cameraName, "M5M0") == 0) { 2000 switch(ret) { 2001 case 0x00: // AF Running 2002 ret = 0; 2003 break; 2004 case 0x01: // AF succeed 2005 ret = 1; 2006 break; 2007 case 0x02: // AF cancel 2008 ret = 0; 2009 break; 2010 default: // AF fail 2011 ret = -1; 2012 break; 2013 } 2014 2015 if (ret != 0) 2016 break; 2017 } else { 2018 ret = -1; 2019 break; 2020 } 2021 2022 usleep(AF_WATING_TIME); 2023 } 2024 2025 return ret; 2026 } 2027 2028 bool ExynosCamera::startFaceDetection(void) 2029 { 2030 if (m_flagStartFaceDetection == true) { 2031 ALOGD("DEBUG(%s):Face detection already started..", __func__); 2032 return true; 2033 } 2034 2035 if (m_previewDev->flagStart == true) { 2036 //if (this->setFocusMode(FOCUS_MODE_AUTO) == false) 2037 // ALOGE("ERR(%s):Fail setFocusMode", __func__); 2038 2039 if (m_internalISP == true) { 2040 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_FD_SET_MAX_FACE_NUMBER, m_defaultCameraInfo->maxNumDetectedFaces) < 0) { 2041 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2042 return false; 2043 } 2044 2045 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_START) < 0) { 2046 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2047 return false; 2048 } 2049 } else { 2050 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FACE_DETECTION, FACE_DETECTION_ON) < 0) { 2051 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2052 return false; 2053 } 2054 } 2055 m_flagStartFaceDetection = true; 2056 } 2057 return true; 2058 } 2059 2060 bool ExynosCamera::stopFaceDetection(void) 2061 { 2062 if (m_flagStartFaceDetection == false) { 2063 ALOGD("DEBUG(%s):Face detection already stopped..", __func__); 2064 return true; 2065 } 2066 2067 if (m_previewDev->flagStart == true) { 2068 if (m_internalISP == true) { 2069 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CMD_FD, IS_FD_COMMAND_STOP) < 0) { 2070 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2071 return false; 2072 } 2073 } else { 2074 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FACE_DETECTION, FACE_DETECTION_OFF) < 0) { 2075 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2076 return false; 2077 } 2078 } 2079 m_flagStartFaceDetection = false; 2080 } 2081 return true; 2082 } 2083 2084 bool ExynosCamera::flagStartFaceDetection(void) 2085 { 2086 return m_flagStartFaceDetection; 2087 } 2088 2089 bool ExynosCamera::setFaceDetectLock(bool toggle) 2090 { 2091 int lock = (toggle == true) ? 1 : 0; 2092 2093 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FACEDETECT_LOCKUNLOCK, lock) < 0) { 2094 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2095 return false; 2096 } 2097 return true; 2098 } 2099 2100 bool ExynosCamera::startSmoothZoom(int value) 2101 { 2102 if (m_defaultCameraInfo->hwZoomSupported == false) { 2103 ALOGE("ERR(%s):m_defaultCameraInfo->hwZoomSupported == false", __func__); 2104 return false; 2105 } 2106 2107 return this->setZoom(value); 2108 } 2109 2110 bool ExynosCamera::stopSmoothZoom(void) 2111 { 2112 // TODO 2113 return true; 2114 } 2115 2116 int ExynosCamera::getAntibanding(void) 2117 { 2118 return m_curCameraInfo->antiBanding; 2119 } 2120 2121 bool ExynosCamera::getAutoExposureLock(void) 2122 { 2123 return m_curCameraInfo->autoExposureLock; 2124 } 2125 2126 bool ExynosCamera::getAutoWhiteBalanceLock(void) 2127 { 2128 return m_curCameraInfo->autoWhiteBalanceLock; 2129 } 2130 2131 int ExynosCamera::getColorEffect(void) 2132 { 2133 return m_curCameraInfo->effect; 2134 } 2135 2136 int ExynosCamera::getDetectedFacesAreas(int num, 2137 int *id, 2138 int *score, 2139 ExynosRect *face, 2140 ExynosRect *leftEye, 2141 ExynosRect *rightEye, 2142 ExynosRect *mouth) 2143 { 2144 if (m_defaultCameraInfo->maxNumDetectedFaces == 0) { 2145 ALOGE("ERR(%s):maxNumDetectedFaces == 0 fail", __func__); 2146 return -1; 2147 } 2148 2149 if (m_flagStartFaceDetection == false) { 2150 ALOGD("DEBUG(%s):m_flagStartFaceDetection == false", __func__); 2151 return 0; 2152 } 2153 2154 if (m_defaultCameraInfo->maxNumDetectedFaces < num) 2155 num = m_defaultCameraInfo->maxNumDetectedFaces; 2156 2157 // width : 0 ~ previewW 2158 // height : 0 ~ previewH 2159 // if eye, mouth is not detectable : -1, -1 2160 ExynosRect2 *face2 = new ExynosRect2[num]; 2161 ExynosRect2 *leftEye2 = new ExynosRect2[num]; 2162 ExynosRect2 *rightEye2 = new ExynosRect2[num]; 2163 ExynosRect2 *mouth2 = new ExynosRect2[num]; 2164 2165 num = getDetectedFacesAreas(num, id, score, face2, leftEye2, rightEye2, mouth2); 2166 2167 for (int i = 0; i < num; i++) { 2168 2169 m_secRect22SecRect(&face2[i], &face[i]); 2170 face[i].fullW = m_curCameraInfo->previewW; 2171 face[i].fullH = m_curCameraInfo->previewH; 2172 2173 m_secRect22SecRect(&leftEye2[i], &leftEye[i]); 2174 leftEye[i].fullW = m_curCameraInfo->previewW; 2175 leftEye[i].fullH = m_curCameraInfo->previewH; 2176 2177 m_secRect22SecRect(&rightEye2[i], &rightEye[i]); 2178 rightEye[i].fullW = m_curCameraInfo->previewW; 2179 rightEye[i].fullH = m_curCameraInfo->previewH; 2180 2181 m_secRect22SecRect(&mouth2[i], &mouth[i]); 2182 mouth[i].fullW = m_curCameraInfo->previewW; 2183 mouth[i].fullH = m_curCameraInfo->previewH; 2184 } 2185 2186 delete [] face2; 2187 delete [] leftEye2; 2188 delete [] rightEye2; 2189 delete [] mouth2; 2190 2191 return num; 2192 } 2193 2194 int ExynosCamera::getDetectedFacesAreas(int num, 2195 int *id, 2196 int *score, 2197 ExynosRect2 *face, 2198 ExynosRect2 *leftEye, 2199 ExynosRect2 *rightEye, 2200 ExynosRect2 *mouth) 2201 { 2202 if (m_defaultCameraInfo->maxNumDetectedFaces == 0) { 2203 ALOGE("ERR(%s):maxNumDetectedFaces == 0 fail", __func__); 2204 return -1; 2205 } 2206 2207 if (m_flagStartFaceDetection == false) { 2208 ALOGD("DEBUG(%s):m_flagStartFaceDetection == false", __func__); 2209 return 0; 2210 } 2211 2212 int i = 0; 2213 2214 if (m_defaultCameraInfo->maxNumDetectedFaces < num) 2215 num = m_defaultCameraInfo->maxNumDetectedFaces; 2216 2217 const unsigned int numOfFDEntity = 1 + ((V4L2_CID_IS_FD_GET_NEXT - V4L2_CID_IS_FD_GET_FACE_FRAME_NUMBER) * num); 2218 2219 // width : 0 ~ previewW 2220 // height : 0 ~ previewH 2221 // if eye, mouth is not detectable : -1, -1 2222 struct v4l2_ext_controls fd_ctrls; 2223 struct v4l2_ext_control *fd_ctrl = new struct v4l2_ext_control[numOfFDEntity]; 2224 struct v4l2_ext_control *cur_ctrl; 2225 2226 cur_ctrl = &fd_ctrl[0]; 2227 cur_ctrl->id = V4L2_CID_IS_FD_GET_FACE_COUNT; 2228 cur_ctrl++; 2229 2230 for (i = 0; i < num; i++) { 2231 cur_ctrl->id = V4L2_CID_IS_FD_GET_FACE_FRAME_NUMBER; 2232 cur_ctrl++; 2233 cur_ctrl->id = V4L2_CID_IS_FD_GET_FACE_CONFIDENCE; 2234 cur_ctrl++; 2235 cur_ctrl->id = V4L2_CID_IS_FD_GET_FACE_TOPLEFT_X; 2236 cur_ctrl++; 2237 cur_ctrl->id = V4L2_CID_IS_FD_GET_FACE_TOPLEFT_Y; 2238 cur_ctrl++; 2239 cur_ctrl->id = V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_X; 2240 cur_ctrl++; 2241 cur_ctrl->id = V4L2_CID_IS_FD_GET_FACE_BOTTOMRIGHT_Y; 2242 cur_ctrl++; 2243 cur_ctrl->id = V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_X; 2244 cur_ctrl++; 2245 cur_ctrl->id = V4L2_CID_IS_FD_GET_LEFT_EYE_TOPLEFT_Y; 2246 cur_ctrl++; 2247 cur_ctrl->id = V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_X; 2248 cur_ctrl++; 2249 cur_ctrl->id = V4L2_CID_IS_FD_GET_LEFT_EYE_BOTTOMRIGHT_Y; 2250 cur_ctrl++; 2251 cur_ctrl->id = V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_X; 2252 cur_ctrl++; 2253 cur_ctrl->id = V4L2_CID_IS_FD_GET_RIGHT_EYE_TOPLEFT_Y; 2254 cur_ctrl++; 2255 cur_ctrl->id = V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_X; 2256 cur_ctrl++; 2257 cur_ctrl->id = V4L2_CID_IS_FD_GET_RIGHT_EYE_BOTTOMRIGHT_Y; 2258 cur_ctrl++; 2259 cur_ctrl->id = V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_X; 2260 cur_ctrl++; 2261 cur_ctrl->id = V4L2_CID_IS_FD_GET_MOUTH_TOPLEFT_Y; 2262 cur_ctrl++; 2263 cur_ctrl->id = V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_X; 2264 cur_ctrl++; 2265 cur_ctrl->id = V4L2_CID_IS_FD_GET_MOUTH_BOTTOMRIGHT_Y; 2266 cur_ctrl++; 2267 cur_ctrl->id = V4L2_CID_IS_FD_GET_NEXT; 2268 cur_ctrl++; 2269 } 2270 2271 fd_ctrls.ctrl_class = V4L2_CTRL_CLASS_CAMERA; 2272 fd_ctrls.count = i + 1; 2273 fd_ctrls.controls = fd_ctrl; 2274 2275 if (exynos_v4l2_g_ext_ctrl(m_previewDev->fd, &fd_ctrls) < 0) { 2276 ALOGE("ERR(%s):exynos_v4l2_g_ext_ctrl() fail", __func__); 2277 num = -1; 2278 goto done; 2279 } 2280 2281 cur_ctrl = &fd_ctrl[0]; 2282 num = cur_ctrl->value; 2283 cur_ctrl++; 2284 2285 for (i = 0; i < num; i++) { 2286 id[i] = cur_ctrl->value; 2287 cur_ctrl++; 2288 score[i] = cur_ctrl->value; 2289 cur_ctrl++; 2290 2291 face[i].x1 = cur_ctrl->value; 2292 cur_ctrl++; 2293 face[i].y1 = cur_ctrl->value; 2294 cur_ctrl++; 2295 face[i].x2 = cur_ctrl->value; 2296 cur_ctrl++; 2297 face[i].y2 = cur_ctrl->value; 2298 cur_ctrl++; 2299 2300 leftEye[i].x1 = cur_ctrl->value; 2301 cur_ctrl++; 2302 leftEye[i].y1 = cur_ctrl->value; 2303 cur_ctrl++; 2304 leftEye[i].x2 = cur_ctrl->value; 2305 cur_ctrl++; 2306 leftEye[i].y2 = cur_ctrl->value; 2307 cur_ctrl++; 2308 2309 rightEye[i].x1 = cur_ctrl->value; 2310 cur_ctrl++; 2311 rightEye[i].y1 = cur_ctrl->value; 2312 cur_ctrl++; 2313 rightEye[i].x2 = cur_ctrl->value; 2314 cur_ctrl++; 2315 rightEye[i].y2 = cur_ctrl->value; 2316 cur_ctrl++; 2317 2318 mouth[i].x1 = cur_ctrl->value; 2319 cur_ctrl++; 2320 mouth[i].y1 = cur_ctrl->value; 2321 cur_ctrl++; 2322 mouth[i].x2 = cur_ctrl->value; 2323 cur_ctrl++; 2324 mouth[i].y2 = cur_ctrl->value; 2325 cur_ctrl++; 2326 } 2327 2328 done: 2329 delete [] fd_ctrl; 2330 2331 return num; 2332 } 2333 2334 int ExynosCamera::getExposureCompensation(void) 2335 { 2336 return m_curCameraInfo->exposure; 2337 } 2338 2339 float ExynosCamera::getExposureCompensationStep(void) 2340 { 2341 // CameraParameters.h 2342 // The exposure compensation step. Exposure compensation index multiply by 2343 // step eqals to EV. Ex: if exposure compensation index is 6 and step is 2344 // 0.3333, EV is -2. 2345 // Example value: "0.333333333" or "0.5". Read only. 2346 // -> But, this formula doesn't works in apps. 2347 return 1.0f; 2348 } 2349 2350 int ExynosCamera::getFlashMode(void) 2351 { 2352 return m_curCameraInfo->flashMode; 2353 } 2354 2355 bool ExynosCamera::getFocalLength(int *num, int *den) 2356 { 2357 *num = m_defaultCameraInfo->focalLengthNum; 2358 *num = m_defaultCameraInfo->focalLengthDen; 2359 return true; 2360 } 2361 2362 int ExynosCamera::getFocusAreas(ExynosRect *rects) 2363 { 2364 // TODO 2365 return 0; 2366 } 2367 2368 int ExynosCamera::getFocusDistances(float *output) 2369 { 2370 // TODO 2371 return 0; 2372 } 2373 2374 int ExynosCamera::getFocusMode(void) 2375 { 2376 return m_curCameraInfo->focusMode; 2377 } 2378 2379 float ExynosCamera::getHorizontalViewAngle(void) 2380 { 2381 //TODO 2382 return 51.2f; 2383 } 2384 2385 int ExynosCamera::getJpegQuality(void) 2386 { 2387 return m_jpegQuality; 2388 } 2389 2390 int ExynosCamera::getJpegThumbnailQuality(void) 2391 { 2392 return m_jpegThumbnailQuality; 2393 } 2394 2395 bool ExynosCamera::getJpegThumbnailSize(int *w, int *h) 2396 { 2397 *w = m_curCameraInfo->thumbnailW; 2398 *h = m_curCameraInfo->thumbnailH; 2399 return true; 2400 } 2401 2402 int ExynosCamera::getMaxExposureCompensation(void) 2403 { 2404 return m_defaultCameraInfo->maxExposure; 2405 } 2406 2407 int ExynosCamera::getMaxNumDetectedFaces(void) 2408 { 2409 return m_defaultCameraInfo->maxNumDetectedFaces; 2410 } 2411 2412 int ExynosCamera::getMaxNumFocusAreas(void) 2413 { 2414 return m_defaultCameraInfo->maxNumFocusAreas; 2415 } 2416 2417 int ExynosCamera::getMaxNumMeteringAreas(void) 2418 { 2419 return m_defaultCameraInfo->maxNumMeteringAreas; 2420 } 2421 2422 int ExynosCamera::getMaxZoom(void) 2423 { 2424 return m_defaultCameraInfo->maxZoom; 2425 } 2426 2427 int ExynosCamera::getMeteringAreas(ExynosRect *rects) 2428 { 2429 // TODO 2430 return 0; 2431 } 2432 2433 int ExynosCamera::getMinExposureCompensation(void) 2434 { 2435 return m_defaultCameraInfo->minExposure; 2436 } 2437 2438 int ExynosCamera::getPictureFormat(void) 2439 { 2440 return m_curCameraInfo->pictureColorFormat; 2441 } 2442 2443 bool ExynosCamera::getPictureSize(int *w, int *h) 2444 { 2445 *w = m_curCameraInfo->pictureW; 2446 *h = m_curCameraInfo->pictureH; 2447 return true; 2448 } 2449 2450 int ExynosCamera::getPreviewFormat(void) 2451 { 2452 return m_curCameraInfo->previewColorFormat; 2453 } 2454 2455 bool ExynosCamera::getPreviewFpsRange(int *min, int *max) 2456 { 2457 *min = 1; 2458 *max = m_defaultCameraInfo->fps; 2459 return true; 2460 } 2461 2462 int ExynosCamera::getPreviewFrameRate(void) 2463 { 2464 return m_curCameraInfo->fps; 2465 } 2466 2467 bool ExynosCamera::getPreviewSize(int *w, int *h) 2468 { 2469 *w = m_curCameraInfo->previewW; 2470 *h = m_curCameraInfo->previewH; 2471 return true; 2472 } 2473 2474 int ExynosCamera::getSceneMode(void) 2475 { 2476 return m_curCameraInfo->sceneMode; 2477 } 2478 2479 int ExynosCamera::getSupportedAntibanding(void) 2480 { 2481 return m_defaultCameraInfo->antiBandingList; 2482 } 2483 2484 int ExynosCamera::getSupportedColorEffects(void) 2485 { 2486 return m_defaultCameraInfo->effectList; 2487 } 2488 2489 int ExynosCamera::getSupportedFlashModes(void) 2490 { 2491 return m_defaultCameraInfo->flashModeList; 2492 } 2493 2494 int ExynosCamera::getSupportedFocusModes(void) 2495 { 2496 return m_defaultCameraInfo->focusModeList; 2497 } 2498 2499 bool ExynosCamera::getSupportedJpegThumbnailSizes(int *w, int *h) 2500 { 2501 *w = m_defaultCameraInfo->thumbnailW; 2502 *h = m_defaultCameraInfo->thumbnailH; 2503 return true; 2504 } 2505 2506 bool ExynosCamera::getSupportedPictureSizes(int *w, int *h) 2507 { 2508 *w = m_defaultCameraInfo->pictureW; 2509 *h = m_defaultCameraInfo->pictureH; 2510 return true; 2511 } 2512 2513 bool ExynosCamera::getSupportedPreviewSizes(int *w, int *h) 2514 { 2515 *w = m_defaultCameraInfo->previewW; 2516 *h = m_defaultCameraInfo->previewH; 2517 return true; 2518 } 2519 2520 int ExynosCamera::getSupportedSceneModes(void) 2521 { 2522 return m_defaultCameraInfo->sceneModeList; 2523 } 2524 2525 bool ExynosCamera::getSupportedVideoSizes(int *w, int *h) 2526 { 2527 *w = m_defaultCameraInfo->videoW; 2528 *h = m_defaultCameraInfo->videoH; 2529 return true; 2530 } 2531 2532 bool ExynosCamera::getPreferredPreivewSizeForVideo(int *w, int *h) 2533 { 2534 *w = m_defaultCameraInfo->prefVideoPreviewW; 2535 *h = m_defaultCameraInfo->prefVideoPreviewH; 2536 return true; 2537 } 2538 2539 int ExynosCamera::getSupportedWhiteBalance(void) 2540 { 2541 return m_defaultCameraInfo->whiteBalanceList; 2542 } 2543 2544 float ExynosCamera::getVerticalViewAngle(void) 2545 { 2546 // TODO 2547 return 39.4f; 2548 } 2549 2550 bool ExynosCamera::getVideoStabilization(void) 2551 { 2552 return m_curCameraInfo->videoStabilization; 2553 } 2554 2555 int ExynosCamera::getWhiteBalance(void) 2556 { 2557 return m_curCameraInfo->whiteBalance; 2558 } 2559 2560 int ExynosCamera::getZoom(void) 2561 { 2562 return m_curCameraInfo->zoom; 2563 } 2564 2565 int ExynosCamera::getMaxZoomRatio(void) 2566 { 2567 return 400; 2568 } 2569 2570 bool ExynosCamera::isAutoExposureLockSupported(void) 2571 { 2572 return m_defaultCameraInfo->autoExposureLockSupported; 2573 } 2574 2575 bool ExynosCamera::isAutoWhiteBalanceLockSupported(void) 2576 { 2577 return m_defaultCameraInfo->autoWhiteBalanceLockSupported; 2578 } 2579 2580 bool ExynosCamera::isSmoothZoomSupported(void) 2581 { 2582 if (m_defaultCameraInfo->hwZoomSupported == true) 2583 return true; 2584 else 2585 return false; 2586 } 2587 2588 bool ExynosCamera::isVideoSnapshotSupported(void) 2589 { 2590 return true; 2591 } 2592 2593 bool ExynosCamera::isVideoStabilizationSupported(void) 2594 { 2595 return m_defaultCameraInfo->supportVideoStabilization; 2596 } 2597 2598 bool ExynosCamera::isZoomSupported(void) 2599 { 2600 return true; 2601 } 2602 2603 bool ExynosCamera::setAntibanding(int value) 2604 { 2605 int internalValue = -1; 2606 2607 switch (value) { 2608 case ANTIBANDING_AUTO: 2609 internalValue = ::ANTI_BANDING_AUTO; 2610 break; 2611 case ANTIBANDING_50HZ: 2612 internalValue = ::ANTI_BANDING_50HZ; 2613 break; 2614 case ANTIBANDING_60HZ: 2615 internalValue = ::ANTI_BANDING_60HZ; 2616 break; 2617 case ANTIBANDING_OFF: 2618 internalValue = ::ANTI_BANDING_OFF; 2619 break; 2620 default: 2621 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 2622 return false; 2623 break; 2624 } 2625 2626 if (m_internalISP == true) { 2627 if (internalValue < ::IS_AFC_DISABLE || ::IS_AFC_MAX <= internalValue) { 2628 ALOGE("ERR(%s):Invalid value (%d)", __func__, value); 2629 return false; 2630 } 2631 } else { 2632 if (internalValue < ::ANTI_BANDING_AUTO || ::ANTI_BANDING_OFF < internalValue) { 2633 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 2634 return false; 2635 } 2636 } 2637 2638 if (m_curCameraInfo->antiBanding != value) { 2639 m_curCameraInfo->antiBanding = value; 2640 if (m_flagCreate == true) { 2641 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_AFC_MODE, internalValue) < 0) { 2642 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2643 return false; 2644 } 2645 } 2646 } 2647 2648 return true; 2649 } 2650 2651 bool ExynosCamera::setAutoExposureLock(bool toggle) 2652 { 2653 int internalValue = -1; 2654 2655 if (m_curCameraInfo->autoExposureLock == toggle) 2656 return true; 2657 2658 m_curCameraInfo->autoExposureLock = toggle; 2659 2660 if (m_curCameraInfo->autoExposureLock == true && m_curCameraInfo->autoWhiteBalanceLock == true) 2661 internalValue = AE_LOCK_AWB_LOCK; 2662 else if (m_curCameraInfo->autoExposureLock == true && m_curCameraInfo->autoWhiteBalanceLock == false) 2663 internalValue = AE_LOCK_AWB_UNLOCK; 2664 else if (m_curCameraInfo->autoExposureLock == false && m_curCameraInfo->autoWhiteBalanceLock == true) 2665 internalValue = AE_UNLOCK_AWB_LOCK; 2666 else // if (m_curCameraInfo->autoExposureLock == false && m_curCameraInfo->autoWhiteBalanceLock == false) 2667 internalValue = AE_UNLOCK_AWB_UNLOCK; 2668 2669 if (m_flagCreate == true) { 2670 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, internalValue) < 0) { 2671 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2672 return false; 2673 } 2674 } 2675 return true; 2676 } 2677 2678 bool ExynosCamera::setAutoWhiteBalanceLock(bool toggle) 2679 { 2680 int internalValue = -1; 2681 2682 if (m_curCameraInfo->autoWhiteBalanceLock == toggle) 2683 return true; 2684 2685 m_curCameraInfo->autoWhiteBalanceLock = toggle; 2686 2687 if (m_curCameraInfo->autoExposureLock == true && m_curCameraInfo->autoWhiteBalanceLock == true) 2688 internalValue = AE_LOCK_AWB_LOCK; 2689 else if (m_curCameraInfo->autoExposureLock == true && m_curCameraInfo->autoWhiteBalanceLock == false) 2690 internalValue = AE_LOCK_AWB_UNLOCK; 2691 else if (m_curCameraInfo->autoExposureLock == false && m_curCameraInfo->autoWhiteBalanceLock == true) 2692 internalValue = AE_UNLOCK_AWB_LOCK; 2693 else // if (m_curCameraInfo->autoExposureLock == false && m_curCameraInfo->autoWhiteBalanceLock == false) 2694 internalValue = AE_UNLOCK_AWB_UNLOCK; 2695 2696 if (m_flagCreate == true) { 2697 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_AEAWB_LOCK_UNLOCK, internalValue) < 0) { 2698 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2699 return false; 2700 } 2701 } 2702 return true; 2703 } 2704 2705 bool ExynosCamera::setColorEffect(int value) 2706 { 2707 int internalValue = -1; 2708 2709 switch (value) { 2710 case EFFECT_NONE: 2711 if (m_internalISP == true) 2712 internalValue = ::IS_IMAGE_EFFECT_DISABLE; 2713 else 2714 internalValue = ::IMAGE_EFFECT_NONE; 2715 break; 2716 case EFFECT_MONO: 2717 if (m_internalISP == true) 2718 internalValue = ::IS_IMAGE_EFFECT_MONOCHROME; 2719 else 2720 internalValue = ::IMAGE_EFFECT_BNW; 2721 break; 2722 case EFFECT_NEGATIVE: 2723 internalValue = IS_IMAGE_EFFECT_NEGATIVE_MONO; 2724 break; 2725 case EFFECT_SEPIA: 2726 if (m_internalISP == true) 2727 internalValue = ::IS_IMAGE_EFFECT_SEPIA; 2728 else 2729 internalValue = ::IMAGE_EFFECT_SEPIA; 2730 break; 2731 case EFFECT_AQUA: 2732 case EFFECT_SOLARIZE: 2733 case EFFECT_POSTERIZE: 2734 case EFFECT_WHITEBOARD: 2735 case EFFECT_BLACKBOARD: 2736 default: 2737 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 2738 return false; 2739 break; 2740 } 2741 2742 if (m_internalISP == true) { 2743 if (internalValue < ::IS_IMAGE_EFFECT_DISABLE || ::IS_IMAGE_EFFECT_MAX <= internalValue) { 2744 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 2745 return false; 2746 } 2747 } else { 2748 if (internalValue <= ::IMAGE_EFFECT_BASE || ::IMAGE_EFFECT_MAX <= internalValue) { 2749 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 2750 return false; 2751 } 2752 } 2753 2754 if (m_curCameraInfo->effect != value) { 2755 m_curCameraInfo->effect = value; 2756 if (m_flagCreate == true) { 2757 if (m_internalISP == true) { 2758 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_IMAGE_EFFECT, internalValue) < 0) { 2759 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2760 return false; 2761 } 2762 } else { 2763 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_EFFECT, internalValue) < 0) { 2764 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2765 return false; 2766 } 2767 } 2768 } 2769 } 2770 2771 return true; 2772 } 2773 2774 bool ExynosCamera::setExposureCompensation(int value) 2775 { 2776 int internalValue = value; 2777 2778 if (m_internalISP == true) { 2779 internalValue += IS_EXPOSURE_DEFAULT; 2780 if (internalValue < IS_EXPOSURE_MINUS_2 || IS_EXPOSURE_PLUS_2 < internalValue) { 2781 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 2782 return false; 2783 } 2784 } else { 2785 internalValue += EV_DEFAULT; 2786 if (internalValue < EV_MINUS_4 || EV_PLUS_4 < internalValue) { 2787 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 2788 return false; 2789 } 2790 } 2791 2792 if (m_curCameraInfo->exposure != value) { 2793 m_curCameraInfo->exposure = value; 2794 if (m_flagCreate == true) { 2795 if (m_internalISP == true) { 2796 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXPOSURE, internalValue) < 0) { 2797 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2798 return false; 2799 } 2800 } else { 2801 if (this->setBrightness(value) == false) { 2802 ALOGE("ERR(%s):setBrightness() fail", __func__); 2803 return false; 2804 } 2805 } 2806 } 2807 } 2808 2809 return true; 2810 } 2811 2812 bool ExynosCamera::setFlashMode(int value) 2813 { 2814 int internalValue = -1; 2815 2816 switch (value) { 2817 case FLASH_MODE_OFF: 2818 internalValue = ::FLASH_MODE_OFF; 2819 break; 2820 case FLASH_MODE_AUTO: 2821 internalValue = ::FLASH_MODE_AUTO; 2822 break; 2823 case FLASH_MODE_ON: 2824 internalValue = ::FLASH_MODE_ON; 2825 break; 2826 case FLASH_MODE_TORCH: 2827 internalValue = ::FLASH_MODE_TORCH; 2828 break; 2829 case FLASH_MODE_RED_EYE: 2830 default: 2831 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 2832 return false; 2833 break; 2834 } 2835 2836 if (internalValue <= ::FLASH_MODE_BASE || ::FLASH_MODE_MAX <= internalValue) { 2837 ALOGE("ERR(%s):Invalid value (%d)", __func__, value); 2838 return false; 2839 } 2840 2841 if (m_curCameraInfo->flashMode != value) { 2842 m_curCameraInfo->flashMode = value; 2843 if (m_flagCreate == true) { 2844 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FLASH_MODE, internalValue) < 0) { 2845 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2846 return false; 2847 } 2848 } 2849 } 2850 2851 return true; 2852 } 2853 2854 bool ExynosCamera::setFocusAreas(int num, ExynosRect* rects, int *weights) 2855 { 2856 if (m_defaultCameraInfo->maxNumFocusAreas == 0) { 2857 ALOGV("DEBUG(%s):maxNumFocusAreas is 0. so, ignored", __func__); 2858 return true; 2859 } 2860 2861 bool ret = true; 2862 2863 ExynosRect2 *rect2s = new ExynosRect2[num]; 2864 for (int i = 0; i < num; i++) 2865 m_secRect2SecRect2(&rects[i], &rect2s[i]); 2866 2867 ret = setFocusAreas(num, rect2s, weights); 2868 2869 delete [] rect2s; 2870 2871 return ret; 2872 } 2873 2874 bool ExynosCamera::setFocusAreas(int num, ExynosRect2* rect2s, int *weights) 2875 { 2876 if (m_defaultCameraInfo->maxNumFocusAreas == 0) { 2877 ALOGV("DEBUG(%s):maxNumFocusAreas is 0. so, ignored", __func__); 2878 return true; 2879 } 2880 2881 int new_x = 0; 2882 int new_y = 0; 2883 2884 if (m_defaultCameraInfo->maxNumFocusAreas < num) 2885 num = m_defaultCameraInfo->maxNumFocusAreas; 2886 2887 if (m_flagCreate == true) { 2888 for (int i = 0; i < num; i++) { 2889 if ( num == 1 2890 && rect2s[0].x1 == 0 2891 && rect2s[0].y1 == 0 2892 && rect2s[0].x2 == m_curCameraInfo->previewW 2893 && rect2s[0].y2 == m_curCameraInfo->previewH) { 2894 // TODO : driver decide focus areas -> focus center. 2895 new_x = (m_curCameraInfo->previewW) / 2; 2896 new_y = (m_curCameraInfo->previewH) / 2; 2897 } else { 2898 new_x = (rect2s[i].x1 + rect2s[i].x2) / 2; 2899 new_y = (rect2s[i].y1 + rect2s[i].y2) / 2; 2900 } 2901 2902 m_touchAFMode = true; 2903 if ( exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJECT_POSITION_X, new_x) < 0 2904 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJECT_POSITION_Y, new_y) < 0) { 2905 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2906 return false; 2907 } 2908 } 2909 } 2910 2911 return true; 2912 } 2913 2914 bool ExynosCamera::setFocusMode(int value) 2915 { 2916 int internalValue = -1; 2917 2918 switch (value) { 2919 case FOCUS_MODE_AUTO: 2920 internalValue = ::FOCUS_MODE_AUTO; 2921 m_touchAFMode = false; 2922 break; 2923 case FOCUS_MODE_INFINITY: 2924 internalValue = ::FOCUS_MODE_INFINITY; 2925 m_touchAFMode = false; 2926 break; 2927 case FOCUS_MODE_MACRO: 2928 internalValue = ::FOCUS_MODE_MACRO; 2929 m_touchAFMode = false; 2930 break; 2931 case FOCUS_MODE_CONTINUOUS_VIDEO: 2932 case FOCUS_MODE_CONTINUOUS_PICTURE: 2933 internalValue = ::FOCUS_MODE_CONTINOUS; 2934 m_touchAFMode = false; 2935 break; 2936 case FOCUS_MODE_TOUCH: 2937 internalValue = ::FOCUS_MODE_TOUCH; 2938 m_touchAFMode = true; 2939 break; 2940 case FOCUS_MODE_FIXED: 2941 internalValue = ::FOCUS_MODE_FIXED; 2942 m_touchAFMode = false; 2943 break; 2944 case FOCUS_MODE_EDOF: 2945 default: 2946 m_touchAFMode = false; 2947 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 2948 return false; 2949 break; 2950 } 2951 2952 if (::FOCUS_MODE_MAX <= internalValue) { 2953 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 2954 return false; 2955 } 2956 2957 if (m_curCameraInfo->focusMode != value) { 2958 m_curCameraInfo->focusMode = value; 2959 if (m_flagCreate == true) { 2960 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FOCUS_MODE, internalValue) < 0) { 2961 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 2962 return false; 2963 } 2964 } 2965 } 2966 2967 return true; 2968 } 2969 2970 bool ExynosCamera::setGpsAltitude(const char *gpsAltitude) 2971 { 2972 double conveted_altitude = 0; 2973 2974 if (gpsAltitude == NULL) 2975 m_curCameraInfo->gpsAltitude = 0; 2976 else { 2977 conveted_altitude = atof(gpsAltitude); 2978 m_curCameraInfo->gpsAltitude = (long)(conveted_altitude * 100 / 1); 2979 } 2980 2981 return true; 2982 } 2983 2984 bool ExynosCamera::setGpsLatitude(const char *gpsLatitude) 2985 { 2986 double conveted_latitude = 0; 2987 2988 if (gpsLatitude == NULL) 2989 m_curCameraInfo->gpsLatitude = 0; 2990 else { 2991 conveted_latitude = atof(gpsLatitude); 2992 m_curCameraInfo->gpsLatitude = (long)(conveted_latitude * 10000 / 1); 2993 } 2994 2995 return true; 2996 } 2997 2998 bool ExynosCamera::setGpsLongitude(const char *gpsLongitude) 2999 { 3000 double conveted_longitude = 0; 3001 3002 if (gpsLongitude == NULL) 3003 m_curCameraInfo->gpsLongitude = 0; 3004 else { 3005 conveted_longitude = atof(gpsLongitude); 3006 m_curCameraInfo->gpsLongitude = (long)(conveted_longitude * 10000 / 1); 3007 } 3008 3009 return true; 3010 } 3011 3012 bool ExynosCamera::setGpsProcessingMethod(const char *gpsProcessingMethod) 3013 { 3014 memset(mExifInfo.gps_processing_method, 0, sizeof(mExifInfo.gps_processing_method)); 3015 3016 if (gpsProcessingMethod != NULL) { 3017 size_t len = strlen(gpsProcessingMethod); 3018 if (len > sizeof(mExifInfo.gps_processing_method)) { 3019 len = sizeof(mExifInfo.gps_processing_method); 3020 } 3021 memcpy(mExifInfo.gps_processing_method, gpsProcessingMethod, len); 3022 } 3023 3024 return true; 3025 } 3026 3027 bool ExynosCamera::setGpsTimeStamp(const char *gpsTimestamp) 3028 { 3029 if (gpsTimestamp == NULL) 3030 m_curCameraInfo->gpsTimestamp = 0; 3031 else 3032 m_curCameraInfo->gpsTimestamp = atol(gpsTimestamp); 3033 3034 return true; 3035 } 3036 3037 bool ExynosCamera::setJpegQuality(int quality) 3038 { 3039 if (quality < JPEG_QUALITY_MIN || JPEG_QUALITY_MAX < quality) { 3040 ALOGE("ERR(%s):Invalid quality (%d)", __func__, quality); 3041 return false; 3042 } 3043 3044 m_jpegQuality = quality; 3045 3046 return true; 3047 } 3048 3049 bool ExynosCamera::setJpegThumbnailQuality(int quality) 3050 { 3051 if (quality < JPEG_QUALITY_MIN || JPEG_QUALITY_MAX < quality) { 3052 ALOGE("ERR(%s):Invalid quality (%d)", __func__, quality); 3053 return false; 3054 } 3055 3056 m_jpegThumbnailQuality = quality; 3057 3058 return true; 3059 } 3060 3061 bool ExynosCamera::setJpegThumbnailSize(int w, int h) 3062 { 3063 m_curCameraInfo->thumbnailW = w; 3064 m_curCameraInfo->thumbnailH = h; 3065 return true; 3066 } 3067 3068 bool ExynosCamera::setMeteringAreas(int num, ExynosRect *rects, int *weights) 3069 { 3070 if (m_defaultCameraInfo->maxNumMeteringAreas == 0) { 3071 ALOGV("DEBUG(%s):maxNumMeteringAreas is 0. so, ignored", __func__); 3072 return true; 3073 } 3074 3075 if (m_defaultCameraInfo->maxNumMeteringAreas < num) 3076 num = m_defaultCameraInfo->maxNumMeteringAreas; 3077 3078 if (m_flagCreate == true) { 3079 for (int i = 0; i < num; i++) { 3080 if ( exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING_POSITION_X, rects[i].x) < 0 3081 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING_POSITION_Y, rects[i].y) < 0 3082 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING_WINDOW_X, rects[i].w) < 0 3083 && exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING_WINDOW_Y, rects[i].h) < 0) { 3084 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 3085 return false; 3086 } 3087 } 3088 } 3089 3090 return true; 3091 } 3092 3093 bool ExynosCamera::setMeteringAreas(int num, ExynosRect2 *rect2s, int *weights) 3094 { 3095 if (m_defaultCameraInfo->maxNumMeteringAreas == 0) { 3096 ALOGV("DEBUG(%s):maxNumMeteringAreas is 0. so, ignored", __func__); 3097 return true; 3098 } 3099 3100 bool ret = true; 3101 3102 ExynosRect *rects = new ExynosRect[num]; 3103 for (int i = 0; i < num; i++) 3104 m_secRect22SecRect(&rect2s[i], &rects[i]); 3105 3106 /* FIXME: Currnetly HW dose not support metering area */ 3107 //ret = setMeteringAreas(num, rects, weights); 3108 3109 delete [] rects; 3110 3111 return ret; 3112 } 3113 3114 bool ExynosCamera::setPictureFormat(int colorFormat) 3115 { 3116 m_curCameraInfo->pictureColorFormat = colorFormat; 3117 3118 #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 3119 m_printFormat(m_curCameraInfo->pictureColorFormat, "PictureFormat"); 3120 #endif 3121 return true; 3122 } 3123 3124 bool ExynosCamera::setPictureSize(int w, int h) 3125 { 3126 m_curCameraInfo->pictureW = w; 3127 m_curCameraInfo->pictureH = h; 3128 3129 // HACK : Camera cannot support zoom. So, we must make max size picture w, h 3130 m_curCameraInfo->pictureW = m_defaultCameraInfo->pictureW; 3131 m_curCameraInfo->pictureH = m_defaultCameraInfo->pictureH; 3132 3133 return true; 3134 } 3135 3136 bool ExynosCamera::setPreviewFormat(int colorFormat) 3137 { 3138 m_curCameraInfo->previewColorFormat = colorFormat; 3139 3140 #if defined(LOG_NDEBUG) && LOG_NDEBUG == 0 3141 m_printFormat(m_curCameraInfo->previewColorFormat, "PreviewtFormat"); 3142 #endif 3143 3144 return true; 3145 } 3146 3147 bool ExynosCamera::setPreviewFrameRate(int fps) 3148 { 3149 if (fps < FRAME_RATE_AUTO || FRAME_RATE_MAX < fps) 3150 ALOGE("ERR(%s):Invalid fps(%d)", __func__, fps); 3151 3152 if (m_flagCreate == true) { 3153 m_curCameraInfo->fps = fps; 3154 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_FRAME_RATE, fps) < 0) { 3155 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 3156 return false; 3157 } 3158 } 3159 3160 return true; 3161 } 3162 3163 bool ExynosCamera::setPreviewSize(int w, int h) 3164 { 3165 m_curCameraInfo->previewW = w; 3166 m_curCameraInfo->previewH = h; 3167 return true; 3168 } 3169 3170 bool ExynosCamera::setRecordingHint(bool hint) 3171 { 3172 // TODO : fixed fps? 3173 /* DIS is only possible recording hint is true. */ 3174 m_recordingHint = hint; 3175 return true; 3176 } 3177 3178 bool ExynosCamera::setRotation(int rotation) 3179 { 3180 if (rotation < 0) { 3181 ALOGE("ERR(%s):Invalid rotation (%d)", __func__, rotation); 3182 return false; 3183 } 3184 m_curCameraInfo->rotation = rotation; 3185 3186 return true; 3187 } 3188 3189 int ExynosCamera::getRotation(void) 3190 { 3191 return m_curCameraInfo->rotation; 3192 } 3193 3194 bool ExynosCamera::setSceneMode(int value) 3195 { 3196 int internalValue = -1; 3197 3198 switch (value) { 3199 case SCENE_MODE_AUTO: 3200 internalValue = ::SCENE_MODE_NONE; 3201 break; 3202 case SCENE_MODE_PORTRAIT: 3203 internalValue = ::SCENE_MODE_PORTRAIT; 3204 break; 3205 case SCENE_MODE_LANDSCAPE: 3206 internalValue = ::SCENE_MODE_LANDSCAPE; 3207 break; 3208 case SCENE_MODE_NIGHT: 3209 internalValue = ::SCENE_MODE_NIGHTSHOT; 3210 break; 3211 case SCENE_MODE_BEACH: 3212 internalValue = ::SCENE_MODE_BEACH_SNOW; 3213 break; 3214 case SCENE_MODE_SNOW: 3215 internalValue = ::SCENE_MODE_BEACH_SNOW; 3216 break; 3217 case SCENE_MODE_SUNSET: 3218 internalValue = ::SCENE_MODE_SUNSET; 3219 break; 3220 case SCENE_MODE_FIREWORKS: 3221 internalValue = ::SCENE_MODE_FIREWORKS; 3222 break; 3223 case SCENE_MODE_SPORTS: 3224 internalValue = ::SCENE_MODE_SPORTS; 3225 break; 3226 case SCENE_MODE_PARTY: 3227 internalValue = ::SCENE_MODE_PARTY_INDOOR; 3228 break; 3229 case SCENE_MODE_CANDLELIGHT: 3230 internalValue = ::SCENE_MODE_CANDLE_LIGHT; 3231 break; 3232 case SCENE_MODE_STEADYPHOTO: 3233 internalValue = ::SCENE_MODE_TEXT; 3234 break; 3235 case SCENE_MODE_ACTION: 3236 case SCENE_MODE_NIGHT_PORTRAIT: 3237 case SCENE_MODE_THEATRE: 3238 default: 3239 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 3240 return false; 3241 break; 3242 } 3243 3244 if (internalValue <= ::SCENE_MODE_BASE || ::SCENE_MODE_MAX <= internalValue) { 3245 ALOGE("ERR(%s):Invalid value (%d)", __func__, internalValue); 3246 return false; 3247 } 3248 3249 if (m_curCameraInfo->sceneMode != value) { 3250 m_curCameraInfo->sceneMode = value; 3251 if (m_flagCreate == true) { 3252 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SCENE_MODE, internalValue) < 0) { 3253 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 3254 return false; 3255 } 3256 } 3257 } 3258 3259 return true; 3260 } 3261 3262 bool ExynosCamera::setVideoStabilization(bool toggle) 3263 { 3264 m_curCameraInfo->videoStabilization = toggle; 3265 3266 if (m_previewDev->flagStart == true) { 3267 if (m_curCameraInfo->applyVideoStabilization != toggle) { 3268 3269 int dis = (toggle == true) ? CAMERA_DIS_ON : CAMERA_DIS_OFF; 3270 3271 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_DIS, dis) < 0) { 3272 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 3273 return false; 3274 } else { 3275 m_curCameraInfo->applyVideoStabilization = toggle; 3276 } 3277 } 3278 } 3279 return true; 3280 } 3281 3282 bool ExynosCamera::setWhiteBalance(int value) 3283 { 3284 int internalValue = -1; 3285 3286 switch (value) { 3287 case WHITE_BALANCE_AUTO: 3288 if (m_internalISP == true) 3289 internalValue = ::IS_AWB_AUTO; 3290 else 3291 internalValue = ::WHITE_BALANCE_AUTO; 3292 break; 3293 case WHITE_BALANCE_INCANDESCENT: 3294 if (m_internalISP == true) 3295 internalValue = ::IS_AWB_TUNGSTEN; 3296 else 3297 internalValue = ::WHITE_BALANCE_TUNGSTEN; 3298 break; 3299 case WHITE_BALANCE_FLUORESCENT: 3300 if (m_internalISP == true) 3301 internalValue = ::IS_AWB_FLUORESCENT; 3302 else 3303 internalValue = ::WHITE_BALANCE_FLUORESCENT; 3304 break; 3305 case WHITE_BALANCE_DAYLIGHT: 3306 if (m_internalISP == true) 3307 internalValue = ::IS_AWB_DAYLIGHT; 3308 else 3309 internalValue = ::WHITE_BALANCE_SUNNY; 3310 break; 3311 case WHITE_BALANCE_CLOUDY_DAYLIGHT: 3312 if (m_internalISP == true) 3313 internalValue = ::IS_AWB_CLOUDY; 3314 else 3315 internalValue = ::WHITE_BALANCE_CLOUDY; 3316 break; 3317 case WHITE_BALANCE_WARM_FLUORESCENT: 3318 case WHITE_BALANCE_TWILIGHT: 3319 case WHITE_BALANCE_SHADE: 3320 default: 3321 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 3322 return false; 3323 break; 3324 } 3325 3326 if (m_internalISP == true) { 3327 if (internalValue < ::IS_AWB_AUTO || ::IS_AWB_MAX <= internalValue) { 3328 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 3329 return false; 3330 } 3331 } else { 3332 if (internalValue <= ::WHITE_BALANCE_BASE || ::WHITE_BALANCE_MAX <= internalValue) { 3333 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 3334 return false; 3335 } 3336 } 3337 3338 if (m_curCameraInfo->whiteBalance != value) { 3339 m_curCameraInfo->whiteBalance = value; 3340 if (m_flagCreate == true) { 3341 if (m_internalISP == true) { 3342 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_AWB_MODE, internalValue) < 0) { 3343 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 3344 return false; 3345 } 3346 } else { 3347 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_WHITE_BALANCE, internalValue) < 0) { 3348 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 3349 return false; 3350 } 3351 } 3352 } 3353 } 3354 3355 return true; 3356 } 3357 3358 bool ExynosCamera::setZoom(int value) 3359 { 3360 if (value < ZOOM_LEVEL_0 || ZOOM_LEVEL_MAX <= value) { 3361 ALOGE("ERR(%s):Invalid value (%d)", __func__, value); 3362 return false; 3363 } 3364 3365 if (m_curCameraInfo->zoom != value) { 3366 m_curCameraInfo->zoom = value; 3367 if (m_defaultCameraInfo->hwZoomSupported == true) { 3368 if (m_flagCreate == true) { 3369 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ZOOM, value) < 0) { 3370 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 3371 return false; 3372 } 3373 } 3374 } else { 3375 if (m_setZoom(m_previewDev->fd, m_curCameraInfo->zoom, m_curCameraInfo->previewW, m_curCameraInfo->previewH) == false) { 3376 ALOGE("ERR(%s):m_setZoom(%d) fail", __func__, m_curCameraInfo->zoom); 3377 return false; 3378 } 3379 } 3380 } 3381 3382 return true; 3383 } 3384 3385 bool ExynosCamera::m_setWidthHeight(int mode, 3386 int fd, 3387 struct pollfd *event, 3388 int w, 3389 int h, 3390 int colorFormat, 3391 struct ExynosBuffer *buf, 3392 bool *validBuf) 3393 { 3394 // Get and throw away the first frame since it is often garbled. 3395 memset(event, 0, sizeof(struct pollfd)); 3396 event->fd = fd; 3397 event->events = POLLIN | POLLERR; 3398 3399 int numOfBuf = 0; 3400 3401 for (int i = 0; i < VIDEO_MAX_FRAME; i++) { 3402 if (buf[i].virt.p != NULL || buf[i].phys.p != 0 || 3403 buf[i].fd.fd >= 0) { 3404 validBuf[i] = true; 3405 numOfBuf++; 3406 } else { 3407 validBuf[i] = false; 3408 } 3409 } 3410 3411 struct v4l2_format v4l2_fmt; 3412 struct v4l2_pix_format pixfmt; 3413 unsigned int bpp; 3414 unsigned int planes; 3415 3416 memset(&v4l2_fmt, 0, sizeof(struct v4l2_format)); 3417 memset(&pixfmt, 0, sizeof(pixfmt)); 3418 3419 switch(mode) { 3420 case PREVIEW_MODE: 3421 case VIDEO_MODE: 3422 v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3423 3424 V4L2_PIX_2_YUV_INFO(colorFormat, &bpp, &planes); 3425 3426 v4l2_fmt.fmt.pix_mp.width = w; 3427 v4l2_fmt.fmt.pix_mp.height = h; 3428 v4l2_fmt.fmt.pix_mp.pixelformat = colorFormat; 3429 v4l2_fmt.fmt.pix_mp.num_planes = planes; 3430 3431 if (exynos_v4l2_s_fmt(fd, &v4l2_fmt) < 0) { 3432 ALOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__); 3433 return false; 3434 } 3435 break; 3436 case PICTURE_MODE: 3437 v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3438 3439 pixfmt.width = w; 3440 pixfmt.height = h; 3441 pixfmt.pixelformat = colorFormat; 3442 if (pixfmt.pixelformat == V4L2_PIX_FMT_JPEG) 3443 pixfmt.colorspace = V4L2_COLORSPACE_JPEG; 3444 3445 v4l2_fmt.fmt.pix = pixfmt; 3446 3447 if (exynos_v4l2_s_fmt(fd, &v4l2_fmt) < 0) { 3448 ALOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__); 3449 return false; 3450 } 3451 break; 3452 default: 3453 break; 3454 } 3455 3456 struct v4l2_requestbuffers req; 3457 req.count = numOfBuf; 3458 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3459 req.memory = V4L2_MEMORY_DMABUF; 3460 3461 if (exynos_v4l2_reqbufs(fd, &req) < 0) { 3462 ALOGE("ERR(%s):exynos_v4l2_reqbufs(%d) fail", __func__, numOfBuf); 3463 return false; 3464 } 3465 3466 for (int i = 0; i < VIDEO_MAX_FRAME; i++) { 3467 if (validBuf[i] == true) { 3468 3469 struct v4l2_buffer v4l2_buf; 3470 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 3471 3472 v4l2_buf.m.planes = planes; 3473 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3474 v4l2_buf.memory = V4L2_MEMORY_DMABUF; 3475 v4l2_buf.index = buf[i].reserved.p; 3476 v4l2_buf.length = 0; 3477 3478 for (int j = 0; j < 3; j++) { 3479 v4l2_buf.m.planes[j].m.fd = buf[i].fd.extFd[j]; 3480 v4l2_buf.m.planes[j].length = buf[i].size.extS[j]; 3481 3482 if (buf[i].size.extS[j] != 0) 3483 v4l2_buf.length++; 3484 } 3485 3486 if (exynos_v4l2_qbuf(fd, &v4l2_buf) < 0) { 3487 ALOGE("ERR(%s):exynos_v4l2_qbuf(%d) fail", __func__, i); 3488 return false; 3489 } 3490 } 3491 } 3492 3493 /* 3494 m_currentZoom = -1; 3495 3496 if (m_setZoom(fd, m_curCameraInfo->zoom, w, h) == false) 3497 ALOGE("ERR(%s):m_setZoom(%d, %d) fail", __func__, mode, m_curCameraInfo->zoom); 3498 */ 3499 return true; 3500 } 3501 3502 bool ExynosCamera::m_setZoom(int fd, int zoom, int w, int h) 3503 { 3504 int ret = true; 3505 3506 if (m_currentZoom != zoom) { 3507 m_currentZoom = zoom; 3508 3509 int real_zoom = 0; 3510 3511 if (m_defaultCameraInfo->hwZoomSupported == true) 3512 real_zoom = 0; // just adjust ratio, not digital zoom. 3513 else 3514 real_zoom = zoom; // adjust ratio, digital zoom 3515 3516 ret = m_setCrop(fd, w, h, real_zoom); 3517 if (ret == false) 3518 ALOGE("ERR(%s):m_setCrop(%d, %d) fail", __func__, w, h); 3519 } 3520 3521 return ret; 3522 } 3523 3524 bool ExynosCamera::m_setCrop(int fd, int w, int h, int zoom) 3525 { 3526 v4l2_cropcap cropcap; 3527 v4l2_crop crop; 3528 unsigned int crop_x = 0; 3529 unsigned int crop_y = 0; 3530 unsigned int crop_w = 0; 3531 unsigned int crop_h = 0; 3532 3533 cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 3534 3535 if (exynos_v4l2_cropcap(fd, &cropcap) < 0) { 3536 ALOGE("ERR(%s):exynos_v4l2_cropcap() fail)", __func__); 3537 return false; 3538 } 3539 3540 m_getCropRect(cropcap.bounds.width, cropcap.bounds.height, 3541 w, h, 3542 &crop_x, &crop_y, 3543 &crop_w, &crop_h, 3544 zoom); 3545 3546 cropcap.defrect.left = crop_x; 3547 cropcap.defrect.top = crop_y; 3548 cropcap.defrect.width = crop_w; 3549 cropcap.defrect.height = crop_h; 3550 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 3551 crop.c = cropcap.defrect; 3552 3553 if (exynos_v4l2_s_crop(fd, &crop) < 0) { 3554 ALOGE("ERR(%s):exynos_v4l2_s_crop() fail(%d))", __func__, zoom); 3555 return false; 3556 } 3557 3558 /* 3559 ALOGD("## 1 w : %d", w); 3560 ALOGD("## 1 h : %d", h); 3561 ALOGD("## 1 zoom : %d", zoom); 3562 ALOGD("## 1 cropcap.bounds.w : %d", cropcap.bounds.width); 3563 ALOGD("## 1 cropcap.bounds.h : %d", cropcap.bounds.height); 3564 ALOGD("## 2 crop_x : %d", crop_x); 3565 ALOGD("## 2 crop_y : %d", crop_y); 3566 ALOGD("## 2 crop_w : %d", crop_w); 3567 ALOGD("## 2 crop_h : %d", crop_h); 3568 ALOGD("## 2 cropcap.defrect.left : %d", cropcap.defrect.left); 3569 ALOGD("## 2 cropcap.defrect.top : %d", cropcap.defrect.top); 3570 ALOGD("## 2 cropcap.defrect.width : %d", cropcap.defrect.width); 3571 ALOGD("## 2 cropcap.defrect.height: %d", cropcap.defrect.height); 3572 */ 3573 3574 return true; 3575 } 3576 3577 bool ExynosCamera::m_getCropRect(unsigned int src_w, unsigned int src_h, 3578 unsigned int dst_w, unsigned int dst_h, 3579 unsigned int *crop_x, unsigned int *crop_y, 3580 unsigned int *crop_w, unsigned int *crop_h, 3581 int zoom) 3582 { 3583 #define DEFAULT_ZOOM_RATIO (4) // 4x zoom 3584 #define DEFAULT_ZOOM_RATIO_SHIFT (2) 3585 int max_zoom = m_defaultCameraInfo->maxZoom; 3586 3587 *crop_w = src_w; 3588 *crop_h = src_h; 3589 3590 if ( src_w != dst_w 3591 || src_h != dst_h) { 3592 float src_ratio = 1.0f; 3593 float dst_ratio = 1.0f; 3594 3595 // ex : 1024 / 768 3596 src_ratio = (float)src_w / (float)src_h; 3597 3598 // ex : 352 / 288 3599 dst_ratio = (float)dst_w / (float)dst_h; 3600 3601 if (src_ratio != dst_ratio) { 3602 if (src_ratio <= dst_ratio) { 3603 // shrink h 3604 *crop_w = src_w; 3605 *crop_h = src_w / dst_ratio; 3606 } else { //(src_ratio > dst_ratio) 3607 // shrink w 3608 *crop_w = src_h * dst_ratio; 3609 *crop_h = src_h; 3610 } 3611 } 3612 3613 if (zoom != 0) { 3614 unsigned int zoom_w_step = 3615 (*crop_w - (*crop_w >> DEFAULT_ZOOM_RATIO_SHIFT)) / max_zoom; 3616 3617 *crop_w = *crop_w - (zoom_w_step * zoom); 3618 3619 unsigned int zoom_h_step = 3620 (*crop_h - (*crop_h >> DEFAULT_ZOOM_RATIO_SHIFT)) / max_zoom; 3621 3622 *crop_h = *crop_h - (zoom_h_step * zoom); 3623 } 3624 } 3625 3626 #define CAMERA_CROP_WIDTH_RESTRAIN_NUM (0x10) // 16 3627 unsigned int w_align = (*crop_w & (CAMERA_CROP_WIDTH_RESTRAIN_NUM - 1)); 3628 if (w_align != 0) { 3629 if ( (CAMERA_CROP_WIDTH_RESTRAIN_NUM >> 1) <= w_align 3630 && *crop_w + (CAMERA_CROP_WIDTH_RESTRAIN_NUM - w_align) <= dst_w) { 3631 *crop_w += (CAMERA_CROP_WIDTH_RESTRAIN_NUM - w_align); 3632 } 3633 else 3634 *crop_w -= w_align; 3635 } 3636 3637 #define CAMERA_CROP_HEIGHT_RESTRAIN_NUM (0x2) // 2 3638 unsigned int h_align = (*crop_h & (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - 1)); 3639 if (h_align != 0) { 3640 if ( (CAMERA_CROP_HEIGHT_RESTRAIN_NUM >> 1) <= h_align 3641 && *crop_h + (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - h_align) <= dst_h) { 3642 *crop_h += (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - h_align); 3643 } 3644 else 3645 *crop_h -= h_align; 3646 } 3647 3648 *crop_x = (src_w - *crop_w) >> 1; 3649 *crop_y = (src_h - *crop_h) >> 1; 3650 3651 return true; 3652 } 3653 3654 void ExynosCamera::m_setExifFixedAttribute(void) 3655 { 3656 char property[PROPERTY_VALUE_MAX]; 3657 3658 //2 0th IFD TIFF Tags 3659 //3 Maker 3660 property_get("ro.product.brand", property, EXIF_DEF_MAKER); 3661 strncpy((char *)mExifInfo.maker, property, 3662 sizeof(mExifInfo.maker) - 1); 3663 mExifInfo.maker[sizeof(mExifInfo.maker) - 1] = '\0'; 3664 //3 Model 3665 property_get("ro.product.model", property, EXIF_DEF_MODEL); 3666 strncpy((char *)mExifInfo.model, property, 3667 sizeof(mExifInfo.model) - 1); 3668 mExifInfo.model[sizeof(mExifInfo.model) - 1] = '\0'; 3669 //3 Software 3670 property_get("ro.build.id", property, EXIF_DEF_SOFTWARE); 3671 strncpy((char *)mExifInfo.software, property, 3672 sizeof(mExifInfo.software) - 1); 3673 mExifInfo.software[sizeof(mExifInfo.software) - 1] = '\0'; 3674 3675 //3 YCbCr Positioning 3676 mExifInfo.ycbcr_positioning = EXIF_DEF_YCBCR_POSITIONING; 3677 3678 //2 0th IFD Exif Private Tags 3679 //3 F Number 3680 mExifInfo.fnumber.num = EXIF_DEF_FNUMBER_NUM; 3681 mExifInfo.fnumber.den = EXIF_DEF_FNUMBER_DEN; 3682 //3 Exposure Program 3683 mExifInfo.exposure_program = EXIF_DEF_EXPOSURE_PROGRAM; 3684 //3 Exif Version 3685 memcpy(mExifInfo.exif_version, EXIF_DEF_EXIF_VERSION, sizeof(mExifInfo.exif_version)); 3686 //3 Aperture 3687 uint32_t av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num/mExifInfo.fnumber.den); 3688 mExifInfo.aperture.num = av*EXIF_DEF_APEX_DEN; 3689 mExifInfo.aperture.den = EXIF_DEF_APEX_DEN; 3690 //3 Maximum lens aperture 3691 mExifInfo.max_aperture.num = mExifInfo.aperture.num; 3692 mExifInfo.max_aperture.den = mExifInfo.aperture.den; 3693 //3 Lens Focal Length 3694 mExifInfo.focal_length.num = m_defaultCameraInfo->focalLengthNum; 3695 mExifInfo.focal_length.den = m_defaultCameraInfo->focalLengthDen; 3696 //3 User Comments 3697 strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS); 3698 //3 Color Space information 3699 mExifInfo.color_space = EXIF_DEF_COLOR_SPACE; 3700 //3 Exposure Mode 3701 mExifInfo.exposure_mode = EXIF_DEF_EXPOSURE_MODE; 3702 3703 //2 0th IFD GPS Info Tags 3704 unsigned char gps_version[4] = { 0x02, 0x02, 0x00, 0x00 }; 3705 memcpy(mExifInfo.gps_version_id, gps_version, sizeof(gps_version)); 3706 3707 //2 1th IFD TIFF Tags 3708 mExifInfo.compression_scheme = EXIF_DEF_COMPRESSION; 3709 mExifInfo.x_resolution.num = EXIF_DEF_RESOLUTION_NUM; 3710 mExifInfo.x_resolution.den = EXIF_DEF_RESOLUTION_DEN; 3711 mExifInfo.y_resolution.num = EXIF_DEF_RESOLUTION_NUM; 3712 mExifInfo.y_resolution.den = EXIF_DEF_RESOLUTION_DEN; 3713 mExifInfo.resolution_unit = EXIF_DEF_RESOLUTION_UNIT; 3714 } 3715 3716 void ExynosCamera::m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosRect *rect) 3717 { 3718 //2 0th IFD TIFF Tags 3719 //3 Width 3720 exifInfo->width = rect->w; 3721 //3 Height 3722 exifInfo->height = rect->h; 3723 //3 Orientation 3724 switch (m_curCameraInfo->rotation) { 3725 case 90: 3726 exifInfo->orientation = EXIF_ORIENTATION_90; 3727 break; 3728 case 180: 3729 exifInfo->orientation = EXIF_ORIENTATION_180; 3730 break; 3731 case 270: 3732 exifInfo->orientation = EXIF_ORIENTATION_270; 3733 break; 3734 case 0: 3735 default: 3736 exifInfo->orientation = EXIF_ORIENTATION_UP; 3737 break; 3738 } 3739 //3 Date time 3740 time_t rawtime; 3741 struct tm *timeinfo; 3742 time(&rawtime); 3743 timeinfo = localtime(&rawtime); 3744 strftime((char *)exifInfo->date_time, 20, "%Y:%m:%d %H:%M:%S", timeinfo); 3745 3746 //2 0th IFD Exif Private Tags 3747 //3 Exposure Time 3748 int shutterSpeed = 100; 3749 /* TBD - front camera needs to be fixed to support this g_ctrl, 3750 it current returns a negative err value, so avoid putting 3751 odd value into exif for now */ 3752 if ( exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_SHUTTERSPEED, &shutterSpeed) < 0 3753 || shutterSpeed < 0) { 3754 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using 100", __func__); 3755 shutterSpeed = 100; 3756 } 3757 3758 exifInfo->exposure_time.num = 1; 3759 // x us -> 1/x s */ 3760 exifInfo->exposure_time.den = (uint32_t)(1000000 / shutterSpeed); 3761 3762 //3 ISO Speed Rating 3763 int iso = m_curCameraInfo->iso; 3764 3765 /* TBD - front camera needs to be fixed to support this g_ctrl, 3766 it current returns a negative err value, so avoid putting 3767 odd value into exif for now */ 3768 if ( exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_ISO, &iso) < 0 3769 || iso < 0) { 3770 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using ISO_100", __func__); 3771 iso = ISO_100; 3772 } 3773 3774 switch (iso) { 3775 case ISO_50: 3776 exifInfo->iso_speed_rating = 50; 3777 break; 3778 case ISO_100: 3779 exifInfo->iso_speed_rating = 100; 3780 break; 3781 case ISO_200: 3782 exifInfo->iso_speed_rating = 200; 3783 break; 3784 case ISO_400: 3785 exifInfo->iso_speed_rating = 400; 3786 break; 3787 case ISO_800: 3788 exifInfo->iso_speed_rating = 800; 3789 break; 3790 case ISO_1600: 3791 exifInfo->iso_speed_rating = 1600; 3792 break; 3793 default: 3794 exifInfo->iso_speed_rating = 100; 3795 break; 3796 } 3797 3798 uint32_t av, tv, bv, sv, ev; 3799 av = APEX_FNUM_TO_APERTURE((double)exifInfo->fnumber.num / exifInfo->fnumber.den); 3800 tv = APEX_EXPOSURE_TO_SHUTTER((double)exifInfo->exposure_time.num / exifInfo->exposure_time.den); 3801 sv = APEX_ISO_TO_FILMSENSITIVITY(exifInfo->iso_speed_rating); 3802 bv = av + tv - sv; 3803 ev = av + tv; 3804 ALOGD("Shutter speed=%d us, iso=%d", shutterSpeed, exifInfo->iso_speed_rating); 3805 ALOGD("AV=%d, TV=%d, SV=%d", av, tv, sv); 3806 3807 //3 Shutter Speed 3808 exifInfo->shutter_speed.num = tv * EXIF_DEF_APEX_DEN; 3809 exifInfo->shutter_speed.den = EXIF_DEF_APEX_DEN; 3810 //3 Brightness 3811 exifInfo->brightness.num = bv*EXIF_DEF_APEX_DEN; 3812 exifInfo->brightness.den = EXIF_DEF_APEX_DEN; 3813 //3 Exposure Bias 3814 if (m_curCameraInfo->sceneMode == SCENE_MODE_BEACH || 3815 m_curCameraInfo->sceneMode == SCENE_MODE_SNOW) { 3816 exifInfo->exposure_bias.num = EXIF_DEF_APEX_DEN; 3817 exifInfo->exposure_bias.den = EXIF_DEF_APEX_DEN; 3818 } else { 3819 exifInfo->exposure_bias.num = 0; 3820 exifInfo->exposure_bias.den = 0; 3821 } 3822 //3 Metering Mode 3823 switch (m_curCameraInfo->metering) { 3824 case METERING_MODE_CENTER: 3825 exifInfo->metering_mode = EXIF_METERING_CENTER; 3826 break; 3827 case METERING_MODE_MATRIX: 3828 exifInfo->metering_mode = EXIF_METERING_MULTISPOT; 3829 break; 3830 case METERING_MODE_SPOT: 3831 exifInfo->metering_mode = EXIF_METERING_SPOT; 3832 break; 3833 case METERING_MODE_AVERAGE: 3834 default: 3835 exifInfo->metering_mode = EXIF_METERING_AVERAGE; 3836 break; 3837 } 3838 3839 //3 Flash 3840 int flash = EXIF_DEF_FLASH; 3841 if ( m_curCameraInfo->flashMode == FLASH_MODE_OFF 3842 || exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_FLASH, &flash) < 0 3843 || flash < 0) 3844 exifInfo->flash = EXIF_DEF_FLASH; 3845 else 3846 exifInfo->flash = flash; 3847 3848 //3 White Balance 3849 if (m_curCameraInfo->whiteBalance == WHITE_BALANCE_AUTO) 3850 exifInfo->white_balance = EXIF_WB_AUTO; 3851 else 3852 exifInfo->white_balance = EXIF_WB_MANUAL; 3853 3854 //3 Scene Capture Type 3855 switch (m_curCameraInfo->sceneMode) { 3856 case SCENE_MODE_PORTRAIT: 3857 exifInfo->scene_capture_type = EXIF_SCENE_PORTRAIT; 3858 break; 3859 case SCENE_MODE_LANDSCAPE: 3860 exifInfo->scene_capture_type = EXIF_SCENE_LANDSCAPE; 3861 break; 3862 case SCENE_MODE_NIGHT: 3863 exifInfo->scene_capture_type = EXIF_SCENE_NIGHT; 3864 break; 3865 default: 3866 exifInfo->scene_capture_type = EXIF_SCENE_STANDARD; 3867 break; 3868 } 3869 3870 //2 0th IFD GPS Info Tags 3871 if (m_curCameraInfo->gpsLatitude != 0 && m_curCameraInfo->gpsLongitude != 0) { 3872 if (m_curCameraInfo->gpsLatitude > 0) 3873 strcpy((char *)exifInfo->gps_latitude_ref, "N"); 3874 else 3875 strcpy((char *)exifInfo->gps_latitude_ref, "S"); 3876 3877 if (m_curCameraInfo->gpsLongitude > 0) 3878 strcpy((char *)exifInfo->gps_longitude_ref, "E"); 3879 else 3880 strcpy((char *)exifInfo->gps_longitude_ref, "W"); 3881 3882 if (m_curCameraInfo->gpsAltitude > 0) 3883 exifInfo->gps_altitude_ref = 0; 3884 else 3885 exifInfo->gps_altitude_ref = 1; 3886 3887 double latitude = fabs(m_curCameraInfo->gpsLatitude / 10000.0); 3888 double longitude = fabs(m_curCameraInfo->gpsLongitude / 10000.0); 3889 double altitude = fabs(m_curCameraInfo->gpsAltitude / 100.0); 3890 3891 exifInfo->gps_latitude[0].num = (uint32_t)latitude; 3892 exifInfo->gps_latitude[0].den = 1; 3893 exifInfo->gps_latitude[1].num = (uint32_t)((latitude - exifInfo->gps_latitude[0].num) * 60); 3894 exifInfo->gps_latitude[1].den = 1; 3895 exifInfo->gps_latitude[2].num = (uint32_t)((((latitude - exifInfo->gps_latitude[0].num) * 60) 3896 - exifInfo->gps_latitude[1].num) * 60); 3897 exifInfo->gps_latitude[2].den = 1; 3898 3899 exifInfo->gps_longitude[0].num = (uint32_t)longitude; 3900 exifInfo->gps_longitude[0].den = 1; 3901 exifInfo->gps_longitude[1].num = (uint32_t)((longitude - exifInfo->gps_longitude[0].num) * 60); 3902 exifInfo->gps_longitude[1].den = 1; 3903 exifInfo->gps_longitude[2].num = (uint32_t)((((longitude - exifInfo->gps_longitude[0].num) * 60) 3904 - exifInfo->gps_longitude[1].num) * 60); 3905 exifInfo->gps_longitude[2].den = 1; 3906 3907 exifInfo->gps_altitude.num = (uint32_t)altitude; 3908 exifInfo->gps_altitude.den = 1; 3909 3910 struct tm tm_data; 3911 gmtime_r(&m_curCameraInfo->gpsTimestamp, &tm_data); 3912 exifInfo->gps_timestamp[0].num = tm_data.tm_hour; 3913 exifInfo->gps_timestamp[0].den = 1; 3914 exifInfo->gps_timestamp[1].num = tm_data.tm_min; 3915 exifInfo->gps_timestamp[1].den = 1; 3916 exifInfo->gps_timestamp[2].num = tm_data.tm_sec; 3917 exifInfo->gps_timestamp[2].den = 1; 3918 snprintf((char*)exifInfo->gps_datestamp, sizeof(exifInfo->gps_datestamp), 3919 "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon + 1, tm_data.tm_mday); 3920 3921 exifInfo->enableGps = true; 3922 } else { 3923 exifInfo->enableGps = false; 3924 } 3925 3926 //2 1th IFD TIFF Tags 3927 exifInfo->widthThumb = m_curCameraInfo->thumbnailW; 3928 exifInfo->heightThumb = m_curCameraInfo->thumbnailH; 3929 } 3930 3931 void ExynosCamera::m_secRect2SecRect2(ExynosRect *rect, ExynosRect2 *rect2) 3932 { 3933 rect2->x1 = rect->x; 3934 rect2->y1 = rect->y; 3935 rect2->x2 = rect->x + rect->w; 3936 rect2->y2 = rect->y + rect->h; 3937 } 3938 3939 void ExynosCamera::m_secRect22SecRect(ExynosRect2 *rect2, ExynosRect *rect) 3940 { 3941 rect->x = rect2->x1; 3942 rect->y = rect2->y1; 3943 rect->w = rect2->x2 - rect2->x1; 3944 rect->h = rect2->y2 - rect2->y1; 3945 } 3946 3947 void ExynosCamera::m_printFormat(int colorFormat, const char *arg) 3948 { 3949 switch (colorFormat) { 3950 case V4L2_PIX_FMT_YUV420: 3951 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUV420", arg); 3952 break; 3953 case V4L2_PIX_FMT_YVU420: 3954 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420", arg); 3955 break; 3956 case V4L2_PIX_FMT_YVU420M: 3957 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420M", arg); 3958 break; 3959 case V4L2_PIX_FMT_NV12M: 3960 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12M", arg); 3961 break; 3962 case V4L2_PIX_FMT_NV12: 3963 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12", arg); 3964 break; 3965 case V4L2_PIX_FMT_NV12T: 3966 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12T", arg); 3967 break; 3968 case V4L2_PIX_FMT_NV21: 3969 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV21", arg); 3970 break; 3971 case V4L2_PIX_FMT_YUV422P: 3972 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUV422PP", arg); 3973 break; 3974 case V4L2_PIX_FMT_YUYV: 3975 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUYV", arg); 3976 break; 3977 case V4L2_PIX_FMT_UYVY: 3978 ALOGV("DEBUG(%s):V4L2_PIX_FMT_UYVYI", arg); 3979 break; 3980 case V4L2_PIX_FMT_RGB565: 3981 ALOGV("DEBUG(%s):V4L2_PIX_FMT_RGB565", arg); 3982 break; 3983 default: 3984 ALOGV("DEBUG(%s):Unknown Format", arg); 3985 break; 3986 } 3987 } 3988 3989 /////////////////////////////////////////////////// 3990 // Additional API. 3991 /////////////////////////////////////////////////// 3992 3993 bool ExynosCamera::setAngle(int angle) 3994 { 3995 if (m_curCameraInfo->angle != angle) { 3996 switch (angle) { 3997 case -360: 3998 case 0: 3999 case 360: 4000 m_curCameraInfo->angle = 0; 4001 break; 4002 4003 case -270: 4004 case 90: 4005 m_curCameraInfo->angle = 90; 4006 break; 4007 4008 case -180: 4009 case 180: 4010 m_curCameraInfo->angle = 180; 4011 break; 4012 4013 case -90: 4014 case 270: 4015 m_curCameraInfo->angle = 270; 4016 break; 4017 4018 default: 4019 ALOGE("ERR(%s):Invalid angle(%d)", __func__, angle); 4020 return false; 4021 } 4022 4023 if (m_flagCreate == true) { 4024 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_ROTATION, angle) < 0) { 4025 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4026 return false; 4027 } 4028 } 4029 } 4030 4031 return true; 4032 } 4033 4034 int ExynosCamera::getAngle(void) 4035 { 4036 return m_curCameraInfo->angle; 4037 } 4038 4039 bool ExynosCamera::setISO(int iso) 4040 { 4041 int internalValue = -1; 4042 4043 switch (iso) { 4044 case 50: 4045 internalValue = ISO_50; 4046 break; 4047 case 100: 4048 internalValue = ISO_100; 4049 break; 4050 case 200: 4051 internalValue = ISO_200; 4052 break; 4053 case 400: 4054 internalValue = ISO_400; 4055 break; 4056 case 800: 4057 internalValue = ISO_800; 4058 break; 4059 case 1600: 4060 internalValue = ISO_1600; 4061 break; 4062 case 0: 4063 default: 4064 internalValue = ISO_AUTO; 4065 break; 4066 } 4067 4068 if (internalValue < ISO_AUTO || ISO_MAX <= internalValue) { 4069 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4070 return false; 4071 } 4072 4073 if (m_curCameraInfo->iso != iso) { 4074 m_curCameraInfo->iso = iso; 4075 if (m_flagCreate == true) { 4076 if (m_internalISP == true) { 4077 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_ISO, internalValue) < 0) { 4078 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4079 return false; 4080 } 4081 } else { 4082 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ISO, internalValue) < 0) { 4083 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4084 return false; 4085 } 4086 } 4087 } 4088 } 4089 4090 return true; 4091 } 4092 4093 int ExynosCamera::getISO(void) 4094 { 4095 return m_curCameraInfo->iso; 4096 } 4097 4098 bool ExynosCamera::setContrast(int value) 4099 { 4100 int internalValue = -1; 4101 4102 switch (value) { 4103 case CONTRAST_AUTO: 4104 if (m_internalISP == true) 4105 internalValue = ::IS_CONTRAST_AUTO; 4106 else 4107 ALOGW("WARN(%s):Invalid contrast value (%d)", __func__, value); 4108 return true; 4109 break; 4110 case CONTRAST_MINUS_2: 4111 if (m_internalISP == true) 4112 internalValue = ::IS_CONTRAST_MINUS_2; 4113 else 4114 internalValue = ::CONTRAST_MINUS_2; 4115 break; 4116 case CONTRAST_MINUS_1: 4117 if (m_internalISP == true) 4118 internalValue = ::IS_CONTRAST_MINUS_1; 4119 else 4120 internalValue = ::CONTRAST_MINUS_1; 4121 break; 4122 case CONTRAST_DEFAULT: 4123 if (m_internalISP == true) 4124 internalValue = ::IS_CONTRAST_DEFAULT; 4125 else 4126 internalValue = ::CONTRAST_DEFAULT; 4127 break; 4128 case CONTRAST_PLUS_1: 4129 if (m_internalISP == true) 4130 internalValue = ::IS_CONTRAST_PLUS_1; 4131 else 4132 internalValue = ::CONTRAST_PLUS_1; 4133 break; 4134 case CONTRAST_PLUS_2: 4135 if (m_internalISP == true) 4136 internalValue = ::IS_CONTRAST_PLUS_2; 4137 else 4138 internalValue = ::CONTRAST_PLUS_2; 4139 break; 4140 default: 4141 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 4142 return false; 4143 break; 4144 } 4145 4146 if (m_internalISP == true) { 4147 if (internalValue < ::IS_CONTRAST_AUTO || ::IS_CONTRAST_MAX <= internalValue) { 4148 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4149 return false; 4150 } 4151 } else { 4152 if (internalValue < ::CONTRAST_MINUS_2 || ::CONTRAST_MAX <= internalValue) { 4153 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4154 return false; 4155 } 4156 } 4157 4158 if (m_curCameraInfo->contrast != value) { 4159 m_curCameraInfo->contrast = value; 4160 if (m_flagCreate == true) { 4161 if (m_internalISP == true) { 4162 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_CONTRAST, internalValue) < 0) { 4163 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4164 return false; 4165 } 4166 } else { 4167 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_CONTRAST, internalValue) < 0) { 4168 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4169 return false; 4170 } 4171 } 4172 } 4173 } 4174 4175 return true; 4176 } 4177 4178 int ExynosCamera::getContrast(void) 4179 { 4180 return m_curCameraInfo->contrast; 4181 } 4182 4183 bool ExynosCamera::setSaturation(int saturation) 4184 { 4185 int internalValue = saturation + SATURATION_DEFAULT; 4186 if (internalValue < SATURATION_MINUS_2 || SATURATION_MAX <= internalValue) { 4187 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4188 return false; 4189 } 4190 4191 if (m_curCameraInfo->saturation != saturation) { 4192 m_curCameraInfo->saturation = saturation; 4193 if (m_flagCreate == true) { 4194 if (m_internalISP == true) { 4195 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SATURATION, internalValue) < 0) { 4196 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4197 return false; 4198 } 4199 } else { 4200 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SATURATION, internalValue) < 0) { 4201 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4202 return false; 4203 } 4204 } 4205 } 4206 } 4207 4208 return true; 4209 } 4210 4211 int ExynosCamera::getSaturation(void) 4212 { 4213 return m_curCameraInfo->saturation; 4214 } 4215 4216 bool ExynosCamera::setSharpness(int sharpness) 4217 { 4218 int internalValue = sharpness + SHARPNESS_DEFAULT; 4219 if (internalValue < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= internalValue) { 4220 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4221 return false; 4222 } 4223 4224 if (m_curCameraInfo->sharpness != sharpness) { 4225 m_curCameraInfo->sharpness = sharpness; 4226 if (m_flagCreate == true) { 4227 if (m_internalISP == true) { 4228 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SHARPNESS, internalValue) < 0) { 4229 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4230 return false; 4231 } 4232 } else { 4233 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SHARPNESS, internalValue) < 0) { 4234 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4235 return false; 4236 } 4237 } 4238 } 4239 } 4240 4241 return true; 4242 } 4243 4244 int ExynosCamera::getSharpness(void) 4245 { 4246 return m_curCameraInfo->sharpness; 4247 } 4248 4249 bool ExynosCamera::setHue(int hue) 4250 { 4251 int internalValue = hue; 4252 4253 if (m_internalISP == true) { 4254 internalValue += IS_HUE_DEFAULT; 4255 if (internalValue < IS_HUE_MINUS_2 || IS_HUE_MAX <= internalValue) { 4256 ALOGE("ERR(%s):Invalid hue (%d)", __func__, hue); 4257 return false; 4258 } 4259 } else { 4260 ALOGV("WARN(%s):Not supported hue setting", __func__); 4261 return true; 4262 } 4263 4264 if (m_curCameraInfo->hue != hue) { 4265 m_curCameraInfo->hue = hue; 4266 if (m_flagCreate == true) { 4267 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_HUE, internalValue) < 0) { 4268 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4269 return false; 4270 } 4271 } 4272 } 4273 4274 return true; 4275 } 4276 4277 int ExynosCamera::getHue(void) 4278 { 4279 return m_curCameraInfo->hue; 4280 } 4281 4282 bool ExynosCamera::setWDR(bool toggle) 4283 { 4284 int internalWdr; 4285 4286 if (toggle == true) { 4287 if (m_internalISP == true) 4288 internalWdr = IS_DRC_BYPASS_ENABLE; 4289 else 4290 internalWdr = IS_DRC_BYPASS_DISABLE; 4291 } else { 4292 if (m_internalISP == true) 4293 internalWdr = WDR_ON; 4294 else 4295 internalWdr = WDR_OFF; 4296 } 4297 4298 if (m_curCameraInfo->wdr != toggle) { 4299 m_curCameraInfo->wdr = toggle; 4300 if (m_flagCreate == true) { 4301 if (m_internalISP == true) { 4302 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_SET_DRC, internalWdr) < 0) { 4303 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4304 return false; 4305 } 4306 } else { 4307 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_WDR, internalWdr) < 0) { 4308 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4309 return false; 4310 } 4311 } 4312 } 4313 } 4314 4315 return true; 4316 } 4317 4318 bool ExynosCamera::getWDR(void) 4319 { 4320 return m_curCameraInfo->wdr; 4321 } 4322 4323 bool ExynosCamera::setAntiShake(bool toggle) 4324 { 4325 int internalValue = ANTI_SHAKE_OFF; 4326 4327 if (toggle == true) 4328 internalValue = ANTI_SHAKE_STILL_ON; 4329 4330 if (m_curCameraInfo->antiShake != toggle) { 4331 m_curCameraInfo->antiShake = toggle; 4332 if (m_flagCreate == true) { 4333 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ANTI_SHAKE, internalValue) < 0) { 4334 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4335 return false; 4336 } 4337 } 4338 } 4339 4340 return true; 4341 } 4342 4343 bool ExynosCamera::getAntiShake(void) 4344 { 4345 return m_curCameraInfo->antiShake; 4346 } 4347 4348 bool ExynosCamera::setMeteringMode(int value) 4349 { 4350 int internalValue = -1; 4351 4352 switch (value) { 4353 case METERING_MODE_AVERAGE: 4354 if (m_internalISP == true) 4355 internalValue = IS_METERING_AVERAGE; 4356 else 4357 internalValue = METERING_MATRIX; 4358 break; 4359 case METERING_MODE_MATRIX: 4360 if (m_internalISP == true) 4361 internalValue = IS_METERING_MATRIX; 4362 else 4363 internalValue = METERING_MATRIX; 4364 break; 4365 case METERING_MODE_CENTER: 4366 if (m_internalISP == true) 4367 internalValue = IS_METERING_CENTER; 4368 else 4369 internalValue = METERING_CENTER; 4370 break; 4371 case METERING_MODE_SPOT: 4372 if (m_internalISP == true) 4373 internalValue = IS_METERING_SPOT; 4374 else 4375 internalValue = METERING_SPOT; 4376 break; 4377 default: 4378 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 4379 return false; 4380 break; 4381 } 4382 4383 if (m_internalISP == true) { 4384 if (internalValue < IS_METERING_AVERAGE || IS_METERING_MAX <= internalValue) { 4385 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4386 return false; 4387 } 4388 } else { 4389 if (internalValue <= METERING_BASE || METERING_MAX <= internalValue) { 4390 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4391 return false; 4392 } 4393 } 4394 4395 if (m_curCameraInfo->metering != value) { 4396 m_curCameraInfo->metering = value; 4397 if (m_flagCreate == true) { 4398 if (m_internalISP == true) { 4399 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING, internalValue) < 0) { 4400 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4401 return false; 4402 } 4403 } else { 4404 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_METERING, internalValue) < 0) { 4405 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4406 return false; 4407 } 4408 } 4409 } 4410 } 4411 4412 return true; 4413 } 4414 4415 int ExynosCamera::getMeteringMode(void) 4416 { 4417 return m_curCameraInfo->metering; 4418 } 4419 4420 bool ExynosCamera::setObjectTracking(bool toggle) 4421 { 4422 m_curCameraInfo->objectTracking = toggle; 4423 return true; 4424 } 4425 4426 bool ExynosCamera::getObjectTracking(void) 4427 { 4428 return m_curCameraInfo->objectTracking; 4429 } 4430 4431 bool ExynosCamera::setObjectTrackingStart(bool toggle) 4432 { 4433 if (m_curCameraInfo->objectTrackingStart != toggle) { 4434 m_curCameraInfo->objectTrackingStart = toggle; 4435 4436 int startStop = (toggle == true) ? 1 : 0; 4437 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, startStop) < 0) { 4438 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4439 return false; 4440 } 4441 } 4442 4443 return true; 4444 } 4445 4446 int ExynosCamera::getObjectTrackingStatus(void) 4447 { 4448 int ret = 0; 4449 4450 if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJ_TRACKING_STATUS, &ret) < 0) { 4451 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__); 4452 return -1; 4453 } 4454 return ret; 4455 } 4456 4457 bool ExynosCamera::setObjectPosition(int x, int y) 4458 { 4459 if (m_curCameraInfo->previewW == 640) 4460 x = x - 80; 4461 4462 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_OBJECT_POSITION_X, x) < 0) { 4463 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4464 return false; 4465 } 4466 4467 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_OBJECT_POSITION_Y, y) < 0) { 4468 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4469 return false; 4470 } 4471 4472 return true; 4473 } 4474 4475 bool ExynosCamera::setTouchAFStart(bool toggle) 4476 { 4477 if (m_curCameraInfo->touchAfStart != toggle) { 4478 m_curCameraInfo->touchAfStart = toggle; 4479 int startStop = (toggle == true) ? 1 : 0; 4480 4481 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, startStop) < 0) { 4482 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4483 return false; 4484 } 4485 } 4486 4487 return true; 4488 } 4489 4490 bool ExynosCamera::setSmartAuto(bool toggle) 4491 { 4492 if (m_curCameraInfo->smartAuto != toggle) { 4493 m_curCameraInfo->smartAuto = toggle; 4494 4495 int smartAuto = (toggle == true) ? SMART_AUTO_ON : SMART_AUTO_OFF; 4496 4497 if (m_flagCreate == true) { 4498 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SMART_AUTO, smartAuto) < 0) { 4499 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4500 return false; 4501 } 4502 } 4503 } 4504 4505 return true; 4506 } 4507 4508 bool ExynosCamera::getSmartAuto(void) 4509 { 4510 return m_curCameraInfo->smartAuto; 4511 } 4512 4513 int ExynosCamera::getSmartAutoStatus(void) 4514 { 4515 int autoscene_status = -1; 4516 4517 if (m_curCameraInfo->smartAuto == true) { 4518 if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS, &autoscene_status) < 0) { 4519 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__); 4520 return -1; 4521 } 4522 4523 if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) { 4524 ALOGE("ERR(%s):Invalid getSmartAutoStatus (%d)", __func__, autoscene_status); 4525 return -1; 4526 } 4527 } 4528 return autoscene_status; 4529 } 4530 4531 bool ExynosCamera::setBeautyShot(bool toggle) 4532 { 4533 if (m_curCameraInfo->beautyShot != toggle) { 4534 m_curCameraInfo->beautyShot = toggle; 4535 int beautyShot = (toggle == true) ? BEAUTY_SHOT_ON : BEAUTY_SHOT_OFF; 4536 4537 if (m_flagCreate == true) { 4538 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beautyShot) < 0) { 4539 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4540 return false; 4541 } 4542 } 4543 } 4544 4545 return true; 4546 } 4547 4548 bool ExynosCamera::getBeautyShot(void) 4549 { 4550 return m_curCameraInfo->beautyShot; 4551 } 4552 4553 bool ExynosCamera::setTopDownMirror(void) 4554 { 4555 if (m_previewDev->fd <= 0) { 4556 ALOGE("ERR(%s):Camera was closed", __func__); 4557 return false; 4558 } 4559 4560 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_VFLIP, 1) < 0) { 4561 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4562 return false; 4563 } 4564 4565 return true; 4566 } 4567 4568 bool ExynosCamera::setLRMirror(void) 4569 { 4570 if (m_previewDev->fd <= 0) { 4571 ALOGE("ERR(%s):Camera was closed", __func__); 4572 return false; 4573 } 4574 4575 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_HFLIP, 1) < 0) { 4576 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4577 return false; 4578 } 4579 4580 return true; 4581 } 4582 4583 bool ExynosCamera::setBrightness(int brightness) 4584 { 4585 int internalValue = brightness; 4586 4587 if (m_internalISP == true) { 4588 internalValue += IS_BRIGHTNESS_DEFAULT; 4589 if (internalValue < IS_BRIGHTNESS_MINUS_2 || IS_BRIGHTNESS_PLUS_2 < internalValue) { 4590 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 4591 return false; 4592 } 4593 } else { 4594 internalValue += EV_DEFAULT; 4595 if (internalValue < EV_MINUS_4 || EV_PLUS_4 < internalValue) { 4596 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 4597 return false; 4598 } 4599 } 4600 4601 if (m_curCameraInfo->brightness != brightness) { 4602 m_curCameraInfo->brightness = brightness; 4603 if (m_flagCreate == true) { 4604 if (m_internalISP == true) { 4605 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_BRIGHTNESS, internalValue) < 0) { 4606 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4607 return false; 4608 } 4609 } else { 4610 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_BRIGHTNESS, internalValue) < 0) { 4611 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4612 return false; 4613 } 4614 } 4615 } 4616 } 4617 4618 return true; 4619 } 4620 4621 int ExynosCamera::getBrightness(void) 4622 { 4623 return m_curCameraInfo->brightness; 4624 } 4625 4626 bool ExynosCamera::setGamma(bool toggle) 4627 { 4628 if (m_curCameraInfo->gamma != toggle) { 4629 m_curCameraInfo->gamma = toggle; 4630 4631 int gamma = (toggle == true) ? GAMMA_ON : GAMMA_OFF; 4632 4633 if (m_flagCreate == true) { 4634 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) { 4635 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4636 return false; 4637 } 4638 } 4639 } 4640 4641 return true; 4642 } 4643 4644 bool ExynosCamera::getGamma(void) 4645 { 4646 return m_curCameraInfo->gamma; 4647 } 4648 4649 bool ExynosCamera::setODC(bool toggle) 4650 { 4651 if (m_previewDev->flagStart == true) { 4652 if (m_curCameraInfo->odc != toggle) { 4653 m_curCameraInfo->odc = toggle; 4654 4655 int odc = (toggle == true) ? CAMERA_ODC_ON : CAMERA_ODC_OFF; 4656 4657 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_ODC, odc) < 0) { 4658 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4659 return false; 4660 } 4661 } 4662 } 4663 4664 return true; 4665 } 4666 4667 bool ExynosCamera::getODC(void) 4668 { 4669 return m_curCameraInfo->odc; 4670 } 4671 4672 bool ExynosCamera::setSlowAE(bool toggle) 4673 { 4674 if (m_curCameraInfo->slowAE != toggle) { 4675 m_curCameraInfo->slowAE = toggle; 4676 4677 int slow_ae = (toggle == true) ? SLOW_AE_ON : SLOW_AE_OFF; 4678 4679 if (m_flagCreate == true) { 4680 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) { 4681 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4682 return false; 4683 } 4684 } 4685 } 4686 4687 return true; 4688 } 4689 4690 bool ExynosCamera::getSlowAE(void) 4691 { 4692 return m_curCameraInfo->slowAE; 4693 } 4694 4695 bool ExynosCamera::setShotMode(int shotMode) 4696 { 4697 if (shotMode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shotMode) { 4698 ALOGE("ERR(%s):Invalid shotMode (%d)", __func__, shotMode); 4699 return false; 4700 } 4701 4702 if (m_curCameraInfo->shotMode != shotMode) { 4703 m_curCameraInfo->shotMode = shotMode; 4704 4705 if (m_flagCreate == true) { 4706 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SHOT_MODE_NORMAL, shotMode) < 0) { 4707 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4708 return false; 4709 } 4710 } 4711 } 4712 4713 return true; 4714 } 4715 4716 int ExynosCamera::getShotMode(void) 4717 { 4718 return m_curCameraInfo->shotMode; 4719 } 4720 4721 bool ExynosCamera::set3DNR(bool toggle) 4722 { 4723 if (m_previewDev->flagStart == true) { 4724 if (m_curCameraInfo->tdnr != toggle) { 4725 m_curCameraInfo->tdnr = toggle; 4726 4727 int tdnr = (toggle == true) ? CAMERA_3DNR_ON : CAMERA_3DNR_OFF; 4728 4729 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_3DNR, tdnr) < 0) { 4730 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4731 return false; 4732 } 4733 } 4734 } 4735 4736 return true; 4737 } 4738 4739 bool ExynosCamera::get3DNR(void) 4740 { 4741 return m_curCameraInfo->tdnr; 4742 } 4743 4744 }; // namespace android 4745
