ExynosCamera.cpp revision 88cc230929f380e97a664d83299a7cf7deb45ac7
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@samsung.com) 22 * \date 2010/06/03 23 * 24 * <b>Revision History: </b> 25 * - 2011/12/31 : thun.hwang(thun.hwang@samsung.com) \n 26 * Initial version 27 * 28 * - 2012/01/18 : Sangwoo, Park(sw5771.park@samsung.com) \n 29 * Adjust Doxygen Document 30 * 31 * - 2012/02/01 : Sangwoo, Park(sw5771.park@samsung.com) \n 32 * Adjust libv4l2 33 * Adjust struct ExynosCameraInfo 34 * External ISP feature 35 * 36 * - 2012/03/14 : sangwoo.park(sw5771.park@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 67using namespace android; 68 69namespace android { 70 71ExynosCameraInfo::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 205ExynosCameraInfoM5M0::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 315ExynosCameraInfoS5K6A3::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 432ExynosCameraInfoS5K4E5::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 630ExynosCamera::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 685ExynosCamera::~ExynosCamera() 686{ 687 if (m_flagCreate == true) 688 destroy(); 689} 690 691bool 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 1056err: 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 1084bool 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 1131bool ExynosCamera::flagCreate(void) 1132{ 1133 return m_flagCreate; 1134} 1135 1136int ExynosCamera::getCameraId(void) 1137{ 1138 return m_cameraId; 1139} 1140 1141char *ExynosCamera::getCameraName(void) 1142{ 1143 return m_cameraName; 1144} 1145 1146int ExynosCamera::getPreviewFd(void) 1147{ 1148 return m_previewDev->fd; 1149} 1150 1151int ExynosCamera::getPictureFd(void) 1152{ 1153 return m_pictureDev->fd; 1154} 1155 1156int ExynosCamera::getVideoFd(void) 1157{ 1158 return m_videoDev->fd; 1159} 1160 1161bool 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 1226bool 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_USERPTR; 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 1280bool ExynosCamera::flagStartPreview(void) 1281{ 1282 return m_previewDev->flagStart; 1283} 1284 1285int ExynosCamera::getPreviewMaxBuf(void) 1286{ 1287 return VIDEO_MAX_FRAME; 1288} 1289 1290bool 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 1311bool 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_USERPTR; 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 1351bool 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_USERPTR; 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.userptr = (unsigned long)m_previewBuf[buf->reserved.p].virt.extP[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 1388bool 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 1401bool ExynosCamera::getVideoSize(int *w, int *h) 1402{ 1403 *w = m_curCameraInfo->videoW; 1404 *h = m_curCameraInfo->videoH; 1405 return true; 1406} 1407 1408bool ExynosCamera::setVideoFormat(int colorFormat) 1409{ 1410 m_curCameraInfo->videoColorFormat = colorFormat; 1411 return true; 1412} 1413 1414int ExynosCamera::getVideoFormat(void) 1415{ 1416 return m_curCameraInfo->videoColorFormat; 1417} 1418 1419bool 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 1453bool 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_USERPTR; 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 1489bool ExynosCamera::flagStartVideo(void) 1490{ 1491 return m_videoDev->flagStart; 1492} 1493 1494int ExynosCamera::getVideoMaxBuf(void) 1495{ 1496 return VIDEO_MAX_FRAME; 1497} 1498 1499bool 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 1515bool 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_USERPTR; 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 1555bool 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_USERPTR; 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.userptr = (unsigned long)m_videoBuf[buf->reserved.p].virt.extP[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 1603bool 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 1635bool 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_USERPTR; 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 1672bool ExynosCamera::flagStartPicture(void) 1673{ 1674 return m_pictureDev->flagStart; 1675} 1676 1677int ExynosCamera::getPictureMaxBuf(void) 1678{ 1679 return VIDEO_MAX_FRAME; 1680} 1681 1682bool 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 1698bool 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_USERPTR; 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 1738bool 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_USERPTR; 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.userptr = (unsigned long)m_pictureBuf[buf->reserved.p].virt.extP[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 1780bool 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 1857jpeg_encode_done: 1858 1859 if (jpegEnc.flagCreate() == true) 1860 jpegEnc.destroy(); 1861 1862 return ret; 1863} 1864 1865bool 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 1918bool 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 1965int 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 2028bool 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 2060bool 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 2084bool ExynosCamera::flagStartFaceDetection(void) 2085{ 2086 return m_flagStartFaceDetection; 2087} 2088 2089bool 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 2100bool 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 2110bool ExynosCamera::stopSmoothZoom(void) 2111{ 2112 // TODO 2113 return true; 2114} 2115 2116int ExynosCamera::getAntibanding(void) 2117{ 2118 return m_curCameraInfo->antiBanding; 2119} 2120 2121bool ExynosCamera::getAutoExposureLock(void) 2122{ 2123 return m_curCameraInfo->autoExposureLock; 2124} 2125 2126bool ExynosCamera::getAutoWhiteBalanceLock(void) 2127{ 2128 return m_curCameraInfo->autoWhiteBalanceLock; 2129} 2130 2131int ExynosCamera::getColorEffect(void) 2132{ 2133 return m_curCameraInfo->effect; 2134} 2135 2136int 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 2194int 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 2328done: 2329 delete [] fd_ctrl; 2330 2331 return num; 2332} 2333 2334int ExynosCamera::getExposureCompensation(void) 2335{ 2336 return m_curCameraInfo->exposure; 2337} 2338 2339float 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 2350int ExynosCamera::getFlashMode(void) 2351{ 2352 return m_curCameraInfo->flashMode; 2353} 2354 2355bool ExynosCamera::getFocalLength(int *num, int *den) 2356{ 2357 *num = m_defaultCameraInfo->focalLengthNum; 2358 *num = m_defaultCameraInfo->focalLengthDen; 2359 return true; 2360} 2361 2362int ExynosCamera::getFocusAreas(ExynosRect *rects) 2363{ 2364 // TODO 2365 return 0; 2366} 2367 2368int ExynosCamera::getFocusDistances(float *output) 2369{ 2370 // TODO 2371 return 0; 2372} 2373 2374int ExynosCamera::getFocusMode(void) 2375{ 2376 return m_curCameraInfo->focusMode; 2377} 2378 2379float ExynosCamera::getHorizontalViewAngle(void) 2380{ 2381 //TODO 2382 return 51.2f; 2383} 2384 2385int ExynosCamera::getJpegQuality(void) 2386{ 2387 return m_jpegQuality; 2388} 2389 2390int ExynosCamera::getJpegThumbnailQuality(void) 2391{ 2392 return m_jpegThumbnailQuality; 2393} 2394 2395bool ExynosCamera::getJpegThumbnailSize(int *w, int *h) 2396{ 2397 *w = m_curCameraInfo->thumbnailW; 2398 *h = m_curCameraInfo->thumbnailH; 2399 return true; 2400} 2401 2402int ExynosCamera::getMaxExposureCompensation(void) 2403{ 2404 return m_defaultCameraInfo->maxExposure; 2405} 2406 2407int ExynosCamera::getMaxNumDetectedFaces(void) 2408{ 2409 return m_defaultCameraInfo->maxNumDetectedFaces; 2410} 2411 2412int ExynosCamera::getMaxNumFocusAreas(void) 2413{ 2414 return m_defaultCameraInfo->maxNumFocusAreas; 2415} 2416 2417int ExynosCamera::getMaxNumMeteringAreas(void) 2418{ 2419 return m_defaultCameraInfo->maxNumMeteringAreas; 2420} 2421 2422int ExynosCamera::getMaxZoom(void) 2423{ 2424 return m_defaultCameraInfo->maxZoom; 2425} 2426 2427int ExynosCamera::getMeteringAreas(ExynosRect *rects) 2428{ 2429 // TODO 2430 return 0; 2431} 2432 2433int ExynosCamera::getMinExposureCompensation(void) 2434{ 2435 return m_defaultCameraInfo->minExposure; 2436} 2437 2438int ExynosCamera::getPictureFormat(void) 2439{ 2440 return m_curCameraInfo->pictureColorFormat; 2441} 2442 2443bool ExynosCamera::getPictureSize(int *w, int *h) 2444{ 2445 *w = m_curCameraInfo->pictureW; 2446 *h = m_curCameraInfo->pictureH; 2447 return true; 2448} 2449 2450int ExynosCamera::getPreviewFormat(void) 2451{ 2452 return m_curCameraInfo->previewColorFormat; 2453} 2454 2455bool ExynosCamera::getPreviewFpsRange(int *min, int *max) 2456{ 2457 *min = 1; 2458 *max = m_defaultCameraInfo->fps; 2459 return true; 2460} 2461 2462int ExynosCamera::getPreviewFrameRate(void) 2463{ 2464 return m_curCameraInfo->fps; 2465} 2466 2467bool ExynosCamera::getPreviewSize(int *w, int *h) 2468{ 2469 *w = m_curCameraInfo->previewW; 2470 *h = m_curCameraInfo->previewH; 2471 return true; 2472} 2473 2474int ExynosCamera::getSceneMode(void) 2475{ 2476 return m_curCameraInfo->sceneMode; 2477} 2478 2479int ExynosCamera::getSupportedAntibanding(void) 2480{ 2481 return m_defaultCameraInfo->antiBandingList; 2482} 2483 2484int ExynosCamera::getSupportedColorEffects(void) 2485{ 2486 return m_defaultCameraInfo->effectList; 2487} 2488 2489int ExynosCamera::getSupportedFlashModes(void) 2490{ 2491 return m_defaultCameraInfo->flashModeList; 2492} 2493 2494int ExynosCamera::getSupportedFocusModes(void) 2495{ 2496 return m_defaultCameraInfo->focusModeList; 2497} 2498 2499bool ExynosCamera::getSupportedJpegThumbnailSizes(int *w, int *h) 2500{ 2501 *w = m_defaultCameraInfo->thumbnailW; 2502 *h = m_defaultCameraInfo->thumbnailH; 2503 return true; 2504} 2505 2506bool ExynosCamera::getSupportedPictureSizes(int *w, int *h) 2507{ 2508 *w = m_defaultCameraInfo->pictureW; 2509 *h = m_defaultCameraInfo->pictureH; 2510 return true; 2511} 2512 2513bool ExynosCamera::getSupportedPreviewSizes(int *w, int *h) 2514{ 2515 *w = m_defaultCameraInfo->previewW; 2516 *h = m_defaultCameraInfo->previewH; 2517 return true; 2518} 2519 2520int ExynosCamera::getSupportedSceneModes(void) 2521{ 2522 return m_defaultCameraInfo->sceneModeList; 2523} 2524 2525bool ExynosCamera::getSupportedVideoSizes(int *w, int *h) 2526{ 2527 *w = m_defaultCameraInfo->videoW; 2528 *h = m_defaultCameraInfo->videoH; 2529 return true; 2530} 2531 2532bool ExynosCamera::getPreferredPreivewSizeForVideo(int *w, int *h) 2533{ 2534 *w = m_defaultCameraInfo->prefVideoPreviewW; 2535 *h = m_defaultCameraInfo->prefVideoPreviewH; 2536 return true; 2537} 2538 2539int ExynosCamera::getSupportedWhiteBalance(void) 2540{ 2541 return m_defaultCameraInfo->whiteBalanceList; 2542} 2543 2544float ExynosCamera::getVerticalViewAngle(void) 2545{ 2546 // TODO 2547 return 39.4f; 2548} 2549 2550bool ExynosCamera::getVideoStabilization(void) 2551{ 2552 return m_curCameraInfo->videoStabilization; 2553} 2554 2555int ExynosCamera::getWhiteBalance(void) 2556{ 2557 return m_curCameraInfo->whiteBalance; 2558} 2559 2560int ExynosCamera::getZoom(void) 2561{ 2562 return m_curCameraInfo->zoom; 2563} 2564 2565int ExynosCamera::getMaxZoomRatio(void) 2566{ 2567 return 400; 2568} 2569 2570bool ExynosCamera::isAutoExposureLockSupported(void) 2571{ 2572 return m_defaultCameraInfo->autoExposureLockSupported; 2573} 2574 2575bool ExynosCamera::isAutoWhiteBalanceLockSupported(void) 2576{ 2577 return m_defaultCameraInfo->autoWhiteBalanceLockSupported; 2578} 2579 2580bool ExynosCamera::isSmoothZoomSupported(void) 2581{ 2582 if (m_defaultCameraInfo->hwZoomSupported == true) 2583 return true; 2584 else 2585 return false; 2586} 2587 2588bool ExynosCamera::isVideoSnapshotSupported(void) 2589{ 2590 return true; 2591} 2592 2593bool ExynosCamera::isVideoStabilizationSupported(void) 2594{ 2595 return m_defaultCameraInfo->supportVideoStabilization; 2596} 2597 2598bool ExynosCamera::isZoomSupported(void) 2599{ 2600 return true; 2601} 2602 2603bool 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 2651bool 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 2678bool 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 2705bool 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 2774bool 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 2812bool 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 2854bool 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 2874bool 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 2914bool 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 2970bool 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 2984bool 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 2998bool 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 3012bool 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 3027bool 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 3037bool 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 3049bool 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 3061bool ExynosCamera::setJpegThumbnailSize(int w, int h) 3062{ 3063 m_curCameraInfo->thumbnailW = w; 3064 m_curCameraInfo->thumbnailH = h; 3065 return true; 3066} 3067 3068bool 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 3093bool 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 3114bool 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 3124bool 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 3136bool 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 3147bool 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 3163bool ExynosCamera::setPreviewSize(int w, int h) 3164{ 3165 m_curCameraInfo->previewW = w; 3166 m_curCameraInfo->previewH = h; 3167 return true; 3168} 3169 3170bool 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 3178bool 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 3189int ExynosCamera::getRotation(void) 3190{ 3191 return m_curCameraInfo->rotation; 3192} 3193 3194bool 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 3262bool 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 3282bool 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 3358bool 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 3385bool 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 validBuf[i] = true; 3404 numOfBuf++; 3405 } else { 3406 validBuf[i] = false; 3407 } 3408 } 3409 3410 struct v4l2_format v4l2_fmt; 3411 struct v4l2_pix_format pixfmt; 3412 unsigned int bpp; 3413 unsigned int planes; 3414 3415 memset(&v4l2_fmt, 0, sizeof(struct v4l2_format)); 3416 memset(&pixfmt, 0, sizeof(pixfmt)); 3417 3418 switch(mode) { 3419 case PREVIEW_MODE: 3420 case VIDEO_MODE: 3421 v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3422 3423 V4L2_PIX_2_YUV_INFO(colorFormat, &bpp, &planes); 3424 3425 v4l2_fmt.fmt.pix_mp.width = w; 3426 v4l2_fmt.fmt.pix_mp.height = h; 3427 v4l2_fmt.fmt.pix_mp.pixelformat = colorFormat; 3428 v4l2_fmt.fmt.pix_mp.num_planes = planes; 3429 3430 if (exynos_v4l2_s_fmt(fd, &v4l2_fmt) < 0) { 3431 ALOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__); 3432 return false; 3433 } 3434 break; 3435 case PICTURE_MODE: 3436 v4l2_fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3437 3438 pixfmt.width = w; 3439 pixfmt.height = h; 3440 pixfmt.pixelformat = colorFormat; 3441 if (pixfmt.pixelformat == V4L2_PIX_FMT_JPEG) 3442 pixfmt.colorspace = V4L2_COLORSPACE_JPEG; 3443 3444 v4l2_fmt.fmt.pix = pixfmt; 3445 3446 if (exynos_v4l2_s_fmt(fd, &v4l2_fmt) < 0) { 3447 ALOGE("ERR(%s):exynos_v4l2_s_fmt() fail", __func__); 3448 return false; 3449 } 3450 break; 3451 default: 3452 break; 3453 } 3454 3455 struct v4l2_requestbuffers req; 3456 req.count = numOfBuf; 3457 req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3458 req.memory = V4L2_MEMORY_USERPTR; 3459 3460 if (exynos_v4l2_reqbufs(fd, &req) < 0) { 3461 ALOGE("ERR(%s):exynos_v4l2_reqbufs(%d) fail", __func__, numOfBuf); 3462 return false; 3463 } 3464 3465 for (int i = 0; i < VIDEO_MAX_FRAME; i++) { 3466 if (validBuf[i] == true) { 3467 3468 struct v4l2_buffer v4l2_buf; 3469 struct v4l2_plane planes[VIDEO_MAX_PLANES]; 3470 3471 v4l2_buf.m.planes = planes; 3472 v4l2_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE; 3473 v4l2_buf.memory = V4L2_MEMORY_USERPTR; 3474 v4l2_buf.index = buf[i].reserved.p; 3475 v4l2_buf.length = 0; 3476 3477 for (int j = 0; j < 3; j++) { 3478 v4l2_buf.m.planes[j].m.userptr = (unsigned long)buf[i].virt.extP[j]; 3479 v4l2_buf.m.planes[j].length = buf[i].size.extS[j]; 3480 3481 if (buf[i].size.extS[j] != 0) 3482 v4l2_buf.length++; 3483 } 3484 3485 if (exynos_v4l2_qbuf(fd, &v4l2_buf) < 0) { 3486 ALOGE("ERR(%s):exynos_v4l2_qbuf(%d) fail", __func__, i); 3487 return false; 3488 } 3489 } 3490 } 3491 3492 /* 3493 m_currentZoom = -1; 3494 3495 if (m_setZoom(fd, m_curCameraInfo->zoom, w, h) == false) 3496 ALOGE("ERR(%s):m_setZoom(%d, %d) fail", __func__, mode, m_curCameraInfo->zoom); 3497 */ 3498 return true; 3499} 3500 3501bool ExynosCamera::m_setZoom(int fd, int zoom, int w, int h) 3502{ 3503 int ret = true; 3504 3505 if (m_currentZoom != zoom) { 3506 m_currentZoom = zoom; 3507 3508 int real_zoom = 0; 3509 3510 if (m_defaultCameraInfo->hwZoomSupported == true) 3511 real_zoom = 0; // just adjust ratio, not digital zoom. 3512 else 3513 real_zoom = zoom; // adjust ratio, digital zoom 3514 3515 ret = m_setCrop(fd, w, h, real_zoom); 3516 if (ret == false) 3517 ALOGE("ERR(%s):m_setCrop(%d, %d) fail", __func__, w, h); 3518 } 3519 3520 return ret; 3521} 3522 3523bool ExynosCamera::m_setCrop(int fd, int w, int h, int zoom) 3524{ 3525 v4l2_cropcap cropcap; 3526 v4l2_crop crop; 3527 unsigned int crop_x = 0; 3528 unsigned int crop_y = 0; 3529 unsigned int crop_w = 0; 3530 unsigned int crop_h = 0; 3531 3532 cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 3533 3534 if (exynos_v4l2_cropcap(fd, &cropcap) < 0) { 3535 ALOGE("ERR(%s):exynos_v4l2_cropcap() fail)", __func__); 3536 return false; 3537 } 3538 3539 m_getCropRect(cropcap.bounds.width, cropcap.bounds.height, 3540 w, h, 3541 &crop_x, &crop_y, 3542 &crop_w, &crop_h, 3543 zoom); 3544 3545 cropcap.defrect.left = crop_x; 3546 cropcap.defrect.top = crop_y; 3547 cropcap.defrect.width = crop_w; 3548 cropcap.defrect.height = crop_h; 3549 crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 3550 crop.c = cropcap.defrect; 3551 3552 if (exynos_v4l2_s_crop(fd, &crop) < 0) { 3553 ALOGE("ERR(%s):exynos_v4l2_s_crop() fail(%d))", __func__, zoom); 3554 return false; 3555 } 3556 3557 /* 3558 ALOGD("## 1 w : %d", w); 3559 ALOGD("## 1 h : %d", h); 3560 ALOGD("## 1 zoom : %d", zoom); 3561 ALOGD("## 1 cropcap.bounds.w : %d", cropcap.bounds.width); 3562 ALOGD("## 1 cropcap.bounds.h : %d", cropcap.bounds.height); 3563 ALOGD("## 2 crop_x : %d", crop_x); 3564 ALOGD("## 2 crop_y : %d", crop_y); 3565 ALOGD("## 2 crop_w : %d", crop_w); 3566 ALOGD("## 2 crop_h : %d", crop_h); 3567 ALOGD("## 2 cropcap.defrect.left : %d", cropcap.defrect.left); 3568 ALOGD("## 2 cropcap.defrect.top : %d", cropcap.defrect.top); 3569 ALOGD("## 2 cropcap.defrect.width : %d", cropcap.defrect.width); 3570 ALOGD("## 2 cropcap.defrect.height: %d", cropcap.defrect.height); 3571 */ 3572 3573 return true; 3574} 3575 3576bool ExynosCamera::m_getCropRect(unsigned int src_w, unsigned int src_h, 3577 unsigned int dst_w, unsigned int dst_h, 3578 unsigned int *crop_x, unsigned int *crop_y, 3579 unsigned int *crop_w, unsigned int *crop_h, 3580 int zoom) 3581{ 3582 #define DEFAULT_ZOOM_RATIO (4) // 4x zoom 3583 #define DEFAULT_ZOOM_RATIO_SHIFT (2) 3584 int max_zoom = m_defaultCameraInfo->maxZoom; 3585 3586 *crop_w = src_w; 3587 *crop_h = src_h; 3588 3589 if ( src_w != dst_w 3590 || src_h != dst_h) { 3591 float src_ratio = 1.0f; 3592 float dst_ratio = 1.0f; 3593 3594 // ex : 1024 / 768 3595 src_ratio = (float)src_w / (float)src_h; 3596 3597 // ex : 352 / 288 3598 dst_ratio = (float)dst_w / (float)dst_h; 3599 3600 if (src_ratio != dst_ratio) { 3601 if (src_ratio <= dst_ratio) { 3602 // shrink h 3603 *crop_w = src_w; 3604 *crop_h = src_w / dst_ratio; 3605 } else { //(src_ratio > dst_ratio) 3606 // shrink w 3607 *crop_w = src_h * dst_ratio; 3608 *crop_h = src_h; 3609 } 3610 } 3611 3612 if (zoom != 0) { 3613 unsigned int zoom_w_step = 3614 (*crop_w - (*crop_w >> DEFAULT_ZOOM_RATIO_SHIFT)) / max_zoom; 3615 3616 *crop_w = *crop_w - (zoom_w_step * zoom); 3617 3618 unsigned int zoom_h_step = 3619 (*crop_h - (*crop_h >> DEFAULT_ZOOM_RATIO_SHIFT)) / max_zoom; 3620 3621 *crop_h = *crop_h - (zoom_h_step * zoom); 3622 } 3623 } 3624 3625 #define CAMERA_CROP_WIDTH_RESTRAIN_NUM (0x10) // 16 3626 unsigned int w_align = (*crop_w & (CAMERA_CROP_WIDTH_RESTRAIN_NUM - 1)); 3627 if (w_align != 0) { 3628 if ( (CAMERA_CROP_WIDTH_RESTRAIN_NUM >> 1) <= w_align 3629 && *crop_w + (CAMERA_CROP_WIDTH_RESTRAIN_NUM - w_align) <= dst_w) { 3630 *crop_w += (CAMERA_CROP_WIDTH_RESTRAIN_NUM - w_align); 3631 } 3632 else 3633 *crop_w -= w_align; 3634 } 3635 3636 #define CAMERA_CROP_HEIGHT_RESTRAIN_NUM (0x2) // 2 3637 unsigned int h_align = (*crop_h & (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - 1)); 3638 if (h_align != 0) { 3639 if ( (CAMERA_CROP_HEIGHT_RESTRAIN_NUM >> 1) <= h_align 3640 && *crop_h + (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - h_align) <= dst_h) { 3641 *crop_h += (CAMERA_CROP_HEIGHT_RESTRAIN_NUM - h_align); 3642 } 3643 else 3644 *crop_h -= h_align; 3645 } 3646 3647 *crop_x = (src_w - *crop_w) >> 1; 3648 *crop_y = (src_h - *crop_h) >> 1; 3649 3650 return true; 3651} 3652 3653void ExynosCamera::m_setExifFixedAttribute(void) 3654{ 3655 char property[PROPERTY_VALUE_MAX]; 3656 3657 //2 0th IFD TIFF Tags 3658 //3 Maker 3659 property_get("ro.product.brand", property, EXIF_DEF_MAKER); 3660 strncpy((char *)mExifInfo.maker, property, 3661 sizeof(mExifInfo.maker) - 1); 3662 mExifInfo.maker[sizeof(mExifInfo.maker) - 1] = '\0'; 3663 //3 Model 3664 property_get("ro.product.model", property, EXIF_DEF_MODEL); 3665 strncpy((char *)mExifInfo.model, property, 3666 sizeof(mExifInfo.model) - 1); 3667 mExifInfo.model[sizeof(mExifInfo.model) - 1] = '\0'; 3668 //3 Software 3669 property_get("ro.build.id", property, EXIF_DEF_SOFTWARE); 3670 strncpy((char *)mExifInfo.software, property, 3671 sizeof(mExifInfo.software) - 1); 3672 mExifInfo.software[sizeof(mExifInfo.software) - 1] = '\0'; 3673 3674 //3 YCbCr Positioning 3675 mExifInfo.ycbcr_positioning = EXIF_DEF_YCBCR_POSITIONING; 3676 3677 //2 0th IFD Exif Private Tags 3678 //3 F Number 3679 mExifInfo.fnumber.num = EXIF_DEF_FNUMBER_NUM; 3680 mExifInfo.fnumber.den = EXIF_DEF_FNUMBER_DEN; 3681 //3 Exposure Program 3682 mExifInfo.exposure_program = EXIF_DEF_EXPOSURE_PROGRAM; 3683 //3 Exif Version 3684 memcpy(mExifInfo.exif_version, EXIF_DEF_EXIF_VERSION, sizeof(mExifInfo.exif_version)); 3685 //3 Aperture 3686 uint32_t av = APEX_FNUM_TO_APERTURE((double)mExifInfo.fnumber.num/mExifInfo.fnumber.den); 3687 mExifInfo.aperture.num = av*EXIF_DEF_APEX_DEN; 3688 mExifInfo.aperture.den = EXIF_DEF_APEX_DEN; 3689 //3 Maximum lens aperture 3690 mExifInfo.max_aperture.num = mExifInfo.aperture.num; 3691 mExifInfo.max_aperture.den = mExifInfo.aperture.den; 3692 //3 Lens Focal Length 3693 mExifInfo.focal_length.num = m_defaultCameraInfo->focalLengthNum; 3694 mExifInfo.focal_length.den = m_defaultCameraInfo->focalLengthDen; 3695 //3 User Comments 3696 strcpy((char *)mExifInfo.user_comment, EXIF_DEF_USERCOMMENTS); 3697 //3 Color Space information 3698 mExifInfo.color_space = EXIF_DEF_COLOR_SPACE; 3699 //3 Exposure Mode 3700 mExifInfo.exposure_mode = EXIF_DEF_EXPOSURE_MODE; 3701 3702 //2 0th IFD GPS Info Tags 3703 unsigned char gps_version[4] = { 0x02, 0x02, 0x00, 0x00 }; 3704 memcpy(mExifInfo.gps_version_id, gps_version, sizeof(gps_version)); 3705 3706 //2 1th IFD TIFF Tags 3707 mExifInfo.compression_scheme = EXIF_DEF_COMPRESSION; 3708 mExifInfo.x_resolution.num = EXIF_DEF_RESOLUTION_NUM; 3709 mExifInfo.x_resolution.den = EXIF_DEF_RESOLUTION_DEN; 3710 mExifInfo.y_resolution.num = EXIF_DEF_RESOLUTION_NUM; 3711 mExifInfo.y_resolution.den = EXIF_DEF_RESOLUTION_DEN; 3712 mExifInfo.resolution_unit = EXIF_DEF_RESOLUTION_UNIT; 3713} 3714 3715void ExynosCamera::m_setExifChangedAttribute(exif_attribute_t *exifInfo, ExynosRect *rect) 3716{ 3717 //2 0th IFD TIFF Tags 3718 //3 Width 3719 exifInfo->width = rect->w; 3720 //3 Height 3721 exifInfo->height = rect->h; 3722 //3 Orientation 3723 switch (m_curCameraInfo->rotation) { 3724 case 90: 3725 exifInfo->orientation = EXIF_ORIENTATION_90; 3726 break; 3727 case 180: 3728 exifInfo->orientation = EXIF_ORIENTATION_180; 3729 break; 3730 case 270: 3731 exifInfo->orientation = EXIF_ORIENTATION_270; 3732 break; 3733 case 0: 3734 default: 3735 exifInfo->orientation = EXIF_ORIENTATION_UP; 3736 break; 3737 } 3738 //3 Date time 3739 time_t rawtime; 3740 struct tm *timeinfo; 3741 time(&rawtime); 3742 timeinfo = localtime(&rawtime); 3743 strftime((char *)exifInfo->date_time, 20, "%Y:%m:%d %H:%M:%S", timeinfo); 3744 3745 //2 0th IFD Exif Private Tags 3746 //3 Exposure Time 3747 int shutterSpeed = 100; 3748 /* TBD - front camera needs to be fixed to support this g_ctrl, 3749 it current returns a negative err value, so avoid putting 3750 odd value into exif for now */ 3751 if ( exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_SHUTTERSPEED, &shutterSpeed) < 0 3752 || shutterSpeed < 0) { 3753 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using 100", __func__); 3754 shutterSpeed = 100; 3755 } 3756 3757 exifInfo->exposure_time.num = 1; 3758 // x us -> 1/x s */ 3759 exifInfo->exposure_time.den = (uint32_t)(1000000 / shutterSpeed); 3760 3761 //3 ISO Speed Rating 3762 int iso = m_curCameraInfo->iso; 3763 3764 /* TBD - front camera needs to be fixed to support this g_ctrl, 3765 it current returns a negative err value, so avoid putting 3766 odd value into exif for now */ 3767 if ( exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_ISO, &iso) < 0 3768 || iso < 0) { 3769 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail, using ISO_100", __func__); 3770 iso = ISO_100; 3771 } 3772 3773 switch (iso) { 3774 case ISO_50: 3775 exifInfo->iso_speed_rating = 50; 3776 break; 3777 case ISO_100: 3778 exifInfo->iso_speed_rating = 100; 3779 break; 3780 case ISO_200: 3781 exifInfo->iso_speed_rating = 200; 3782 break; 3783 case ISO_400: 3784 exifInfo->iso_speed_rating = 400; 3785 break; 3786 case ISO_800: 3787 exifInfo->iso_speed_rating = 800; 3788 break; 3789 case ISO_1600: 3790 exifInfo->iso_speed_rating = 1600; 3791 break; 3792 default: 3793 exifInfo->iso_speed_rating = 100; 3794 break; 3795 } 3796 3797 uint32_t av, tv, bv, sv, ev; 3798 av = APEX_FNUM_TO_APERTURE((double)exifInfo->fnumber.num / exifInfo->fnumber.den); 3799 tv = APEX_EXPOSURE_TO_SHUTTER((double)exifInfo->exposure_time.num / exifInfo->exposure_time.den); 3800 sv = APEX_ISO_TO_FILMSENSITIVITY(exifInfo->iso_speed_rating); 3801 bv = av + tv - sv; 3802 ev = av + tv; 3803 ALOGD("Shutter speed=%d us, iso=%d", shutterSpeed, exifInfo->iso_speed_rating); 3804 ALOGD("AV=%d, TV=%d, SV=%d", av, tv, sv); 3805 3806 //3 Shutter Speed 3807 exifInfo->shutter_speed.num = tv * EXIF_DEF_APEX_DEN; 3808 exifInfo->shutter_speed.den = EXIF_DEF_APEX_DEN; 3809 //3 Brightness 3810 exifInfo->brightness.num = bv*EXIF_DEF_APEX_DEN; 3811 exifInfo->brightness.den = EXIF_DEF_APEX_DEN; 3812 //3 Exposure Bias 3813 if (m_curCameraInfo->sceneMode == SCENE_MODE_BEACH || 3814 m_curCameraInfo->sceneMode == SCENE_MODE_SNOW) { 3815 exifInfo->exposure_bias.num = EXIF_DEF_APEX_DEN; 3816 exifInfo->exposure_bias.den = EXIF_DEF_APEX_DEN; 3817 } else { 3818 exifInfo->exposure_bias.num = 0; 3819 exifInfo->exposure_bias.den = 0; 3820 } 3821 //3 Metering Mode 3822 switch (m_curCameraInfo->metering) { 3823 case METERING_MODE_CENTER: 3824 exifInfo->metering_mode = EXIF_METERING_CENTER; 3825 break; 3826 case METERING_MODE_MATRIX: 3827 exifInfo->metering_mode = EXIF_METERING_MULTISPOT; 3828 break; 3829 case METERING_MODE_SPOT: 3830 exifInfo->metering_mode = EXIF_METERING_SPOT; 3831 break; 3832 case METERING_MODE_AVERAGE: 3833 default: 3834 exifInfo->metering_mode = EXIF_METERING_AVERAGE; 3835 break; 3836 } 3837 3838 //3 Flash 3839 int flash = EXIF_DEF_FLASH; 3840 if ( m_curCameraInfo->flashMode == FLASH_MODE_OFF 3841 || exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_EXIF_FLASH, &flash) < 0 3842 || flash < 0) 3843 exifInfo->flash = EXIF_DEF_FLASH; 3844 else 3845 exifInfo->flash = flash; 3846 3847 //3 White Balance 3848 if (m_curCameraInfo->whiteBalance == WHITE_BALANCE_AUTO) 3849 exifInfo->white_balance = EXIF_WB_AUTO; 3850 else 3851 exifInfo->white_balance = EXIF_WB_MANUAL; 3852 3853 //3 Scene Capture Type 3854 switch (m_curCameraInfo->sceneMode) { 3855 case SCENE_MODE_PORTRAIT: 3856 exifInfo->scene_capture_type = EXIF_SCENE_PORTRAIT; 3857 break; 3858 case SCENE_MODE_LANDSCAPE: 3859 exifInfo->scene_capture_type = EXIF_SCENE_LANDSCAPE; 3860 break; 3861 case SCENE_MODE_NIGHT: 3862 exifInfo->scene_capture_type = EXIF_SCENE_NIGHT; 3863 break; 3864 default: 3865 exifInfo->scene_capture_type = EXIF_SCENE_STANDARD; 3866 break; 3867 } 3868 3869 //2 0th IFD GPS Info Tags 3870 if (m_curCameraInfo->gpsLatitude != 0 && m_curCameraInfo->gpsLongitude != 0) { 3871 if (m_curCameraInfo->gpsLatitude > 0) 3872 strcpy((char *)exifInfo->gps_latitude_ref, "N"); 3873 else 3874 strcpy((char *)exifInfo->gps_latitude_ref, "S"); 3875 3876 if (m_curCameraInfo->gpsLongitude > 0) 3877 strcpy((char *)exifInfo->gps_longitude_ref, "E"); 3878 else 3879 strcpy((char *)exifInfo->gps_longitude_ref, "W"); 3880 3881 if (m_curCameraInfo->gpsAltitude > 0) 3882 exifInfo->gps_altitude_ref = 0; 3883 else 3884 exifInfo->gps_altitude_ref = 1; 3885 3886 double latitude = fabs(m_curCameraInfo->gpsLatitude / 10000.0); 3887 double longitude = fabs(m_curCameraInfo->gpsLongitude / 10000.0); 3888 double altitude = fabs(m_curCameraInfo->gpsAltitude / 100.0); 3889 3890 exifInfo->gps_latitude[0].num = (uint32_t)latitude; 3891 exifInfo->gps_latitude[0].den = 1; 3892 exifInfo->gps_latitude[1].num = (uint32_t)((latitude - exifInfo->gps_latitude[0].num) * 60); 3893 exifInfo->gps_latitude[1].den = 1; 3894 exifInfo->gps_latitude[2].num = (uint32_t)((((latitude - exifInfo->gps_latitude[0].num) * 60) 3895 - exifInfo->gps_latitude[1].num) * 60); 3896 exifInfo->gps_latitude[2].den = 1; 3897 3898 exifInfo->gps_longitude[0].num = (uint32_t)longitude; 3899 exifInfo->gps_longitude[0].den = 1; 3900 exifInfo->gps_longitude[1].num = (uint32_t)((longitude - exifInfo->gps_longitude[0].num) * 60); 3901 exifInfo->gps_longitude[1].den = 1; 3902 exifInfo->gps_longitude[2].num = (uint32_t)((((longitude - exifInfo->gps_longitude[0].num) * 60) 3903 - exifInfo->gps_longitude[1].num) * 60); 3904 exifInfo->gps_longitude[2].den = 1; 3905 3906 exifInfo->gps_altitude.num = (uint32_t)altitude; 3907 exifInfo->gps_altitude.den = 1; 3908 3909 struct tm tm_data; 3910 gmtime_r(&m_curCameraInfo->gpsTimestamp, &tm_data); 3911 exifInfo->gps_timestamp[0].num = tm_data.tm_hour; 3912 exifInfo->gps_timestamp[0].den = 1; 3913 exifInfo->gps_timestamp[1].num = tm_data.tm_min; 3914 exifInfo->gps_timestamp[1].den = 1; 3915 exifInfo->gps_timestamp[2].num = tm_data.tm_sec; 3916 exifInfo->gps_timestamp[2].den = 1; 3917 snprintf((char*)exifInfo->gps_datestamp, sizeof(exifInfo->gps_datestamp), 3918 "%04d:%02d:%02d", tm_data.tm_year + 1900, tm_data.tm_mon + 1, tm_data.tm_mday); 3919 3920 exifInfo->enableGps = true; 3921 } else { 3922 exifInfo->enableGps = false; 3923 } 3924 3925 //2 1th IFD TIFF Tags 3926 exifInfo->widthThumb = m_curCameraInfo->thumbnailW; 3927 exifInfo->heightThumb = m_curCameraInfo->thumbnailH; 3928} 3929 3930void ExynosCamera::m_secRect2SecRect2(ExynosRect *rect, ExynosRect2 *rect2) 3931{ 3932 rect2->x1 = rect->x; 3933 rect2->y1 = rect->y; 3934 rect2->x2 = rect->x + rect->w; 3935 rect2->y2 = rect->y + rect->h; 3936} 3937 3938void ExynosCamera::m_secRect22SecRect(ExynosRect2 *rect2, ExynosRect *rect) 3939{ 3940 rect->x = rect2->x1; 3941 rect->y = rect2->y1; 3942 rect->w = rect2->x2 - rect2->x1; 3943 rect->h = rect2->y2 - rect2->y1; 3944} 3945 3946void ExynosCamera::m_printFormat(int colorFormat, const char *arg) 3947{ 3948 switch (colorFormat) { 3949 case V4L2_PIX_FMT_YUV420: 3950 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUV420", arg); 3951 break; 3952 case V4L2_PIX_FMT_YVU420: 3953 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420", arg); 3954 break; 3955 case V4L2_PIX_FMT_YVU420M: 3956 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YVU420M", arg); 3957 break; 3958 case V4L2_PIX_FMT_NV12M: 3959 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12M", arg); 3960 break; 3961 case V4L2_PIX_FMT_NV12: 3962 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12", arg); 3963 break; 3964 case V4L2_PIX_FMT_NV12T: 3965 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV12T", arg); 3966 break; 3967 case V4L2_PIX_FMT_NV21: 3968 ALOGV("DEBUG(%s):V4L2_PIX_FMT_NV21", arg); 3969 break; 3970 case V4L2_PIX_FMT_YUV422P: 3971 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUV422PP", arg); 3972 break; 3973 case V4L2_PIX_FMT_YUYV: 3974 ALOGV("DEBUG(%s):V4L2_PIX_FMT_YUYV", arg); 3975 break; 3976 case V4L2_PIX_FMT_UYVY: 3977 ALOGV("DEBUG(%s):V4L2_PIX_FMT_UYVYI", arg); 3978 break; 3979 case V4L2_PIX_FMT_RGB565: 3980 ALOGV("DEBUG(%s):V4L2_PIX_FMT_RGB565", arg); 3981 break; 3982 default: 3983 ALOGV("DEBUG(%s):Unknown Format", arg); 3984 break; 3985 } 3986} 3987 3988/////////////////////////////////////////////////// 3989// Additional API. 3990/////////////////////////////////////////////////// 3991 3992bool ExynosCamera::setAngle(int angle) 3993{ 3994 if (m_curCameraInfo->angle != angle) { 3995 switch (angle) { 3996 case -360: 3997 case 0: 3998 case 360: 3999 m_curCameraInfo->angle = 0; 4000 break; 4001 4002 case -270: 4003 case 90: 4004 m_curCameraInfo->angle = 90; 4005 break; 4006 4007 case -180: 4008 case 180: 4009 m_curCameraInfo->angle = 180; 4010 break; 4011 4012 case -90: 4013 case 270: 4014 m_curCameraInfo->angle = 270; 4015 break; 4016 4017 default: 4018 ALOGE("ERR(%s):Invalid angle(%d)", __func__, angle); 4019 return false; 4020 } 4021 4022 if (m_flagCreate == true) { 4023 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_ROTATION, angle) < 0) { 4024 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4025 return false; 4026 } 4027 } 4028 } 4029 4030 return true; 4031} 4032 4033int ExynosCamera::getAngle(void) 4034{ 4035 return m_curCameraInfo->angle; 4036} 4037 4038bool ExynosCamera::setISO(int iso) 4039{ 4040 int internalValue = -1; 4041 4042 switch (iso) { 4043 case 50: 4044 internalValue = ISO_50; 4045 break; 4046 case 100: 4047 internalValue = ISO_100; 4048 break; 4049 case 200: 4050 internalValue = ISO_200; 4051 break; 4052 case 400: 4053 internalValue = ISO_400; 4054 break; 4055 case 800: 4056 internalValue = ISO_800; 4057 break; 4058 case 1600: 4059 internalValue = ISO_1600; 4060 break; 4061 case 0: 4062 default: 4063 internalValue = ISO_AUTO; 4064 break; 4065 } 4066 4067 if (internalValue < ISO_AUTO || ISO_MAX <= internalValue) { 4068 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4069 return false; 4070 } 4071 4072 if (m_curCameraInfo->iso != iso) { 4073 m_curCameraInfo->iso = iso; 4074 if (m_flagCreate == true) { 4075 if (m_internalISP == true) { 4076 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_ISO, internalValue) < 0) { 4077 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4078 return false; 4079 } 4080 } else { 4081 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ISO, internalValue) < 0) { 4082 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4083 return false; 4084 } 4085 } 4086 } 4087 } 4088 4089 return true; 4090} 4091 4092int ExynosCamera::getISO(void) 4093{ 4094 return m_curCameraInfo->iso; 4095} 4096 4097bool ExynosCamera::setContrast(int value) 4098{ 4099 int internalValue = -1; 4100 4101 switch (value) { 4102 case CONTRAST_AUTO: 4103 if (m_internalISP == true) 4104 internalValue = ::IS_CONTRAST_AUTO; 4105 else 4106 ALOGW("WARN(%s):Invalid contrast value (%d)", __func__, value); 4107 return true; 4108 break; 4109 case CONTRAST_MINUS_2: 4110 if (m_internalISP == true) 4111 internalValue = ::IS_CONTRAST_MINUS_2; 4112 else 4113 internalValue = ::CONTRAST_MINUS_2; 4114 break; 4115 case CONTRAST_MINUS_1: 4116 if (m_internalISP == true) 4117 internalValue = ::IS_CONTRAST_MINUS_1; 4118 else 4119 internalValue = ::CONTRAST_MINUS_1; 4120 break; 4121 case CONTRAST_DEFAULT: 4122 if (m_internalISP == true) 4123 internalValue = ::IS_CONTRAST_DEFAULT; 4124 else 4125 internalValue = ::CONTRAST_DEFAULT; 4126 break; 4127 case CONTRAST_PLUS_1: 4128 if (m_internalISP == true) 4129 internalValue = ::IS_CONTRAST_PLUS_1; 4130 else 4131 internalValue = ::CONTRAST_PLUS_1; 4132 break; 4133 case CONTRAST_PLUS_2: 4134 if (m_internalISP == true) 4135 internalValue = ::IS_CONTRAST_PLUS_2; 4136 else 4137 internalValue = ::CONTRAST_PLUS_2; 4138 break; 4139 default: 4140 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 4141 return false; 4142 break; 4143 } 4144 4145 if (m_internalISP == true) { 4146 if (internalValue < ::IS_CONTRAST_AUTO || ::IS_CONTRAST_MAX <= internalValue) { 4147 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4148 return false; 4149 } 4150 } else { 4151 if (internalValue < ::CONTRAST_MINUS_2 || ::CONTRAST_MAX <= internalValue) { 4152 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4153 return false; 4154 } 4155 } 4156 4157 if (m_curCameraInfo->contrast != value) { 4158 m_curCameraInfo->contrast = value; 4159 if (m_flagCreate == true) { 4160 if (m_internalISP == true) { 4161 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_CONTRAST, internalValue) < 0) { 4162 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4163 return false; 4164 } 4165 } else { 4166 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_CONTRAST, internalValue) < 0) { 4167 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4168 return false; 4169 } 4170 } 4171 } 4172 } 4173 4174 return true; 4175} 4176 4177int ExynosCamera::getContrast(void) 4178{ 4179 return m_curCameraInfo->contrast; 4180} 4181 4182bool ExynosCamera::setSaturation(int saturation) 4183{ 4184 int internalValue = saturation + SATURATION_DEFAULT; 4185 if (internalValue < SATURATION_MINUS_2 || SATURATION_MAX <= internalValue) { 4186 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4187 return false; 4188 } 4189 4190 if (m_curCameraInfo->saturation != saturation) { 4191 m_curCameraInfo->saturation = saturation; 4192 if (m_flagCreate == true) { 4193 if (m_internalISP == true) { 4194 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SATURATION, internalValue) < 0) { 4195 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4196 return false; 4197 } 4198 } else { 4199 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SATURATION, internalValue) < 0) { 4200 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4201 return false; 4202 } 4203 } 4204 } 4205 } 4206 4207 return true; 4208} 4209 4210int ExynosCamera::getSaturation(void) 4211{ 4212 return m_curCameraInfo->saturation; 4213} 4214 4215bool ExynosCamera::setSharpness(int sharpness) 4216{ 4217 int internalValue = sharpness + SHARPNESS_DEFAULT; 4218 if (internalValue < SHARPNESS_MINUS_2 || SHARPNESS_MAX <= internalValue) { 4219 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4220 return false; 4221 } 4222 4223 if (m_curCameraInfo->sharpness != sharpness) { 4224 m_curCameraInfo->sharpness = sharpness; 4225 if (m_flagCreate == true) { 4226 if (m_internalISP == true) { 4227 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SHARPNESS, internalValue) < 0) { 4228 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4229 return false; 4230 } 4231 } else { 4232 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SHARPNESS, internalValue) < 0) { 4233 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4234 return false; 4235 } 4236 } 4237 } 4238 } 4239 4240 return true; 4241} 4242 4243int ExynosCamera::getSharpness(void) 4244{ 4245 return m_curCameraInfo->sharpness; 4246} 4247 4248bool ExynosCamera::setHue(int hue) 4249{ 4250 int internalValue = hue; 4251 4252 if (m_internalISP == true) { 4253 internalValue += IS_HUE_DEFAULT; 4254 if (internalValue < IS_HUE_MINUS_2 || IS_HUE_MAX <= internalValue) { 4255 ALOGE("ERR(%s):Invalid hue (%d)", __func__, hue); 4256 return false; 4257 } 4258 } else { 4259 ALOGV("WARN(%s):Not supported hue setting", __func__); 4260 return true; 4261 } 4262 4263 if (m_curCameraInfo->hue != hue) { 4264 m_curCameraInfo->hue = hue; 4265 if (m_flagCreate == true) { 4266 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_HUE, internalValue) < 0) { 4267 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4268 return false; 4269 } 4270 } 4271 } 4272 4273 return true; 4274} 4275 4276int ExynosCamera::getHue(void) 4277{ 4278 return m_curCameraInfo->hue; 4279} 4280 4281bool ExynosCamera::setWDR(bool toggle) 4282{ 4283 int internalWdr; 4284 4285 if (toggle == true) { 4286 if (m_internalISP == true) 4287 internalWdr = IS_DRC_BYPASS_ENABLE; 4288 else 4289 internalWdr = IS_DRC_BYPASS_DISABLE; 4290 } else { 4291 if (m_internalISP == true) 4292 internalWdr = WDR_ON; 4293 else 4294 internalWdr = WDR_OFF; 4295 } 4296 4297 if (m_curCameraInfo->wdr != toggle) { 4298 m_curCameraInfo->wdr = toggle; 4299 if (m_flagCreate == true) { 4300 if (m_internalISP == true) { 4301 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_SET_DRC, internalWdr) < 0) { 4302 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4303 return false; 4304 } 4305 } else { 4306 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_WDR, internalWdr) < 0) { 4307 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4308 return false; 4309 } 4310 } 4311 } 4312 } 4313 4314 return true; 4315} 4316 4317bool ExynosCamera::getWDR(void) 4318{ 4319 return m_curCameraInfo->wdr; 4320} 4321 4322bool ExynosCamera::setAntiShake(bool toggle) 4323{ 4324 int internalValue = ANTI_SHAKE_OFF; 4325 4326 if (toggle == true) 4327 internalValue = ANTI_SHAKE_STILL_ON; 4328 4329 if (m_curCameraInfo->antiShake != toggle) { 4330 m_curCameraInfo->antiShake = toggle; 4331 if (m_flagCreate == true) { 4332 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_ANTI_SHAKE, internalValue) < 0) { 4333 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4334 return false; 4335 } 4336 } 4337 } 4338 4339 return true; 4340} 4341 4342bool ExynosCamera::getAntiShake(void) 4343{ 4344 return m_curCameraInfo->antiShake; 4345} 4346 4347bool ExynosCamera::setMeteringMode(int value) 4348{ 4349 int internalValue = -1; 4350 4351 switch (value) { 4352 case METERING_MODE_AVERAGE: 4353 if (m_internalISP == true) 4354 internalValue = IS_METERING_AVERAGE; 4355 else 4356 internalValue = METERING_MATRIX; 4357 break; 4358 case METERING_MODE_MATRIX: 4359 if (m_internalISP == true) 4360 internalValue = IS_METERING_MATRIX; 4361 else 4362 internalValue = METERING_MATRIX; 4363 break; 4364 case METERING_MODE_CENTER: 4365 if (m_internalISP == true) 4366 internalValue = IS_METERING_CENTER; 4367 else 4368 internalValue = METERING_CENTER; 4369 break; 4370 case METERING_MODE_SPOT: 4371 if (m_internalISP == true) 4372 internalValue = IS_METERING_SPOT; 4373 else 4374 internalValue = METERING_SPOT; 4375 break; 4376 default: 4377 ALOGE("ERR(%s):Unsupported value(%d)", __func__, value); 4378 return false; 4379 break; 4380 } 4381 4382 if (m_internalISP == true) { 4383 if (internalValue < IS_METERING_AVERAGE || IS_METERING_MAX <= internalValue) { 4384 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4385 return false; 4386 } 4387 } else { 4388 if (internalValue <= METERING_BASE || METERING_MAX <= internalValue) { 4389 ALOGE("ERR(%s):Invalid internalValue (%d)", __func__, internalValue); 4390 return false; 4391 } 4392 } 4393 4394 if (m_curCameraInfo->metering != value) { 4395 m_curCameraInfo->metering = value; 4396 if (m_flagCreate == true) { 4397 if (m_internalISP == true) { 4398 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_METERING, internalValue) < 0) { 4399 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4400 return false; 4401 } 4402 } else { 4403 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_METERING, internalValue) < 0) { 4404 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4405 return false; 4406 } 4407 } 4408 } 4409 } 4410 4411 return true; 4412} 4413 4414int ExynosCamera::getMeteringMode(void) 4415{ 4416 return m_curCameraInfo->metering; 4417} 4418 4419bool ExynosCamera::setObjectTracking(bool toggle) 4420{ 4421 m_curCameraInfo->objectTracking = toggle; 4422 return true; 4423} 4424 4425bool ExynosCamera::getObjectTracking(void) 4426{ 4427 return m_curCameraInfo->objectTracking; 4428} 4429 4430bool ExynosCamera::setObjectTrackingStart(bool toggle) 4431{ 4432 if (m_curCameraInfo->objectTrackingStart != toggle) { 4433 m_curCameraInfo->objectTrackingStart = toggle; 4434 4435 int startStop = (toggle == true) ? 1 : 0; 4436 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJ_TRACKING_START_STOP, startStop) < 0) { 4437 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4438 return false; 4439 } 4440 } 4441 4442 return true; 4443} 4444 4445int ExynosCamera::getObjectTrackingStatus(void) 4446{ 4447 int ret = 0; 4448 4449 if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_OBJ_TRACKING_STATUS, &ret) < 0) { 4450 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__); 4451 return -1; 4452 } 4453 return ret; 4454} 4455 4456bool ExynosCamera::setObjectPosition(int x, int y) 4457{ 4458 if (m_curCameraInfo->previewW == 640) 4459 x = x - 80; 4460 4461 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_OBJECT_POSITION_X, x) < 0) { 4462 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4463 return false; 4464 } 4465 4466 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_OBJECT_POSITION_Y, y) < 0) { 4467 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4468 return false; 4469 } 4470 4471 return true; 4472} 4473 4474bool ExynosCamera::setTouchAFStart(bool toggle) 4475{ 4476 if (m_curCameraInfo->touchAfStart != toggle) { 4477 m_curCameraInfo->touchAfStart = toggle; 4478 int startStop = (toggle == true) ? 1 : 0; 4479 4480 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_TOUCH_AF_START_STOP, startStop) < 0) { 4481 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4482 return false; 4483 } 4484 } 4485 4486 return true; 4487} 4488 4489bool ExynosCamera::setSmartAuto(bool toggle) 4490{ 4491 if (m_curCameraInfo->smartAuto != toggle) { 4492 m_curCameraInfo->smartAuto = toggle; 4493 4494 int smartAuto = (toggle == true) ? SMART_AUTO_ON : SMART_AUTO_OFF; 4495 4496 if (m_flagCreate == true) { 4497 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SMART_AUTO, smartAuto) < 0) { 4498 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4499 return false; 4500 } 4501 } 4502 } 4503 4504 return true; 4505} 4506 4507bool ExynosCamera::getSmartAuto(void) 4508{ 4509 return m_curCameraInfo->smartAuto; 4510} 4511 4512int ExynosCamera::getSmartAutoStatus(void) 4513{ 4514 int autoscene_status = -1; 4515 4516 if (m_curCameraInfo->smartAuto == true) { 4517 if (exynos_v4l2_g_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SMART_AUTO_STATUS, &autoscene_status) < 0) { 4518 ALOGE("ERR(%s):exynos_v4l2_g_ctrl() fail", __func__); 4519 return -1; 4520 } 4521 4522 if ((autoscene_status < SMART_AUTO_STATUS_AUTO) || (autoscene_status > SMART_AUTO_STATUS_MAX)) { 4523 ALOGE("ERR(%s):Invalid getSmartAutoStatus (%d)", __func__, autoscene_status); 4524 return -1; 4525 } 4526 } 4527 return autoscene_status; 4528} 4529 4530bool ExynosCamera::setBeautyShot(bool toggle) 4531{ 4532 if (m_curCameraInfo->beautyShot != toggle) { 4533 m_curCameraInfo->beautyShot = toggle; 4534 int beautyShot = (toggle == true) ? BEAUTY_SHOT_ON : BEAUTY_SHOT_OFF; 4535 4536 if (m_flagCreate == true) { 4537 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_BEAUTY_SHOT, beautyShot) < 0) { 4538 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4539 return false; 4540 } 4541 } 4542 } 4543 4544 return true; 4545} 4546 4547bool ExynosCamera::getBeautyShot(void) 4548{ 4549 return m_curCameraInfo->beautyShot; 4550} 4551 4552bool ExynosCamera::setTopDownMirror(void) 4553{ 4554 if (m_previewDev->fd <= 0) { 4555 ALOGE("ERR(%s):Camera was closed", __func__); 4556 return false; 4557 } 4558 4559 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_VFLIP, 1) < 0) { 4560 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4561 return false; 4562 } 4563 4564 return true; 4565} 4566 4567bool ExynosCamera::setLRMirror(void) 4568{ 4569 if (m_previewDev->fd <= 0) { 4570 ALOGE("ERR(%s):Camera was closed", __func__); 4571 return false; 4572 } 4573 4574 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_HFLIP, 1) < 0) { 4575 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4576 return false; 4577 } 4578 4579 return true; 4580} 4581 4582bool ExynosCamera::setBrightness(int brightness) 4583{ 4584 int internalValue = brightness; 4585 4586 if (m_internalISP == true) { 4587 internalValue += IS_BRIGHTNESS_DEFAULT; 4588 if (internalValue < IS_BRIGHTNESS_MINUS_2 || IS_BRIGHTNESS_PLUS_2 < internalValue) { 4589 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 4590 return false; 4591 } 4592 } else { 4593 internalValue += EV_DEFAULT; 4594 if (internalValue < EV_MINUS_4 || EV_PLUS_4 < internalValue) { 4595 ALOGE("ERR(%s):Invalid internalValue(%d)", __func__, internalValue); 4596 return false; 4597 } 4598 } 4599 4600 if (m_curCameraInfo->brightness != brightness) { 4601 m_curCameraInfo->brightness = brightness; 4602 if (m_flagCreate == true) { 4603 if (m_internalISP == true) { 4604 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_BRIGHTNESS, internalValue) < 0) { 4605 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4606 return false; 4607 } 4608 } else { 4609 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_BRIGHTNESS, internalValue) < 0) { 4610 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4611 return false; 4612 } 4613 } 4614 } 4615 } 4616 4617 return true; 4618} 4619 4620int ExynosCamera::getBrightness(void) 4621{ 4622 return m_curCameraInfo->brightness; 4623} 4624 4625bool ExynosCamera::setGamma(bool toggle) 4626{ 4627 if (m_curCameraInfo->gamma != toggle) { 4628 m_curCameraInfo->gamma = toggle; 4629 4630 int gamma = (toggle == true) ? GAMMA_ON : GAMMA_OFF; 4631 4632 if (m_flagCreate == true) { 4633 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_GAMMA, gamma) < 0) { 4634 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4635 return false; 4636 } 4637 } 4638 } 4639 4640 return true; 4641} 4642 4643bool ExynosCamera::getGamma(void) 4644{ 4645 return m_curCameraInfo->gamma; 4646} 4647 4648bool ExynosCamera::setODC(bool toggle) 4649{ 4650 if (m_previewDev->flagStart == true) { 4651 if (m_curCameraInfo->odc != toggle) { 4652 m_curCameraInfo->odc = toggle; 4653 4654 int odc = (toggle == true) ? CAMERA_ODC_ON : CAMERA_ODC_OFF; 4655 4656 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_ODC, odc) < 0) { 4657 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4658 return false; 4659 } 4660 } 4661 } 4662 4663 return true; 4664} 4665 4666bool ExynosCamera::getODC(void) 4667{ 4668 return m_curCameraInfo->odc; 4669} 4670 4671bool ExynosCamera::setSlowAE(bool toggle) 4672{ 4673 if (m_curCameraInfo->slowAE != toggle) { 4674 m_curCameraInfo->slowAE = toggle; 4675 4676 int slow_ae = (toggle == true) ? SLOW_AE_ON : SLOW_AE_OFF; 4677 4678 if (m_flagCreate == true) { 4679 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_SLOW_AE, slow_ae) < 0) { 4680 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4681 return false; 4682 } 4683 } 4684 } 4685 4686 return true; 4687} 4688 4689bool ExynosCamera::getSlowAE(void) 4690{ 4691 return m_curCameraInfo->slowAE; 4692} 4693 4694bool ExynosCamera::setShotMode(int shotMode) 4695{ 4696 if (shotMode < SHOT_MODE_SINGLE || SHOT_MODE_SELF < shotMode) { 4697 ALOGE("ERR(%s):Invalid shotMode (%d)", __func__, shotMode); 4698 return false; 4699 } 4700 4701 if (m_curCameraInfo->shotMode != shotMode) { 4702 m_curCameraInfo->shotMode = shotMode; 4703 4704 if (m_flagCreate == true) { 4705 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_IS_CAMERA_SHOT_MODE_NORMAL, shotMode) < 0) { 4706 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4707 return false; 4708 } 4709 } 4710 } 4711 4712 return true; 4713} 4714 4715int ExynosCamera::getShotMode(void) 4716{ 4717 return m_curCameraInfo->shotMode; 4718} 4719 4720bool ExynosCamera::set3DNR(bool toggle) 4721{ 4722 if (m_previewDev->flagStart == true) { 4723 if (m_curCameraInfo->tdnr != toggle) { 4724 m_curCameraInfo->tdnr = toggle; 4725 4726 int tdnr = (toggle == true) ? CAMERA_3DNR_ON : CAMERA_3DNR_OFF; 4727 4728 if (exynos_v4l2_s_ctrl(m_previewDev->fd, V4L2_CID_CAMERA_SET_3DNR, tdnr) < 0) { 4729 ALOGE("ERR(%s):exynos_v4l2_s_ctrl() fail", __func__); 4730 return false; 4731 } 4732 } 4733 } 4734 4735 return true; 4736} 4737 4738bool ExynosCamera::get3DNR(void) 4739{ 4740 return m_curCameraInfo->tdnr; 4741} 4742 4743}; // namespace android 4744