1 /* 2 ** 3 ** Copyright 2008, The Android Open Source Project 4 ** Copyright 2010, Samsung Electronics Co. LTD 5 ** 6 ** Licensed under the Apache License, Version 2.0 (the "License"); 7 ** you may not use this file except in compliance with the License. 8 ** You may obtain a copy of the License at 9 ** 10 ** http://www.apache.org/licenses/LICENSE-2.0 11 ** 12 ** Unless required by applicable law or agreed to in writing, software 13 ** distributed under the License is distributed on an "AS IS" BASIS, 14 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 ** See the License for the specific language governing permissions and 16 ** limitations under the License. 17 */ 18 19 //#define LOG_NDEBUG 0 20 #define LOG_TAG "CameraHardwareSec" 21 #include <utils/Log.h> 22 23 #include "SecCameraHWInterface.h" 24 #include <utils/threads.h> 25 #include <fcntl.h> 26 #include <sys/mman.h> 27 28 #if defined(BOARD_USES_OVERLAY) 29 #include <hardware/overlay.h> 30 #include <ui/Overlay.h> 31 #define CACHEABLE_BUFFERS 0x1 32 #define ALL_BUFFERS_FLUSHED -66 33 #endif 34 35 #ifdef SEND_YUV_RECORD_DATA 36 #define ALIGN_TO_32B(x) ((((x) + (1 << 5) - 1) >> 5) << 5) 37 #define ALIGN_TO_128B(x) ((((x) + (1 << 7) - 1) >> 7) << 7) 38 #define ALIGN_TO_8KB(x) ((((x) + (1 << 13) - 1) >> 13) << 13) 39 #define RECORD_HEAP_SIZE (ALIGN_TO_8KB(ALIGN_TO_128B(1280) * \ 40 ALIGN_TO_32B(720)) + ALIGN_TO_8KB(ALIGN_TO_128B(1280) * \ 41 ALIGN_TO_32B(720 / 2))) 42 #endif 43 44 #define VIDEO_COMMENT_MARKER_H 0xFFBE 45 #define VIDEO_COMMENT_MARKER_L 0xFFBF 46 #define VIDEO_COMMENT_MARKER_LENGTH 4 47 #define JPEG_EOI_MARKER 0xFFD9 48 #define HIBYTE(x) (((x) >> 8) & 0xFF) 49 #define LOBYTE(x) ((x) & 0xFF) 50 51 #define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR "0.10,1.20,Infinity" 52 #define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR "0.10,0.20,Infinity" 53 #define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR "0.10,1.20,Infinity" 54 #define FRONT_CAMERA_FOCUS_DISTANCES_STR "0.20,0.25,Infinity" 55 56 namespace android { 57 58 struct addrs { 59 unsigned int addr_y; 60 unsigned int addr_cbcr; 61 unsigned int buf_index; 62 unsigned int reserved; 63 }; 64 65 struct addrs_cap { 66 unsigned int addr_y; 67 unsigned int width; 68 unsigned int height; 69 }; 70 71 static const int INITIAL_SKIP_FRAME = 3; 72 static const int EFFECT_SKIP_FRAME = 1; 73 74 CameraHardwareSec::CameraHardwareSec(int cameraId) 75 : 76 mPreviewRunning(false), 77 mCaptureInProgress(false), 78 mParameters(), 79 mPreviewHeap(0), 80 mRawHeap(0), 81 mRecordHeap(0), 82 mJpegHeap(0), 83 mSecCamera(NULL), 84 mPreviewFrameSize(0), 85 mRawFrameSize(0), 86 mPreviewFrameRateMicrosec(33000), 87 mCameraSensorName(NULL), 88 mSkipFrame(0), 89 #if defined(BOARD_USES_OVERLAY) 90 mUseOverlay(false), 91 mOverlayBufferIdx(0), 92 #endif 93 mNotifyCb(0), 94 mDataCb(0), 95 mDataCbTimestamp(0), 96 mCallbackCookie(0), 97 mMsgEnabled(0), 98 mCurrentPreviewFrame(0), 99 mRecordRunning(false) 100 #ifdef JPEG_FROM_SENSOR 101 , 102 mPostViewWidth(0), 103 mPostViewHeight(0), 104 mPostViewSize(0) 105 #endif 106 { 107 LOGV("%s :", __func__); 108 int ret = 0; 109 110 mSecCamera = SecCamera::createInstance(); 111 112 if (mSecCamera == NULL) { 113 LOGE("ERR(%s):Fail on mSecCamera object creation", __func__); 114 } 115 116 ret = mSecCamera->initCamera(cameraId); 117 if (ret < 0) { 118 LOGE("ERR(%s):Fail on mSecCamera init", __func__); 119 } 120 121 if (mSecCamera->flagCreate() == 0) { 122 LOGE("ERR(%s):Fail on mSecCamera->flagCreate()", __func__); 123 } 124 125 #ifndef PREVIEW_USING_MMAP 126 int previewHeapSize = sizeof(struct addrs) * kBufferCount; 127 128 LOGV("mPreviewHeap : MemoryHeapBase(previewHeapSize(%d))", previewHeapSize); 129 mPreviewHeap = new MemoryHeapBase(previewHeapSize); 130 if (mPreviewHeap->getHeapID() < 0) { 131 LOGE("ERR(%s): Preview heap creation fail", __func__); 132 mPreviewHeap.clear(); 133 } 134 #endif 135 136 #ifdef SEND_YUV_RECORD_DATA 137 int recordHeapSize = RECORD_HEAP_SIZE; 138 #else 139 int recordHeapSize = sizeof(struct addrs) * kBufferCount; 140 #endif 141 LOGV("mRecordHeap : MemoryHeapBase(recordHeapSize(%d))", recordHeapSize); 142 mRecordHeap = new MemoryHeapBase(recordHeapSize); 143 if (mRecordHeap->getHeapID() < 0) { 144 LOGE("ERR(%s): Record heap creation fail", __func__); 145 mRecordHeap.clear(); 146 } 147 148 #ifdef JPEG_FROM_SENSOR 149 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); 150 LOGV("mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d", 151 mPostViewWidth,mPostViewHeight,mPostViewSize); 152 #endif 153 154 #ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA 155 int rawHeapSize = mPostViewSize; 156 #else 157 int rawHeapSize = sizeof(struct addrs_cap); 158 #endif 159 LOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize); 160 mRawHeap = new MemoryHeapBase(rawHeapSize); 161 if (mRawHeap->getHeapID() < 0) { 162 LOGE("ERR(%s): Raw heap creation fail", __func__); 163 mRawHeap.clear(); 164 } 165 166 initDefaultParameters(cameraId); 167 168 mExitAutoFocusThread = false; 169 mPreviewThread = new PreviewThread(this); 170 mAutoFocusThread = new AutoFocusThread(this); 171 mPictureThread = new PictureThread(this); 172 } 173 174 void CameraHardwareSec::initDefaultParameters(int cameraId) 175 { 176 if (mSecCamera == NULL) { 177 LOGE("ERR(%s):mSecCamera object is NULL", __func__); 178 return; 179 } 180 181 CameraParameters p; 182 CameraParameters ip; 183 184 mCameraSensorName = mSecCamera->getCameraSensorName(); 185 LOGV("CameraSensorName: %s", mCameraSensorName); 186 187 int preview_max_width = 0; 188 int preview_max_height = 0; 189 int snapshot_max_width = 0; 190 int snapshot_max_height = 0; 191 192 /* set camera ID & reset camera */ 193 mSecCamera->setCameraId(cameraId); 194 if (cameraId == SecCamera::CAMERA_ID_BACK) { 195 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 196 "720x480,640x480,352x288,176x144"); 197 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 198 "2560x1920,2048x1536,1600x1200,1280x960,640x480"); 199 } else { 200 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 201 "640x480"); 202 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 203 "640x480"); 204 } 205 206 // If these fail, then we are using an invalid cameraId and we'll leave the 207 // sizes at zero to catch the error. 208 if (mSecCamera->getPreviewMaxSize(&preview_max_width, 209 &preview_max_height) < 0) 210 LOGE("getPreviewMaxSize fail (%d / %d) \n", 211 preview_max_width, preview_max_height); 212 if (mSecCamera->getSnapshotMaxSize(&snapshot_max_width, 213 &snapshot_max_height) < 0) 214 LOGE("getSnapshotMaxSize fail (%d / %d) \n", 215 snapshot_max_width, snapshot_max_height); 216 217 #ifdef PREVIEW_USING_MMAP 218 p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP); 219 #else 220 p.setPreviewFormat("yuv420sp_custom"); 221 #endif 222 p.setPreviewSize(preview_max_width, preview_max_height); 223 224 p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 225 p.setPictureSize(snapshot_max_width, snapshot_max_height); 226 p.set(CameraParameters::KEY_JPEG_QUALITY, "100"); // maximum quality 227 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION 228 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, 229 CameraParameters::PIXEL_FORMAT_YUV420SP); 230 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 231 CameraParameters::PIXEL_FORMAT_JPEG); 232 p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, 233 CameraParameters::PIXEL_FORMAT_YUV420SP); 234 235 String8 parameterString; 236 237 if (cameraId == SecCamera::CAMERA_ID_BACK) { 238 parameterString = CameraParameters::FOCUS_MODE_AUTO; 239 parameterString.append(","); 240 parameterString.append(CameraParameters::FOCUS_MODE_INFINITY); 241 parameterString.append(","); 242 parameterString.append(CameraParameters::FOCUS_MODE_MACRO); 243 p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 244 parameterString.string()); 245 p.set(CameraParameters::KEY_FOCUS_MODE, 246 CameraParameters::FOCUS_MODE_AUTO); 247 p.set(CameraParameters::KEY_FOCUS_DISTANCES, 248 BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR); 249 p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 250 "320x240,0x0"); 251 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "320"); 252 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "240"); 253 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "30"); 254 p.setPreviewFrameRate(30); 255 } else { 256 parameterString = CameraParameters::FOCUS_MODE_FIXED; 257 p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 258 parameterString.string()); 259 p.set(CameraParameters::KEY_FOCUS_MODE, 260 CameraParameters::FOCUS_MODE_FIXED); 261 p.set(CameraParameters::KEY_FOCUS_DISTANCES, 262 FRONT_CAMERA_FOCUS_DISTANCES_STR); 263 p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 264 "160x120,0x0"); 265 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160"); 266 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120"); 267 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "15"); 268 p.setPreviewFrameRate(15); 269 } 270 271 parameterString = CameraParameters::EFFECT_NONE; 272 parameterString.append(","); 273 parameterString.append(CameraParameters::EFFECT_MONO); 274 parameterString.append(","); 275 parameterString.append(CameraParameters::EFFECT_NEGATIVE); 276 parameterString.append(","); 277 parameterString.append(CameraParameters::EFFECT_SEPIA); 278 p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, parameterString.string()); 279 280 if (cameraId == SecCamera::CAMERA_ID_BACK) { 281 parameterString = CameraParameters::FLASH_MODE_ON; 282 parameterString.append(","); 283 parameterString.append(CameraParameters::FLASH_MODE_OFF); 284 parameterString.append(","); 285 parameterString.append(CameraParameters::FLASH_MODE_AUTO); 286 parameterString.append(","); 287 parameterString.append(CameraParameters::FLASH_MODE_TORCH); 288 p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 289 parameterString.string()); 290 p.set(CameraParameters::KEY_FLASH_MODE, 291 CameraParameters::FLASH_MODE_OFF); 292 293 parameterString = CameraParameters::SCENE_MODE_AUTO; 294 parameterString.append(","); 295 parameterString.append(CameraParameters::SCENE_MODE_PORTRAIT); 296 parameterString.append(","); 297 parameterString.append(CameraParameters::SCENE_MODE_LANDSCAPE); 298 parameterString.append(","); 299 parameterString.append(CameraParameters::SCENE_MODE_NIGHT); 300 parameterString.append(","); 301 parameterString.append(CameraParameters::SCENE_MODE_BEACH); 302 parameterString.append(","); 303 parameterString.append(CameraParameters::SCENE_MODE_SNOW); 304 parameterString.append(","); 305 parameterString.append(CameraParameters::SCENE_MODE_SUNSET); 306 parameterString.append(","); 307 parameterString.append(CameraParameters::SCENE_MODE_FIREWORKS); 308 parameterString.append(","); 309 parameterString.append(CameraParameters::SCENE_MODE_SPORTS); 310 parameterString.append(","); 311 parameterString.append(CameraParameters::SCENE_MODE_PARTY); 312 parameterString.append(","); 313 parameterString.append(CameraParameters::SCENE_MODE_CANDLELIGHT); 314 p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 315 parameterString.string()); 316 p.set(CameraParameters::KEY_SCENE_MODE, 317 CameraParameters::SCENE_MODE_AUTO); 318 319 /* we have two ranges, 4-30fps for night mode and 320 * 15-30fps for all others 321 */ 322 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)"); 323 p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000"); 324 325 p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.43"); 326 } else { 327 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(7500,30000)"); 328 p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000"); 329 330 p.set(CameraParameters::KEY_FOCAL_LENGTH, "0.9"); 331 } 332 333 parameterString = CameraParameters::WHITE_BALANCE_AUTO; 334 parameterString.append(","); 335 parameterString.append(CameraParameters::WHITE_BALANCE_INCANDESCENT); 336 parameterString.append(","); 337 parameterString.append(CameraParameters::WHITE_BALANCE_FLUORESCENT); 338 parameterString.append(","); 339 parameterString.append(CameraParameters::WHITE_BALANCE_DAYLIGHT); 340 parameterString.append(","); 341 parameterString.append(CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT); 342 p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 343 parameterString.string()); 344 345 ip.set("sharpness-min", 0); 346 ip.set("sharpness-max", 4); 347 ip.set("saturation-min", 0); 348 ip.set("saturation-max", 4); 349 ip.set("contrast-min", 0); 350 ip.set("contrast-max", 4); 351 #endif 352 353 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100"); 354 355 p.set(CameraParameters::KEY_ROTATION, 0); 356 p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO); 357 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION 358 p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE); 359 360 ip.set("sharpness", SHARPNESS_DEFAULT); 361 ip.set("contrast", CONTRAST_DEFAULT); 362 ip.set("saturation", SATURATION_DEFAULT); 363 ip.set("iso", "auto"); 364 ip.set("metering", "center"); 365 366 ip.set("wdr", 0); 367 ip.set("chk_dataline", 0); 368 if (cameraId == SecCamera::CAMERA_ID_FRONT) { 369 ip.set("vtmode", 0); 370 ip.set("blur", 0); 371 } 372 #else 373 ip.set("image-effects", "original"); 374 #endif 375 376 377 p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2"); 378 p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4"); 379 380 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0"); 381 p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "4"); 382 p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-4"); 383 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5"); 384 385 mParameters = p; 386 mInternalParameters = ip; 387 388 /* make sure mSecCamera has all the settings we do. applications 389 * aren't required to call setParameters themselves (only if they 390 * want to change something. 391 */ 392 setParameters(p); 393 mSecCamera->setISO(ISO_AUTO); 394 mSecCamera->setMetering(METERING_CENTER); 395 mSecCamera->setContrast(CONTRAST_DEFAULT); 396 mSecCamera->setSharpness(SHARPNESS_DEFAULT); 397 mSecCamera->setSaturation(SATURATION_DEFAULT); 398 if (cameraId == SecCamera::CAMERA_ID_BACK) 399 mSecCamera->setFrameRate(30); 400 else 401 mSecCamera->setFrameRate(15); 402 } 403 404 CameraHardwareSec::~CameraHardwareSec() 405 { 406 LOGV("%s :", __func__); 407 408 singleton.clear(); 409 } 410 411 sp<IMemoryHeap> CameraHardwareSec::getPreviewHeap() const 412 { 413 return mPreviewHeap; 414 } 415 416 sp<IMemoryHeap> CameraHardwareSec::getRawHeap() const 417 { 418 return mRawHeap; 419 } 420 421 void CameraHardwareSec::setCallbacks(notify_callback notify_cb, 422 data_callback data_cb, 423 data_callback_timestamp data_cb_timestamp, 424 void *user) 425 { 426 mNotifyCb = notify_cb; 427 mDataCb = data_cb; 428 mDataCbTimestamp = data_cb_timestamp; 429 mCallbackCookie = user; 430 } 431 432 void CameraHardwareSec::enableMsgType(int32_t msgType) 433 { 434 LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x", 435 __func__, msgType, mMsgEnabled); 436 mMsgEnabled |= msgType; 437 LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); 438 } 439 440 void CameraHardwareSec::disableMsgType(int32_t msgType) 441 { 442 LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x", 443 __func__, msgType, mMsgEnabled); 444 mMsgEnabled &= ~msgType; 445 LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); 446 } 447 448 bool CameraHardwareSec::msgTypeEnabled(int32_t msgType) 449 { 450 return (mMsgEnabled & msgType); 451 } 452 453 // --------------------------------------------------------------------------- 454 void CameraHardwareSec::setSkipFrame(int frame) 455 { 456 Mutex::Autolock lock(mSkipFrameLock); 457 if (frame < mSkipFrame) 458 return; 459 460 mSkipFrame = frame; 461 } 462 463 int CameraHardwareSec::previewThread() 464 { 465 int index; 466 467 index = mSecCamera->getPreview(); 468 if (index < 0) { 469 LOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__); 470 return UNKNOWN_ERROR; 471 } 472 mSkipFrameLock.lock(); 473 if (mSkipFrame > 0) { 474 mSkipFrame--; 475 mSkipFrameLock.unlock(); 476 return NO_ERROR; 477 } 478 mSkipFrameLock.unlock(); 479 480 nsecs_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 481 482 #ifdef PREVIEW_USING_MMAP 483 int width, height, frame_size, offset; 484 485 mSecCamera->getPreviewSize(&width, &height, &frame_size); 486 487 offset = (frame_size + 16) * index; 488 sp<MemoryBase> buffer = new MemoryBase(mPreviewHeap, offset, frame_size); 489 490 unsigned int phyYAddr = mSecCamera->getPhyAddrY(index); 491 unsigned int phyCAddr = mSecCamera->getPhyAddrC(index); 492 493 if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) { 494 LOGE("ERR(%s):Fail on SecCamera. Invalid PhyAddr, Y addr = %0x C addr = %0x", 495 __func__, phyYAddr, phyCAddr); 496 return UNKNOWN_ERROR; 497 } 498 memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size ), &phyYAddr, 4); 499 memcpy(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size + 4), &phyCAddr, 4); 500 501 #if defined(BOARD_USES_OVERLAY) 502 if (mUseOverlay) { 503 int ret; 504 mOverlayBufferIdx ^= 1; 505 memcpy(static_cast<unsigned char*>(mPreviewHeap->base()) + offset + frame_size + sizeof(phyYAddr) + sizeof(phyCAddr), 506 &mOverlayBufferIdx, sizeof(mOverlayBufferIdx)); 507 508 ret = mOverlay->queueBuffer((void*)(static_cast<unsigned char *>(mPreviewHeap->base()) + (offset + frame_size))); 509 510 if (ret == ALL_BUFFERS_FLUSHED) { 511 goto OverlayEnd; 512 } else if (ret == -1) { 513 LOGE("ERR(%s):overlay queueBuffer fail", __func__); 514 goto OverlayEnd; 515 } 516 517 overlay_buffer_t overlay_buffer; 518 ret = mOverlay->dequeueBuffer(&overlay_buffer); 519 520 if (ret == ALL_BUFFERS_FLUSHED) { 521 goto OverlayEnd; 522 } else if (ret == -1) { 523 LOGE("ERR(%s):overlay dequeueBuffer fail", __func__); 524 goto OverlayEnd; 525 } 526 } 527 528 OverlayEnd: 529 #endif 530 531 #else 532 unsigned int phyYAddr = mSecCamera->getPhyAddrY(index); 533 unsigned int phyCAddr = mSecCamera->getPhyAddrC(index); 534 535 if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) { 536 LOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr); 537 return UNKNOWN_ERROR; 538 } 539 struct addrs *addrs = (struct addrs *)mPreviewHeap->base(); 540 541 sp<MemoryBase> buffer = new MemoryBase(mPreviewHeap, index * sizeof(struct addrs), sizeof(struct addrs)); 542 addrs[index].addr_y = phyYAddr; 543 addrs[index].addr_cbcr = phyCAddr; 544 #endif //PREVIEW_USING_MMAP 545 546 // Notify the client of a new frame. 547 if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) { 548 mDataCb(CAMERA_MSG_PREVIEW_FRAME, buffer, mCallbackCookie); 549 } 550 551 if (mRecordRunning == true) { 552 #ifdef SEND_YUV_RECORD_DATA 553 int width, height, frame_size; 554 unsigned char *virYAddr; 555 unsigned char *virCAddr; 556 557 mSecCamera->getPreviewSize(&width, &height, &frame_size); 558 mSecCamera->getYUVBuffers(&virYAddr, &virCAddr, index); 559 sp<MemoryBase> buffer = new MemoryBase(mRecordHeap, 0, frame_size); 560 //memcpy(mRecordHeap->base(), (void*)virYAddr, width * height); 561 //memcpy(mRecordHeap->base() + (width*height),(void*)virCAddr, width * height * 0.5); 562 memcpy(mRecordHeap->base(), (void*)virYAddr, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height))); 563 memcpy(mRecordHeap->base() + ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height)), 564 (void*)virCAddr, ALIGN_TO_8KB(ALIGN_TO_128B(width) * ALIGN_TO_32B(height / 2))); 565 #else 566 #ifdef DUAL_PORT_RECORDING 567 int index = mSecCamera->getRecord(); 568 569 if (index < 0) { 570 LOGE("ERR(%s):Fail on SecCamera->getRecord()", __func__); 571 return UNKNOWN_ERROR; 572 } 573 574 unsigned int phyYAddr = mSecCamera->getRecPhyAddrY(index); 575 unsigned int phyCAddr = mSecCamera->getRecPhyAddrC(index); 576 577 if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) { 578 LOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __func__, phyYAddr, phyCAddr); 579 return UNKNOWN_ERROR; 580 } 581 #endif//DUAL_PORT_RECORDING 582 struct addrs *addrs = (struct addrs *)mRecordHeap->base(); 583 584 sp<MemoryBase> buffer = new MemoryBase(mRecordHeap, index * sizeof(struct addrs), sizeof(struct addrs)); 585 addrs[index].addr_y = phyYAddr; 586 addrs[index].addr_cbcr = phyCAddr; 587 #endif 588 // Notify the client of a new frame. 589 if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) { 590 //nsecs_t timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 591 mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, buffer, mCallbackCookie); 592 } 593 #ifdef DUAL_PORT_RECORDING 594 } else if (mRecordRunning == false) { 595 if (mSecCamera->stopRecord() < 0) { 596 LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__); 597 return UNKNOWN_ERROR; 598 } 599 #endif 600 } 601 602 // Wait for it... 603 if (mTimeStart.tv_sec == 0 && mTimeStart.tv_usec == 0) { 604 gettimeofday(&mTimeStart, NULL); 605 } else { 606 gettimeofday(&mTimeStop, NULL); 607 long time = measure_time(&mTimeStart, &mTimeStop); 608 int delay = (mPreviewFrameRateMicrosec > time) ? mPreviewFrameRateMicrosec - time : 0; 609 610 usleep(delay); 611 //LOG_CAMERA_PREVIEW("delay = %d time = %ld us\n ", delay, time); 612 gettimeofday(&mTimeStart, NULL); 613 } 614 615 return NO_ERROR; 616 } 617 618 status_t CameraHardwareSec::startPreview() 619 { 620 int ret = 0; //s1 [Apply factory standard] 621 622 LOGV("%s :", __func__); 623 624 Mutex::Autolock lock(mStateLock); 625 if (mPreviewRunning) { 626 // already running 627 LOGE("%s : preview thread already running", __func__); 628 return INVALID_OPERATION; 629 } 630 631 if (mCaptureInProgress) { 632 LOGE("%s : capture in progress, not allowed", __func__); 633 return INVALID_OPERATION; 634 } 635 636 memset(&mTimeStart, 0, sizeof(mTimeStart)); 637 memset(&mTimeStop, 0, sizeof(mTimeStop)); 638 639 mSecCamera->stopPreview(); 640 641 setSkipFrame(INITIAL_SKIP_FRAME); 642 643 ret = mSecCamera->startPreview(); 644 LOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret); 645 646 if (ret < 0) { 647 LOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__); 648 return -1; //UNKNOWN_ERROR; 649 } 650 651 #ifdef PREVIEW_USING_MMAP 652 if (mPreviewHeap != NULL) 653 mPreviewHeap.clear(); 654 655 int width, height, frame_size; 656 657 mSecCamera->getPreviewSize(&width, &height, &frame_size); 658 659 int previewHeapSize = (frame_size + 16) * kBufferCount; 660 661 LOGD("MemoryHeapBase(fd(%d), size(%d), width(%d), height(%d))", (int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), width, height); 662 mPreviewHeap = new MemoryHeapBase((int)mSecCamera->getCameraFd(), (size_t)(previewHeapSize), (uint32_t)0); 663 #endif 664 665 #ifdef JPEG_FROM_SENSOR 666 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); 667 LOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d",mPostViewWidth,mPostViewHeight,mPostViewSize); 668 #endif 669 670 #ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA 671 int rawHeapSize = mPostViewSize; 672 #else 673 int rawHeapSize = sizeof(struct addrs_cap); 674 #endif 675 LOGV("CameraHardwareSec: mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize); 676 mRawHeap = new MemoryHeapBase(rawHeapSize); 677 if (mRawHeap->getHeapID() < 0) { 678 LOGE("ERR(%s): Raw heap creation fail", __func__); 679 mRawHeap.clear(); 680 } 681 682 mPreviewRunning = true; 683 mPreviewThread->run("CameraPreviewThread", PRIORITY_URGENT_DISPLAY); 684 685 return NO_ERROR; 686 } 687 688 #if defined(BOARD_USES_OVERLAY) 689 bool CameraHardwareSec::useOverlay() 690 { 691 LOGV("%s: returning true", __func__); 692 return true; 693 } 694 695 status_t CameraHardwareSec::setOverlay(const sp<Overlay> &overlay) 696 { 697 LOGV("%s :", __func__); 698 699 int overlayWidth = 0; 700 int overlayHeight = 0; 701 int overlayFrameSize = 0; 702 703 if (overlay == NULL) { 704 LOGV("%s : overlay == NULL", __func__); 705 goto setOverlayFail; 706 } 707 LOGV("%s : overlay = %p", __func__, overlay->getHandleRef()); 708 709 if (overlay->getHandleRef()== NULL && mUseOverlay == true) { 710 if (mOverlay != 0) 711 mOverlay->destroy(); 712 713 mOverlay = NULL; 714 mUseOverlay = false; 715 716 return NO_ERROR; 717 } 718 719 if (overlay->getStatus() != NO_ERROR) { 720 LOGE("ERR(%s):overlay->getStatus() fail", __func__); 721 goto setOverlayFail; 722 } 723 724 mSecCamera->getPreviewSize(&overlayWidth, &overlayHeight, &overlayFrameSize); 725 726 if (overlay->setCrop(0, 0, overlayWidth, overlayHeight) != NO_ERROR) { 727 LOGE("ERR(%s)::(mOverlay->setCrop(0, 0, %d, %d) fail", __func__, overlayWidth, overlayHeight); 728 goto setOverlayFail; 729 } 730 731 mOverlay = overlay; 732 mUseOverlay = true; 733 734 return NO_ERROR; 735 736 setOverlayFail : 737 if (mOverlay != 0) 738 mOverlay->destroy(); 739 mOverlay = 0; 740 741 mUseOverlay = false; 742 743 return UNKNOWN_ERROR; 744 } 745 #endif 746 747 void CameraHardwareSec::stopPreview() 748 { 749 LOGV("%s :", __func__); 750 751 if (!previewEnabled()) 752 return; 753 754 /* request that the preview thread exit. we can wait because we're 755 * called by CameraServices with a lock but it has disabled all preview 756 * related callbacks so previewThread should not invoke any callbacks. 757 */ 758 mPreviewThread->requestExitAndWait(); 759 760 if (mSecCamera->stopPreview() < 0) 761 LOGE("ERR(%s):Fail on mSecCamera->stopPreview()", __func__); 762 763 mPreviewRunning = false; 764 } 765 766 bool CameraHardwareSec::previewEnabled() 767 { 768 Mutex::Autolock lock(mStateLock); 769 LOGV("%s : %d", __func__, mPreviewRunning); 770 return mPreviewRunning; 771 } 772 773 // --------------------------------------------------------------------------- 774 775 status_t CameraHardwareSec::startRecording() 776 { 777 LOGV("%s :", __func__); 778 779 #ifdef DUAL_PORT_RECORDING 780 if (mSecCamera->startRecord() < 0) { 781 LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__); 782 return UNKNOWN_ERROR; 783 } 784 #endif 785 786 mRecordRunning = true; 787 return NO_ERROR; 788 } 789 790 void CameraHardwareSec::stopRecording() 791 { 792 LOGV("%s :", __func__); 793 794 mRecordRunning = false; 795 } 796 797 bool CameraHardwareSec::recordingEnabled() 798 { 799 LOGV("%s :", __func__); 800 801 return mRecordRunning; 802 } 803 804 void CameraHardwareSec::releaseRecordingFrame(const sp<IMemory>& mem) 805 { 806 LOG_CAMERA_PREVIEW("%s :", __func__); 807 808 // ssize_t offset; size_t size; 809 // sp<MemoryBase> mem1 = mem; 810 // sp<MemoryHeapBase> heap = mem->getMemory(&offset, &size); 811 // sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); 812 813 // mem1.clear(); 814 // heap.clear(); 815 } 816 817 // --------------------------------------------------------------------------- 818 819 int CameraHardwareSec::autoFocusThread() 820 { 821 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION 822 int count =0; 823 int af_status =0 ; 824 #endif 825 826 LOGV("%s : starting", __func__); 827 828 /* block until we're told to start. we don't want to use 829 * a restartable thread and requestExitAndWait() in cancelAutoFocus() 830 * because it would cause deadlock between our callbacks and the 831 * caller of cancelAutoFocus() which both want to grab the same lock 832 * in CameraServices layer. 833 */ 834 mFocusLock.lock(); 835 mCondition.wait(mFocusLock); 836 mFocusLock.unlock(); 837 838 /* check early exit request */ 839 if (mExitAutoFocusThread) 840 return NO_ERROR; 841 842 LOGV("%s : calling setAutoFocus", __func__); 843 if (mSecCamera->setAutofocus() < 0) { 844 LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__); 845 return UNKNOWN_ERROR; 846 } 847 848 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION 849 af_status = mSecCamera->getAutoFocusResult(); 850 851 if (af_status == 0x01) { 852 LOGV("%s : AF Success!!", __func__); 853 if (mMsgEnabled & CAMERA_MSG_FOCUS) 854 mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); 855 } else if (af_status == 0x02) { 856 LOGV("%s : AF Cancelled !!", __func__); 857 if (mMsgEnabled & CAMERA_MSG_FOCUS) { 858 /* CAMERA_MSG_FOCUS only takes a bool. true for 859 * finished and false for failure. cancel is still 860 * considered a true result. 861 */ 862 mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); 863 } 864 } else { 865 LOGV("%s : AF Fail !!", __func__); 866 LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); 867 if (mMsgEnabled & CAMERA_MSG_FOCUS) 868 mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie); 869 } 870 #else 871 if (mMsgEnabled & CAMERA_MSG_FOCUS) 872 mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); 873 #endif 874 875 return NO_ERROR; 876 } 877 878 status_t CameraHardwareSec::autoFocus() 879 { 880 LOGV("%s :", __func__); 881 /* signal autoFocusThread to run once */ 882 mCondition.signal(); 883 return NO_ERROR; 884 } 885 886 /* 2009.10.14 by icarus for added interface */ 887 status_t CameraHardwareSec::cancelAutoFocus() 888 { 889 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION 890 LOGV("%s :", __func__); 891 892 if (mSecCamera->cancelAutofocus() < 0) { 893 LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__); 894 return UNKNOWN_ERROR; 895 } 896 #endif 897 898 return NO_ERROR; 899 } 900 901 int CameraHardwareSec::save_jpeg( unsigned char *real_jpeg, int jpeg_size) 902 { 903 FILE *yuv_fp = NULL; 904 char filename[100], *buffer = NULL; 905 906 /* file create/open, note to "wb" */ 907 yuv_fp = fopen("/data/camera_dump.jpeg", "wb"); 908 if (yuv_fp == NULL) { 909 LOGE("Save jpeg file open error"); 910 return -1; 911 } 912 913 LOGV("[BestIQ] real_jpeg size ========> %d\n", jpeg_size); 914 buffer = (char *) malloc(jpeg_size); 915 if (buffer == NULL) { 916 LOGE("Save YUV] buffer alloc failed"); 917 if (yuv_fp) 918 fclose(yuv_fp); 919 920 return -1; 921 } 922 923 memcpy(buffer, real_jpeg, jpeg_size); 924 925 fflush(stdout); 926 927 fwrite(buffer, 1, jpeg_size, yuv_fp); 928 929 fflush(yuv_fp); 930 931 if (yuv_fp) 932 fclose(yuv_fp); 933 if (buffer) 934 free(buffer); 935 936 return 0; 937 } 938 939 void CameraHardwareSec::save_postview(const char *fname, uint8_t *buf, uint32_t size) 940 { 941 int nw; 942 int cnt = 0; 943 uint32_t written = 0; 944 945 LOGD("opening file [%s]\n", fname); 946 int fd = open(fname, O_RDWR | O_CREAT); 947 if (fd < 0) { 948 LOGE("failed to create file [%s]: %s", fname, strerror(errno)); 949 return; 950 } 951 952 LOGD("writing %d bytes to file [%s]\n", size, fname); 953 while (written < size) { 954 nw = ::write(fd, buf + written, size - written); 955 if (nw < 0) { 956 LOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno)); 957 break; 958 } 959 written += nw; 960 cnt++; 961 } 962 LOGD("done writing %d bytes to file [%s] in %d passes\n",size, fname, cnt); 963 ::close(fd); 964 } 965 966 bool CameraHardwareSec::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHeight, 967 char *dstBuf, uint32_t dstWidth, uint32_t dstHeight) 968 { 969 int32_t step_x, step_y; 970 int32_t iXsrc, iXdst; 971 int32_t x, y, src_y_start_pos, dst_pos, src_pos; 972 973 if (dstWidth % 2 != 0 || dstHeight % 2 != 0){ 974 LOGE("scale_down_yuv422: invalid width, height for scaling"); 975 return false; 976 } 977 978 step_x = srcWidth / dstWidth; 979 step_y = srcHeight / dstHeight; 980 981 dst_pos = 0; 982 for (uint32_t y = 0; y < dstHeight; y++) { 983 src_y_start_pos = (y * step_y * (srcWidth * 2)); 984 985 for (uint32_t x = 0; x < dstWidth; x += 2) { 986 src_pos = src_y_start_pos + (x * (step_x * 2)); 987 988 dstBuf[dst_pos++] = srcBuf[src_pos ]; 989 dstBuf[dst_pos++] = srcBuf[src_pos + 1]; 990 dstBuf[dst_pos++] = srcBuf[src_pos + 2]; 991 dstBuf[dst_pos++] = srcBuf[src_pos + 3]; 992 } 993 } 994 995 return true; 996 } 997 998 bool CameraHardwareSec::YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight) 999 { 1000 int32_t x, y, src_y_start_pos, dst_cbcr_pos, dst_pos, src_pos; 1001 unsigned char *srcBufPointer = (unsigned char *)srcBuf; 1002 unsigned char *dstBufPointer = (unsigned char *)dstBuf; 1003 1004 dst_pos = 0; 1005 dst_cbcr_pos = srcWidth*srcHeight; 1006 for (uint32_t y = 0; y < srcHeight; y++) { 1007 src_y_start_pos = (y * (srcWidth * 2)); 1008 1009 for (uint32_t x = 0; x < (srcWidth * 2); x += 2) { 1010 src_pos = src_y_start_pos + x; 1011 1012 dstBufPointer[dst_pos++] = srcBufPointer[src_pos]; 1013 } 1014 } 1015 for (uint32_t y = 0; y < srcHeight; y += 2) { 1016 src_y_start_pos = (y * (srcWidth * 2)); 1017 1018 for (uint32_t x = 0; x < (srcWidth * 2); x += 4) { 1019 src_pos = src_y_start_pos + x; 1020 1021 dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 3]; 1022 dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 1]; 1023 } 1024 } 1025 1026 return true; 1027 } 1028 1029 int CameraHardwareSec::pictureThread() 1030 { 1031 LOGV("%s :", __func__); 1032 1033 int jpeg_size = 0; 1034 int ret = NO_ERROR; 1035 unsigned char *jpeg_data = NULL; 1036 int postview_offset = 0; 1037 unsigned char *postview_data = NULL; 1038 1039 unsigned char *addr = NULL; 1040 int mPostViewWidth, mPostViewHeight, mPostViewSize; 1041 int mThumbWidth, mThumbHeight, mThumbSize; 1042 int cap_width, cap_height, cap_frame_size; 1043 1044 unsigned int output_size = 0; 1045 1046 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); 1047 mSecCamera->getThumbnailConfig(&mThumbWidth, &mThumbHeight, &mThumbSize); 1048 int postviewHeapSize = mPostViewSize; 1049 mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size); 1050 int mJpegHeapSize; 1051 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) 1052 mJpegHeapSize = cap_frame_size * SecCamera::getJpegRatio(); 1053 else 1054 mJpegHeapSize = cap_frame_size; 1055 1056 LOG_TIME_DEFINE(0) 1057 LOG_TIME_START(0) 1058 #ifdef DIRECT_DELIVERY_OF_POSTVIEW_DATA 1059 sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, mPostViewSize + 8); 1060 #else 1061 sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, sizeof(struct addrs_cap)); 1062 #endif 1063 1064 struct addrs_cap *addrs = (struct addrs_cap *)mRawHeap->base(); 1065 1066 #ifdef JPEG_FROM_SENSOR 1067 addrs[0].width = mPostViewWidth; 1068 addrs[0].height = mPostViewHeight; 1069 LOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight); 1070 #else 1071 mParameters.getPictureSize((int*)&addrs[0].width, (int*)&addrs[0].height); 1072 #endif 1073 1074 sp<MemoryHeapBase> JpegHeap = new MemoryHeapBase(mJpegHeapSize); 1075 sp<MemoryHeapBase> PostviewHeap = new MemoryHeapBase(mPostViewSize); 1076 sp<MemoryHeapBase> ThumbnailHeap = new MemoryHeapBase(mThumbSize); 1077 1078 if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { 1079 LOG_TIME_DEFINE(1) 1080 LOG_TIME_START(1) 1081 1082 int picture_size, picture_width, picture_height; 1083 mSecCamera->getSnapshotSize(&picture_width, &picture_height, &picture_size); 1084 int picture_format = mSecCamera->getSnapshotPixelFormat(); 1085 1086 unsigned int phyAddr; 1087 #ifdef JPEG_FROM_SENSOR 1088 // Modified the shutter sound timing for Jpeg capture 1089 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) 1090 mSecCamera->setSnapshotCmd(); 1091 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION 1092 if (mMsgEnabled & CAMERA_MSG_SHUTTER) { 1093 mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie); 1094 } 1095 #endif 1096 1097 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){ 1098 jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr); 1099 if (jpeg_data == NULL) { 1100 LOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __func__); 1101 ret = UNKNOWN_ERROR; 1102 } 1103 } else { 1104 if (mSecCamera->getSnapshotAndJpeg((unsigned char*)PostviewHeap->base(), 1105 (unsigned char*)JpegHeap->base(), &output_size) < 0) { 1106 mStateLock.lock(); 1107 mCaptureInProgress = false; 1108 mStateLock.unlock(); 1109 return UNKNOWN_ERROR; 1110 } 1111 LOGI("snapshotandjpeg done\n"); 1112 } 1113 #else 1114 phyAddr = mSecCamera->getSnapshotAndJpeg(); 1115 if (phyAddr < 0) { 1116 mStateLock.lock(); 1117 mCaptureInProgress = false; 1118 mStateLock.unlock(); 1119 return UNKNOWN_ERROR; 1120 } 1121 1122 jpeg_data = mSecCamera->yuv2Jpeg((unsigned char*)phyAddr, 0, &jpeg_size, 1123 picture_width, picture_height, picture_format); 1124 #endif 1125 1126 #ifndef DIRECT_DELIVERY_OF_POSTVIEW_DATA 1127 1128 addrs[0].addr_y = phyAddr; 1129 #endif 1130 1131 LOG_TIME_END(1) 1132 LOG_CAMERA("getSnapshotAndJpeg interval: %lu us", LOG_TIME(1)); 1133 } 1134 1135 /* the capture is done at this point so we can allow sensor commands 1136 * again, we still need to do jpeg and thumbnail processing, but the 1137 * sensor is available for something else 1138 */ 1139 mStateLock.lock(); 1140 mCaptureInProgress = false; 1141 mStateLock.unlock(); 1142 1143 int JpegImageSize, JpegExifSize; 1144 bool isLSISensor = false; 1145 1146 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) { 1147 isLSISensor = !strncmp((const char*)mCameraSensorName, "S5K4ECGX", 8); 1148 if(isLSISensor) { 1149 LOGI("== Camera Sensor Detect %s - Samsung LSI SOC 5M ==\n", mCameraSensorName); 1150 // LSI 5M SOC 1151 if (!SplitFrame(jpeg_data, SecCamera::getInterleaveDataSize(), 1152 SecCamera::getJpegLineLength(), 1153 mPostViewWidth * 2, mPostViewWidth, 1154 JpegHeap->base(), &JpegImageSize, 1155 PostviewHeap->base(), &mPostViewSize)) 1156 return UNKNOWN_ERROR; 1157 } else { 1158 LOGI("== Camera Sensor Detect %s Sony SOC 5M ==\n", mCameraSensorName); 1159 decodeInterleaveData(jpeg_data, SecCamera::getInterleaveDataSize(), mPostViewWidth, mPostViewHeight, 1160 &JpegImageSize, JpegHeap->base(), PostviewHeap->base()); 1161 1162 } 1163 } else { 1164 JpegImageSize = static_cast<int>(output_size); 1165 } 1166 scaleDownYuv422((char *)PostviewHeap->base(), mPostViewWidth, mPostViewHeight, 1167 (char *)ThumbnailHeap->base(), mThumbWidth, mThumbHeight); 1168 1169 #ifdef POSTVIEW_CALLBACK 1170 sp<MemoryBase> postview = new MemoryBase(PostviewHeap, 0, postviewHeapSize); 1171 #endif 1172 memcpy(mRawHeap->base(),PostviewHeap->base(), postviewHeapSize); 1173 1174 #if defined(BOARD_USES_OVERLAY) 1175 /* Put postview image to Overlay */ 1176 unsigned int index = 0; 1177 unsigned int offset = ((mPostViewWidth*mPostViewHeight*3/2) + 16) * index; 1178 unsigned int overlay_header[4]; 1179 1180 // Only show postview image if size is VGA since sensor cannot deliver 1181 // any other sizes. 1182 int previewWidth, previewHeight, previewSize; 1183 mSecCamera->getPreviewSize(&previewWidth, &previewHeight, &previewSize); 1184 if ((previewWidth != 640) || (previewHeight != 480)) 1185 goto PostviewOverlayEnd; 1186 1187 mOverlayBufferIdx ^= 1; 1188 overlay_header[0]= mSecCamera->getPhyAddrY(index); 1189 overlay_header[1]= overlay_header[0] + mPostViewWidth*mPostViewHeight; 1190 overlay_header[2]= mOverlayBufferIdx; 1191 1192 YUY2toNV21(mRawHeap->base(), (void*)(static_cast<unsigned char *>(mPreviewHeap->base()) + offset), 1193 mPostViewWidth, mPostViewHeight); 1194 1195 memcpy(static_cast<unsigned char*>(mPreviewHeap->base()) + offset + (mPostViewWidth*mPostViewHeight * 3 / 2), 1196 overlay_header, 16); 1197 1198 ret = mOverlay->queueBuffer((void*)(static_cast<unsigned char *>(mPreviewHeap->base()) + offset + 1199 (mPostViewWidth*mPostViewHeight * 3 / 2))); 1200 1201 if (ret == ALL_BUFFERS_FLUSHED) { 1202 goto PostviewOverlayEnd; 1203 } else if (ret == -1) { 1204 LOGE("ERR(%s):overlay queueBuffer fail", __func__); 1205 goto PostviewOverlayEnd; 1206 } 1207 1208 overlay_buffer_t overlay_buffer; 1209 ret = mOverlay->dequeueBuffer(&overlay_buffer); 1210 1211 if (ret == ALL_BUFFERS_FLUSHED) { 1212 goto PostviewOverlayEnd; 1213 } else if (ret == -1) { 1214 LOGE("ERR(%s):overlay dequeueBuffer fail", __func__); 1215 goto PostviewOverlayEnd; 1216 } 1217 1218 PostviewOverlayEnd: 1219 #endif 1220 if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { 1221 mDataCb(CAMERA_MSG_RAW_IMAGE, buffer, mCallbackCookie); 1222 } 1223 #ifdef POSTVIEW_CALLBACK 1224 if (mMsgEnabled & CAMERA_MSG_POSTVIEW_FRAME) { 1225 int postviewHeapSize = mPostViewSize; 1226 sp<MemoryHeapBase> mPostviewHeap = new MemoryHeapBase(postviewHeapSize); 1227 1228 postview_data = jpeg_data + postview_offset; 1229 sp<MemoryBase> postview = new MemoryBase(mPostviewHeap, 0, postviewHeapSize); 1230 1231 if (postview_data != NULL) 1232 memcpy(mPostviewHeap->base(), postview_data, postviewHeapSize); 1233 1234 mDataCb(CAMERA_MSG_POSTVIEW_FRAME, postview, mCallbackCookie); 1235 } 1236 #endif 1237 if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { 1238 sp<MemoryHeapBase> ExifHeap = new MemoryHeapBase(EXIF_FILE_SIZE + JPG_STREAM_BUF_SIZE); 1239 JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->base(), 1240 (unsigned char *)ThumbnailHeap->base()); 1241 1242 LOGV("JpegExifSize=%d", JpegExifSize); 1243 1244 if (JpegExifSize < 0) { 1245 return UNKNOWN_ERROR; 1246 } 1247 1248 unsigned char *ExifStart = (unsigned char *)JpegHeap->base() + 2; 1249 unsigned char *ImageStart = ExifStart + JpegExifSize; 1250 1251 memmove(ImageStart, ExifStart, JpegImageSize - 2); 1252 memcpy(ExifStart, ExifHeap->base(), JpegExifSize); 1253 sp<MemoryBase> mem = new MemoryBase(JpegHeap, 0, JpegImageSize + JpegExifSize); 1254 1255 mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, mCallbackCookie); 1256 } 1257 1258 LOG_TIME_END(0) 1259 LOG_CAMERA("pictureThread interval: %lu us", LOG_TIME(0)); 1260 1261 LOGV("%s : pictureThread end", __func__); 1262 return ret; 1263 } 1264 1265 status_t CameraHardwareSec::takePicture() 1266 { 1267 LOGV("%s :", __func__); 1268 1269 stopPreview(); 1270 1271 Mutex::Autolock lock(mStateLock); 1272 if (mCaptureInProgress) { 1273 LOGE("%s : capture already in progress", __func__); 1274 return INVALID_OPERATION; 1275 } 1276 1277 if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) { 1278 LOGE("%s : couldn't run picture thread", __func__); 1279 return INVALID_OPERATION; 1280 } 1281 mCaptureInProgress = true; 1282 1283 return NO_ERROR; 1284 } 1285 1286 status_t CameraHardwareSec::cancelPicture() 1287 { 1288 mPictureThread->requestExitAndWait(); 1289 1290 mSecCamera->cancelPicture(); 1291 1292 LOGW("%s : not supported, just returning NO_ERROR", __func__); 1293 return NO_ERROR; 1294 } 1295 1296 bool CameraHardwareSec::CheckVideoStartMarker(unsigned char *pBuf) 1297 { 1298 if (!pBuf) { 1299 LOGE("CheckVideoStartMarker() => pBuf is NULL\n"); 1300 return false; 1301 } 1302 1303 if (HIBYTE(VIDEO_COMMENT_MARKER_H) == * pBuf && LOBYTE(VIDEO_COMMENT_MARKER_H) == *(pBuf + 1) && 1304 HIBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 2) && LOBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 3)) 1305 return true; 1306 1307 return false; 1308 } 1309 1310 bool CameraHardwareSec::CheckEOIMarker(unsigned char *pBuf) 1311 { 1312 if (!pBuf) { 1313 LOGE("CheckEOIMarker() => pBuf is NULL\n"); 1314 return false; 1315 } 1316 1317 // EOI marker [FF D9] 1318 if (HIBYTE(JPEG_EOI_MARKER) == *pBuf && LOBYTE(JPEG_EOI_MARKER) == *(pBuf + 1)) 1319 return true; 1320 1321 return false; 1322 } 1323 1324 bool CameraHardwareSec::FindEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize) 1325 { 1326 if (NULL == pBuf || 0 >= dwBufSize) { 1327 LOGE("FindEOIMarkerInJPEG() => There is no contents."); 1328 return false; 1329 } 1330 1331 unsigned char *pBufEnd = pBuf + dwBufSize; 1332 1333 while (pBuf < pBufEnd) { 1334 if (CheckEOIMarker(pBuf++)) 1335 return true; 1336 1337 (*pnJPEGsize)++; 1338 } 1339 1340 return false; 1341 } 1342 1343 bool CameraHardwareSec::SplitFrame(unsigned char *pFrame, int dwSize, 1344 int dwJPEGLineLength, int dwVideoLineLength, int dwVideoHeight, 1345 void *pJPEG, int *pdwJPEGSize, 1346 void *pVideo, int *pdwVideoSize) 1347 { 1348 LOGV("===========SplitFrame Start=============="); 1349 1350 if (NULL == pFrame || 0 >= dwSize) { 1351 LOGE("There is no contents.\r\n"); 1352 return false; 1353 } 1354 1355 if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) { 1356 LOGE("There in no input information for decoding interleaved jpeg"); 1357 return false; 1358 } 1359 1360 unsigned char *pSrc = pFrame; 1361 unsigned char *pSrcEnd = pFrame + dwSize; 1362 1363 unsigned char *pJ = (unsigned char *)pJPEG; 1364 int dwJSize = 0; 1365 unsigned char *pV = (unsigned char *)pVideo; 1366 int dwVSize = 0; 1367 1368 bool bRet = false; 1369 bool isFinishJpeg = false; 1370 1371 while (pSrc < pSrcEnd) { 1372 // Check video start marker 1373 if (CheckVideoStartMarker(pSrc)) { 1374 int copyLength; 1375 1376 if (pSrc + dwVideoLineLength <= pSrcEnd) 1377 copyLength = dwVideoLineLength; 1378 else 1379 copyLength = pSrcEnd - pSrc - VIDEO_COMMENT_MARKER_LENGTH; 1380 1381 // Copy video data 1382 if (pV) { 1383 memcpy(pV, pSrc + VIDEO_COMMENT_MARKER_LENGTH, copyLength); 1384 pV += copyLength; 1385 dwVSize += copyLength; 1386 } 1387 1388 pSrc += copyLength + VIDEO_COMMENT_MARKER_LENGTH; 1389 } else { 1390 // Copy pure JPEG data 1391 int size = 0; 1392 int dwCopyBufLen = dwJPEGLineLength <= pSrcEnd-pSrc ? dwJPEGLineLength : pSrcEnd - pSrc; 1393 1394 if (FindEOIMarkerInJPEG((unsigned char *)pSrc, dwCopyBufLen, &size)) { 1395 isFinishJpeg = true; 1396 size += 2; // to count EOF marker size 1397 } else { 1398 if ((dwCopyBufLen == 1) && (pJPEG < pJ)) { 1399 unsigned char checkBuf[2] = { *(pJ - 1), *pSrc }; 1400 1401 if (CheckEOIMarker(checkBuf)) 1402 isFinishJpeg = true; 1403 } 1404 size = dwCopyBufLen; 1405 } 1406 1407 memcpy(pJ, pSrc, size); 1408 1409 dwJSize += size; 1410 1411 pJ += dwCopyBufLen; 1412 pSrc += dwCopyBufLen; 1413 } 1414 if (isFinishJpeg) 1415 break; 1416 } 1417 1418 if (isFinishJpeg) { 1419 bRet = true; 1420 if(pdwJPEGSize) 1421 *pdwJPEGSize = dwJSize; 1422 if(pdwVideoSize) 1423 *pdwVideoSize = dwVSize; 1424 } else { 1425 LOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI"); 1426 bRet = false; 1427 if(pdwJPEGSize) 1428 *pdwJPEGSize = 0; 1429 if(pdwVideoSize) 1430 *pdwVideoSize = 0; 1431 } 1432 LOGV("===========SplitFrame end=============="); 1433 1434 return bRet; 1435 } 1436 1437 int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData, 1438 int interleaveDataSize, 1439 int yuvWidth, 1440 int yuvHeight, 1441 int *pJpegSize, 1442 void *pJpegData, 1443 void *pYuvData) 1444 { 1445 if (pInterleaveData == NULL) 1446 return false; 1447 1448 bool ret = true; 1449 unsigned int *interleave_ptr = (unsigned int *)pInterleaveData; 1450 unsigned char *jpeg_ptr = (unsigned char *)pJpegData; 1451 unsigned char *yuv_ptr = (unsigned char *)pYuvData; 1452 unsigned char *p; 1453 int jpeg_size = 0; 1454 int yuv_size = 0; 1455 1456 int i = 0; 1457 1458 LOGV("decodeInterleaveData Start~~~"); 1459 while (i < interleaveDataSize) { 1460 if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) || 1461 (*interleave_ptr == 0xFF02FFFF)) { 1462 // Padding Data 1463 // LOGE("%d(%x) padding data\n", i, *interleave_ptr); 1464 interleave_ptr++; 1465 i += 4; 1466 } 1467 else if ((*interleave_ptr & 0xFFFF) == 0x05FF) { 1468 // Start-code of YUV Data 1469 // LOGE("%d(%x) yuv data\n", i, *interleave_ptr); 1470 p = (unsigned char *)interleave_ptr; 1471 p += 2; 1472 i += 2; 1473 1474 // Extract YUV Data 1475 if (pYuvData != NULL) { 1476 memcpy(yuv_ptr, p, yuvWidth * 2); 1477 yuv_ptr += yuvWidth * 2; 1478 yuv_size += yuvWidth * 2; 1479 } 1480 p += yuvWidth * 2; 1481 i += yuvWidth * 2; 1482 1483 // Check End-code of YUV Data 1484 if ((*p == 0xFF) && (*(p + 1) == 0x06)) { 1485 interleave_ptr = (unsigned int *)(p + 2); 1486 i += 2; 1487 } else { 1488 ret = false; 1489 break; 1490 } 1491 } else { 1492 // Extract JPEG Data 1493 // LOGE("%d(%x) jpg data, jpeg_size = %d bytes\n", i, *interleave_ptr, jpeg_size); 1494 if (pJpegData != NULL) { 1495 memcpy(jpeg_ptr, interleave_ptr, 4); 1496 jpeg_ptr += 4; 1497 jpeg_size += 4; 1498 } 1499 interleave_ptr++; 1500 i += 4; 1501 } 1502 } 1503 if (ret) { 1504 if (pJpegData != NULL) { 1505 // Remove Padding after EOI 1506 for (i = 0; i < 3; i++) { 1507 if (*(--jpeg_ptr) != 0xFF) { 1508 break; 1509 } 1510 jpeg_size--; 1511 } 1512 *pJpegSize = jpeg_size; 1513 1514 } 1515 // Check YUV Data Size 1516 if (pYuvData != NULL) { 1517 if (yuv_size != (yuvWidth * yuvHeight * 2)) { 1518 ret = false; 1519 } 1520 } 1521 } 1522 LOGV("decodeInterleaveData End~~~"); 1523 return ret; 1524 } 1525 1526 status_t CameraHardwareSec::dump(int fd, const Vector<String16>& args) const 1527 { 1528 const size_t SIZE = 256; 1529 char buffer[SIZE]; 1530 String8 result; 1531 1532 if (mSecCamera != 0) { 1533 mSecCamera->dump(fd, args); 1534 mParameters.dump(fd, args); 1535 mInternalParameters.dump(fd, args); 1536 snprintf(buffer, 255, " preview frame(%d), size (%d), running(%s)\n", mCurrentPreviewFrame, mPreviewFrameSize, mPreviewRunning?"true": "false"); 1537 result.append(buffer); 1538 } else { 1539 result.append("No camera client yet.\n"); 1540 } 1541 write(fd, result.string(), result.size()); 1542 return NO_ERROR; 1543 } 1544 1545 status_t CameraHardwareSec::setParameters(const CameraParameters& params) 1546 { 1547 LOGV("%s :", __func__); 1548 1549 status_t ret = NO_ERROR; 1550 1551 /* if someone calls us while picture thread is running, it could screw 1552 * up the sensor quite a bit so return error. we can't wait because 1553 * that would cause deadlock with the callbacks 1554 */ 1555 mStateLock.lock(); 1556 if (mCaptureInProgress) { 1557 mStateLock.unlock(); 1558 LOGE("%s : capture in progress, not allowed", __func__); 1559 return UNKNOWN_ERROR; 1560 } 1561 mStateLock.unlock(); 1562 1563 // preview size 1564 int new_preview_width = 0; 1565 int new_preview_height = 0; 1566 params.getPreviewSize(&new_preview_width, &new_preview_height); 1567 const char *new_str_preview_format = params.getPreviewFormat(); 1568 LOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s", 1569 __func__, new_preview_width, new_preview_height, new_str_preview_format); 1570 1571 if (0 < new_preview_width && 0 < new_preview_height && new_str_preview_format != NULL) { 1572 int new_preview_format = 0; 1573 1574 if (!strcmp(new_str_preview_format, 1575 CameraParameters::PIXEL_FORMAT_RGB565)) 1576 new_preview_format = V4L2_PIX_FMT_RGB565; 1577 else if (!strcmp(new_str_preview_format, 1578 CameraParameters::PIXEL_FORMAT_YUV420SP)) 1579 new_preview_format = V4L2_PIX_FMT_NV21; 1580 else if (!strcmp(new_str_preview_format, "yuv420sp_custom")) 1581 new_preview_format = V4L2_PIX_FMT_NV12T; 1582 else if (!strcmp(new_str_preview_format, "yuv420p")) 1583 new_preview_format = V4L2_PIX_FMT_YUV420; 1584 else if (!strcmp(new_str_preview_format, "yuv422i")) 1585 new_preview_format = V4L2_PIX_FMT_YUYV; 1586 else if (!strcmp(new_str_preview_format, "yuv422p")) 1587 new_preview_format = V4L2_PIX_FMT_YUV422P; 1588 else 1589 new_preview_format = V4L2_PIX_FMT_NV21; //for 3rd party 1590 1591 if (mSecCamera->setPreviewSize(new_preview_width, new_preview_height, new_preview_format) < 0) { 1592 LOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))", 1593 __func__, new_preview_width, new_preview_height, new_preview_format); 1594 ret = UNKNOWN_ERROR; 1595 } else { 1596 mParameters.setPreviewSize(new_preview_width, new_preview_height); 1597 mParameters.setPreviewFormat(new_str_preview_format); 1598 } 1599 #if defined(BOARD_USES_OVERLAY) 1600 if (mUseOverlay == true && mOverlay != 0) { 1601 if (mOverlay->setCrop(0, 0, new_preview_width, new_preview_height) != NO_ERROR) { 1602 LOGE("ERR(%s)::(mOverlay->setCrop(0, 0, %d, %d) fail", 1603 __func__, new_preview_width, new_preview_height); 1604 } 1605 } 1606 #endif 1607 } 1608 1609 int new_picture_width = 0; 1610 int new_picture_height = 0; 1611 1612 params.getPictureSize(&new_picture_width, &new_picture_height); 1613 LOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height); 1614 if (0 < new_picture_width && 0 < new_picture_height) { 1615 if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) { 1616 LOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))", 1617 __func__, new_picture_width, new_picture_height); 1618 ret = UNKNOWN_ERROR; 1619 } else { 1620 mParameters.setPictureSize(new_picture_width, new_picture_height); 1621 } 1622 } 1623 1624 // picture format 1625 const char *new_str_picture_format = params.getPictureFormat(); 1626 LOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format); 1627 if (new_str_picture_format != NULL) { 1628 int new_picture_format = 0; 1629 1630 if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGB565)) 1631 new_picture_format = V4L2_PIX_FMT_RGB565; 1632 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_YUV420SP)) 1633 new_picture_format = V4L2_PIX_FMT_NV21; 1634 else if (!strcmp(new_str_picture_format, "yuv420sp_custom")) 1635 new_picture_format = V4L2_PIX_FMT_NV12T; 1636 else if (!strcmp(new_str_picture_format, "yuv420p")) 1637 new_picture_format = V4L2_PIX_FMT_YUV420; 1638 else if (!strcmp(new_str_picture_format, "yuv422i")) 1639 new_picture_format = V4L2_PIX_FMT_YUYV; 1640 else if (!strcmp(new_str_picture_format, "uyv422i_custom")) //Zero copy UYVY format 1641 new_picture_format = V4L2_PIX_FMT_UYVY; 1642 else if (!strcmp(new_str_picture_format, "uyv422i")) //Non-zero copy UYVY format 1643 new_picture_format = V4L2_PIX_FMT_UYVY; 1644 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_JPEG)) 1645 #ifdef JPEG_FROM_SENSOR 1646 new_picture_format = V4L2_PIX_FMT_YUYV; 1647 #endif 1648 else if (!strcmp(new_str_picture_format, "yuv422p")) 1649 new_picture_format = V4L2_PIX_FMT_YUV422P; 1650 else 1651 new_picture_format = V4L2_PIX_FMT_NV21; //for 3rd party 1652 1653 if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) { 1654 LOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format); 1655 ret = UNKNOWN_ERROR; 1656 } else { 1657 mParameters.setPictureFormat(new_str_picture_format); 1658 } 1659 } 1660 1661 #ifdef SWP1_CAMERA_ADD_ADVANCED_FUNCTION 1662 //JPEG image quality 1663 int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY); 1664 LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality); 1665 /* we ignore bad values */ 1666 if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) { 1667 if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) { 1668 LOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality); 1669 ret = UNKNOWN_ERROR; 1670 } else { 1671 mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality); 1672 } 1673 } 1674 #else 1675 //JPEG image quality 1676 int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY); 1677 LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality); 1678 if (new_jpeg_quality < 0) { 1679 LOGW("JPEG-image quality is not specified or is negative, defaulting to 100"); 1680 new_jpeg_quality = 100; 1681 mParameters.set(CameraParameters::KEY_JPEG_QUALITY, "100"); 1682 } 1683 mSecCamera->setJpegQuality(new_jpeg_quality); 1684 #endif 1685 1686 // JPEG thumbnail size 1687 int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 1688 int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 1689 if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) { 1690 if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) { 1691 LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height); 1692 ret = UNKNOWN_ERROR; 1693 } else { 1694 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width); 1695 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, new_jpeg_thumbnail_height); 1696 } 1697 } 1698 1699 // frame rate 1700 int new_frame_rate = params.getPreviewFrameRate(); 1701 /* ignore any fps request, we're determine fps automatically based 1702 * on scene mode. don't return an error because it causes CTS failure. 1703 */ 1704 if (new_frame_rate != mParameters.getPreviewFrameRate()) { 1705 LOGW("WARN(%s): request for preview frame %d not allowed, != %d\n", 1706 __func__, new_frame_rate, mParameters.getPreviewFrameRate()); 1707 } 1708 1709 // rotation 1710 int new_rotation = params.getInt(CameraParameters::KEY_ROTATION); 1711 LOGV("%s : new_rotation %d", __func__, new_rotation); 1712 if (0 <= new_rotation) { 1713 LOGV("%s : set orientation:%d\n", __func__, new_rotation); 1714 if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) { 1715 LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation); 1716 ret = UNKNOWN_ERROR; 1717 } else { 1718 mParameters.set(CameraParameters::KEY_ROTATION, new_rotation); 1719 } 1720 } 1721 1722 // brightness 1723 int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1724 int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION); 1725 int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION); 1726 LOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation); 1727 if ((min_exposure_compensation <= new_exposure_compensation) && 1728 (max_exposure_compensation >= new_exposure_compensation)) { 1729 if (mSecCamera->setBrightness(new_exposure_compensation) < 0) { 1730 LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_exposure_compensation); 1731 ret = UNKNOWN_ERROR; 1732 } else { 1733 mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation); 1734 } 1735 } 1736 1737 // whitebalance 1738 const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE); 1739 LOGV("%s : new_white_str %s", __func__, new_white_str); 1740 if (new_white_str != NULL) { 1741 int new_white = -1; 1742 1743 if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO)) 1744 new_white = WHITE_BALANCE_AUTO; 1745 else if (!strcmp(new_white_str, 1746 CameraParameters::WHITE_BALANCE_DAYLIGHT)) 1747 new_white = WHITE_BALANCE_SUNNY; 1748 else if (!strcmp(new_white_str, 1749 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT)) 1750 new_white = WHITE_BALANCE_CLOUDY; 1751 else if (!strcmp(new_white_str, 1752 CameraParameters::WHITE_BALANCE_FLUORESCENT)) 1753 new_white = WHITE_BALANCE_FLUORESCENT; 1754 else if (!strcmp(new_white_str, 1755 CameraParameters::WHITE_BALANCE_INCANDESCENT)) 1756 new_white = WHITE_BALANCE_TUNGSTEN; 1757 else { 1758 LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent 1759 ret = UNKNOWN_ERROR; 1760 } 1761 1762 if (0 <= new_white) { 1763 if (mSecCamera->setWhiteBalance(new_white) < 0) { 1764 LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white); 1765 ret = UNKNOWN_ERROR; 1766 } else { 1767 mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str); 1768 } 1769 } 1770 } 1771 1772 // scene mode 1773 const char *new_scene_mode_str = params.get(CameraParameters::KEY_SCENE_MODE); 1774 const char *current_scene_mode_str = mParameters.get(CameraParameters::KEY_SCENE_MODE); 1775 1776 // fps range 1777 int new_min_fps = 0; 1778 int new_max_fps = 0; 1779 int current_min_fps, current_max_fps; 1780 params.getPreviewFpsRange(&new_min_fps, &new_max_fps); 1781 mParameters.getPreviewFpsRange(¤t_min_fps, ¤t_max_fps); 1782 /* our fps range is determined by the sensor, reject any request 1783 * that isn't exactly what we're already at. 1784 * but the check is performed when requesting only changing fps range 1785 */ 1786 if (new_scene_mode_str && current_scene_mode_str) { 1787 if (!strcmp(new_scene_mode_str, current_scene_mode_str)) { 1788 if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) { 1789 LOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed", 1790 __func__, new_min_fps, new_max_fps); 1791 LOGE("%s : current_min_fps = %d, current_max_fps = %d", 1792 __func__, current_min_fps, current_max_fps); 1793 ret = UNKNOWN_ERROR; 1794 } 1795 } 1796 } else { 1797 /* Check basic validation if scene mode is different */ 1798 if ((new_min_fps > new_max_fps) || 1799 (new_min_fps < 0) || (new_max_fps < 0)) 1800 ret = UNKNOWN_ERROR; 1801 } 1802 1803 if (new_scene_mode_str != NULL) { 1804 int new_scene_mode = -1; 1805 1806 const char *new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE); 1807 const char *new_focus_mode_str; 1808 1809 new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE); 1810 // fps range is (15000,30000) by default. 1811 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)"); 1812 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 1813 "15000,30000"); 1814 1815 if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) { 1816 new_scene_mode = SCENE_MODE_NONE; 1817 } else { 1818 // defaults for non-auto scene modes 1819 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) { 1820 new_focus_mode_str = CameraParameters::FOCUS_MODE_AUTO; 1821 } 1822 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1823 1824 if (!strcmp(new_scene_mode_str, 1825 CameraParameters::SCENE_MODE_PORTRAIT)) { 1826 new_scene_mode = SCENE_MODE_PORTRAIT; 1827 new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO; 1828 } else if (!strcmp(new_scene_mode_str, 1829 CameraParameters::SCENE_MODE_LANDSCAPE)) { 1830 new_scene_mode = SCENE_MODE_LANDSCAPE; 1831 } else if (!strcmp(new_scene_mode_str, 1832 CameraParameters::SCENE_MODE_SPORTS)) { 1833 new_scene_mode = SCENE_MODE_SPORTS; 1834 } else if (!strcmp(new_scene_mode_str, 1835 CameraParameters::SCENE_MODE_PARTY)) { 1836 new_scene_mode = SCENE_MODE_PARTY_INDOOR; 1837 new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO; 1838 } else if ((!strcmp(new_scene_mode_str, 1839 CameraParameters::SCENE_MODE_BEACH)) || 1840 (!strcmp(new_scene_mode_str, 1841 CameraParameters::SCENE_MODE_SNOW))) { 1842 new_scene_mode = SCENE_MODE_BEACH_SNOW; 1843 } else if (!strcmp(new_scene_mode_str, 1844 CameraParameters::SCENE_MODE_SUNSET)) { 1845 new_scene_mode = SCENE_MODE_SUNSET; 1846 } else if (!strcmp(new_scene_mode_str, 1847 CameraParameters::SCENE_MODE_NIGHT)) { 1848 new_scene_mode = SCENE_MODE_NIGHTSHOT; 1849 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)"); 1850 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 1851 "4000,30000"); 1852 } else if (!strcmp(new_scene_mode_str, 1853 CameraParameters::SCENE_MODE_FIREWORKS)) { 1854 new_scene_mode = SCENE_MODE_FIREWORKS; 1855 } else if (!strcmp(new_scene_mode_str, 1856 CameraParameters::SCENE_MODE_CANDLELIGHT)) { 1857 new_scene_mode = SCENE_MODE_CANDLE_LIGHT; 1858 } else { 1859 LOGE("%s::unmatched scene_mode(%s)", 1860 __func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto 1861 ret = UNKNOWN_ERROR; 1862 } 1863 } 1864 1865 // focus mode 1866 if (new_focus_mode_str != NULL) { 1867 int new_focus_mode = -1; 1868 1869 if (!strcmp(new_focus_mode_str, 1870 CameraParameters::FOCUS_MODE_AUTO)) { 1871 new_focus_mode = FOCUS_MODE_AUTO; 1872 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, 1873 BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR); 1874 } 1875 else if (!strcmp(new_focus_mode_str, 1876 CameraParameters::FOCUS_MODE_MACRO)) { 1877 new_focus_mode = FOCUS_MODE_MACRO; 1878 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, 1879 BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR); 1880 } 1881 else if (!strcmp(new_focus_mode_str, 1882 CameraParameters::FOCUS_MODE_INFINITY)) { 1883 new_focus_mode = FOCUS_MODE_INFINITY; 1884 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, 1885 BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR); 1886 } 1887 else { 1888 LOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str); 1889 ret = UNKNOWN_ERROR; 1890 } 1891 1892 if (0 <= new_focus_mode) { 1893 if (mSecCamera->setFocusMode(new_focus_mode) < 0) { 1894 LOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode); 1895 ret = UNKNOWN_ERROR; 1896 } else { 1897 mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str); 1898 } 1899 } 1900 } 1901 1902 // flash.. 1903 if (new_flash_mode_str != NULL) { 1904 int new_flash_mode = -1; 1905 1906 if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_OFF)) 1907 new_flash_mode = FLASH_MODE_OFF; 1908 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_AUTO)) 1909 new_flash_mode = FLASH_MODE_AUTO; 1910 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_ON)) 1911 new_flash_mode = FLASH_MODE_ON; 1912 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_TORCH)) 1913 new_flash_mode = FLASH_MODE_TORCH; 1914 else { 1915 LOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye 1916 ret = UNKNOWN_ERROR; 1917 } 1918 if (0 <= new_flash_mode) { 1919 if (mSecCamera->setFlashMode(new_flash_mode) < 0) { 1920 LOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode); 1921 ret = UNKNOWN_ERROR; 1922 } else { 1923 mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str); 1924 } 1925 } 1926 } 1927 1928 // scene.. 1929 if (0 <= new_scene_mode) { 1930 if (mSecCamera->setSceneMode(new_scene_mode) < 0) { 1931 LOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode); 1932 ret = UNKNOWN_ERROR; 1933 } else { 1934 mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str); 1935 } 1936 } 1937 } 1938 1939 // --------------------------------------------------------------------------- 1940 1941 // image effect 1942 const char *new_image_effect_str = params.get(CameraParameters::KEY_EFFECT); 1943 if (new_image_effect_str != NULL) { 1944 1945 int new_image_effect = -1; 1946 1947 if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NONE)) 1948 new_image_effect = IMAGE_EFFECT_NONE; 1949 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_MONO)) 1950 new_image_effect = IMAGE_EFFECT_BNW; 1951 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_SEPIA)) 1952 new_image_effect = IMAGE_EFFECT_SEPIA; 1953 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_AQUA)) 1954 new_image_effect = IMAGE_EFFECT_AQUA; 1955 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NEGATIVE)) 1956 new_image_effect = IMAGE_EFFECT_NEGATIVE; 1957 else { 1958 //posterize, whiteboard, blackboard, solarize 1959 LOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str); 1960 ret = UNKNOWN_ERROR; 1961 } 1962 1963 if (new_image_effect >= 0) { 1964 if (mSecCamera->setImageEffect(new_image_effect) < 0) { 1965 LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect); 1966 ret = UNKNOWN_ERROR; 1967 } else { 1968 const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT); 1969 1970 if (old_image_effect_str) { 1971 if (strcmp(old_image_effect_str, new_image_effect_str)) { 1972 setSkipFrame(EFFECT_SKIP_FRAME); 1973 } 1974 } 1975 1976 mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str); 1977 } 1978 } 1979 } 1980 1981 //vt mode 1982 int new_vtmode = mInternalParameters.getInt("vtmode"); 1983 if (0 <= new_vtmode) { 1984 if (mSecCamera->setVTmode(new_vtmode) < 0) { 1985 LOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __func__, new_vtmode); 1986 ret = UNKNOWN_ERROR; 1987 } 1988 } 1989 1990 //contrast 1991 int new_contrast = mInternalParameters.getInt("contrast"); 1992 1993 if (0 <= new_contrast) { 1994 if (mSecCamera->setContrast(new_contrast) < 0) { 1995 LOGE("ERR(%s):Fail on mSecCamera->setContrast(%d)", __func__, new_contrast); 1996 ret = UNKNOWN_ERROR; 1997 } 1998 } 1999 2000 //WDR 2001 int new_wdr = mInternalParameters.getInt("wdr"); 2002 2003 if (0 <= new_wdr) { 2004 if (mSecCamera->setWDR(new_wdr) < 0) { 2005 LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr); 2006 ret = UNKNOWN_ERROR; 2007 } 2008 } 2009 2010 //anti shake 2011 int new_anti_shake = mInternalParameters.getInt("anti-shake"); 2012 2013 if (0 <= new_anti_shake) { 2014 if (mSecCamera->setAntiShake(new_anti_shake) < 0) { 2015 LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake); 2016 ret = UNKNOWN_ERROR; 2017 } 2018 } 2019 2020 // gps latitude 2021 const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE); 2022 if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) { 2023 LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str); 2024 ret = UNKNOWN_ERROR; 2025 } else { 2026 if (new_gps_latitude_str) { 2027 mParameters.set(CameraParameters::KEY_GPS_LATITUDE, new_gps_latitude_str); 2028 } else { 2029 mParameters.remove(CameraParameters::KEY_GPS_LATITUDE); 2030 } 2031 } 2032 2033 // gps longitude 2034 const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE); 2035 2036 if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) { 2037 LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str); 2038 ret = UNKNOWN_ERROR; 2039 } else { 2040 if (new_gps_longitude_str) { 2041 mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, new_gps_longitude_str); 2042 } else { 2043 mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE); 2044 } 2045 } 2046 2047 // gps altitude 2048 const char *new_gps_altitude_str = params.get(CameraParameters::KEY_GPS_ALTITUDE); 2049 2050 if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) { 2051 LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str); 2052 ret = UNKNOWN_ERROR; 2053 } else { 2054 if (new_gps_altitude_str) { 2055 mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, new_gps_altitude_str); 2056 } else { 2057 mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE); 2058 } 2059 } 2060 2061 // gps timestamp 2062 const char *new_gps_timestamp_str = params.get(CameraParameters::KEY_GPS_TIMESTAMP); 2063 2064 if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) { 2065 LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str); 2066 ret = UNKNOWN_ERROR; 2067 } else { 2068 if (new_gps_timestamp_str) { 2069 mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, new_gps_timestamp_str); 2070 } else { 2071 mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP); 2072 } 2073 } 2074 2075 // gps processing method 2076 const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 2077 2078 if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) { 2079 LOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str); 2080 ret = UNKNOWN_ERROR; 2081 } else { 2082 if (new_gps_processing_method_str) { 2083 mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, new_gps_processing_method_str); 2084 } else { 2085 mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD); 2086 } 2087 } 2088 2089 // Recording size 2090 int new_recording_width = mInternalParameters.getInt("recording-size-width"); 2091 int new_recording_height= mInternalParameters.getInt("recording-size-height"); 2092 2093 if (0 < new_recording_width && 0 < new_recording_height) { 2094 if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) { 2095 LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_recording_width, new_recording_height); 2096 ret = UNKNOWN_ERROR; 2097 } 2098 } else { 2099 if (mSecCamera->setRecordingSize(new_preview_width, new_preview_height) < 0) { 2100 LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_preview_width, new_preview_height); 2101 ret = UNKNOWN_ERROR; 2102 } 2103 } 2104 2105 //gamma 2106 const char *new_gamma_str = mInternalParameters.get("video_recording_gamma"); 2107 2108 if (new_gamma_str != NULL) { 2109 int new_gamma = -1; 2110 if (!strcmp(new_gamma_str, "off")) 2111 new_gamma = GAMMA_OFF; 2112 else if (!strcmp(new_gamma_str, "on")) 2113 new_gamma = GAMMA_ON; 2114 else { 2115 LOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str); 2116 ret = UNKNOWN_ERROR; 2117 } 2118 2119 if (0 <= new_gamma) { 2120 if (mSecCamera->setGamma(new_gamma) < 0) { 2121 LOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma); 2122 ret = UNKNOWN_ERROR; 2123 } 2124 } 2125 } 2126 2127 //slow ae 2128 const char *new_slow_ae_str = mInternalParameters.get("slow_ae"); 2129 2130 if (new_slow_ae_str != NULL) { 2131 int new_slow_ae = -1; 2132 2133 if (!strcmp(new_slow_ae_str, "off")) 2134 new_slow_ae = SLOW_AE_OFF; 2135 else if (!strcmp(new_slow_ae_str, "on")) 2136 new_slow_ae = SLOW_AE_ON; 2137 else { 2138 LOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str); 2139 ret = UNKNOWN_ERROR; 2140 } 2141 2142 if (0 <= new_slow_ae) { 2143 if (mSecCamera->setSlowAE(new_slow_ae) < 0) { 2144 LOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae); 2145 ret = UNKNOWN_ERROR; 2146 } 2147 } 2148 } 2149 2150 /*Camcorder fix fps*/ 2151 int new_sensor_mode = mInternalParameters.getInt("cam_mode"); 2152 2153 if (0 <= new_sensor_mode) { 2154 if (mSecCamera->setSensorMode(new_sensor_mode) < 0) { 2155 LOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode); 2156 ret = UNKNOWN_ERROR; 2157 } 2158 } else { 2159 new_sensor_mode=0; 2160 } 2161 2162 /*Shot mode*/ 2163 int new_shot_mode = mInternalParameters.getInt("shot_mode"); 2164 2165 if (0 <= new_shot_mode) { 2166 if (mSecCamera->setShotMode(new_shot_mode) < 0) { 2167 LOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode); 2168 ret = UNKNOWN_ERROR; 2169 } 2170 } else { 2171 new_shot_mode=0; 2172 } 2173 2174 //blur for Video call 2175 int new_blur_level = mInternalParameters.getInt("blur"); 2176 2177 if (0 <= new_blur_level) { 2178 if (mSecCamera->setBlur(new_blur_level) < 0) { 2179 LOGE("ERR(%s):Fail on mSecCamera->setBlur(%d)", __func__, new_blur_level); 2180 ret = UNKNOWN_ERROR; 2181 } 2182 } 2183 2184 2185 // chk_dataline 2186 int new_dataline = mInternalParameters.getInt("chk_dataline"); 2187 2188 if (0 <= new_dataline) { 2189 if (mSecCamera->setDataLineCheck(new_dataline) < 0) { 2190 LOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline); 2191 ret = UNKNOWN_ERROR; 2192 } 2193 } 2194 LOGV("%s return ret = %d", __func__, ret); 2195 2196 return ret; 2197 } 2198 2199 CameraParameters CameraHardwareSec::getParameters() const 2200 { 2201 LOGV("%s :", __func__); 2202 return mParameters; 2203 } 2204 2205 status_t CameraHardwareSec::sendCommand(int32_t command, int32_t arg1, int32_t arg2) 2206 { 2207 return BAD_VALUE; 2208 } 2209 2210 void CameraHardwareSec::release() 2211 { 2212 LOGV("%s :", __func__); 2213 2214 /* shut down any threads we have that might be running. do it here 2215 * instead of the destructor. we're guaranteed to be on another thread 2216 * than the ones below. if we used the destructor, since the threads 2217 * have a reference to this object, we could wind up trying to wait 2218 * for ourself to exit, which is a deadlock. 2219 */ 2220 if (mPreviewThread != NULL) { 2221 mPreviewThread->requestExitAndWait(); 2222 mPreviewThread.clear(); 2223 } 2224 if (mAutoFocusThread != NULL) { 2225 /* this thread is normally already in it's threadLoop but blocked 2226 * on the condition variable. signal it so it wakes up and can exit. 2227 */ 2228 mAutoFocusThread->requestExit(); 2229 mExitAutoFocusThread = true; 2230 mCondition.signal(); 2231 mAutoFocusThread->requestExitAndWait(); 2232 mAutoFocusThread.clear(); 2233 } 2234 if (mPictureThread != NULL) { 2235 mPictureThread->requestExitAndWait(); 2236 mPictureThread.clear(); 2237 } 2238 if (mRawHeap != NULL) 2239 mRawHeap.clear(); 2240 2241 if (mJpegHeap != NULL) 2242 mJpegHeap.clear(); 2243 2244 if (mPreviewHeap != NULL) 2245 mPreviewHeap.clear(); 2246 2247 if (mRecordHeap != NULL) 2248 mRecordHeap.clear(); 2249 2250 #if defined(BOARD_USES_OVERLAY) 2251 if (mUseOverlay) { 2252 mOverlay->destroy(); 2253 mUseOverlay = false; 2254 mOverlay = NULL; 2255 } 2256 #endif 2257 2258 /* close after all the heaps are cleared since those 2259 * could have dup'd our file descriptor. 2260 */ 2261 mSecCamera->DeinitCamera(); 2262 mSecCamera = NULL; 2263 2264 } 2265 2266 wp<CameraHardwareInterface> CameraHardwareSec::singleton; 2267 2268 sp<CameraHardwareInterface> CameraHardwareSec::createInstance(int cameraId) 2269 { 2270 LOGV("%s :", __func__); 2271 if (singleton != 0) { 2272 sp<CameraHardwareInterface> hardware = singleton.promote(); 2273 if (hardware != 0) { 2274 return hardware; 2275 } 2276 } 2277 sp<CameraHardwareInterface> hardware(new CameraHardwareSec(cameraId)); 2278 singleton = hardware; 2279 return hardware; 2280 } 2281 2282 static CameraInfo sCameraInfo[] = { 2283 { 2284 CAMERA_FACING_BACK, 2285 90, /* orientation */ 2286 }, 2287 { 2288 CAMERA_FACING_FRONT, 2289 270, /* orientation */ 2290 } 2291 }; 2292 2293 extern "C" int HAL_getNumberOfCameras() 2294 { 2295 return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]); 2296 } 2297 2298 extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo *cameraInfo) 2299 { 2300 memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo)); 2301 } 2302 2303 extern "C" sp<CameraHardwareInterface> HAL_openCameraHardware(int cameraId) 2304 { 2305 return CameraHardwareSec::createInstance(cameraId); 2306 } 2307 2308 }; // namespace android 2309
