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 #include <camera/Camera.h> 28 #include <media/stagefright/MetadataBufferType.h> 29 30 #define VIDEO_COMMENT_MARKER_H 0xFFBE 31 #define VIDEO_COMMENT_MARKER_L 0xFFBF 32 #define VIDEO_COMMENT_MARKER_LENGTH 4 33 #define JPEG_EOI_MARKER 0xFFD9 34 #define HIBYTE(x) (((x) >> 8) & 0xFF) 35 #define LOBYTE(x) ((x) & 0xFF) 36 37 #define BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR "0.10,1.20,Infinity" 38 #define BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR "0.10,0.20,Infinity" 39 #define BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR "0.10,1.20,Infinity" 40 #define FRONT_CAMERA_FOCUS_DISTANCES_STR "0.20,0.25,Infinity" 41 42 // FIXME: 43 // -- The actual preview color is set to YV12. The preview frames 44 // returned via preview callback must be generated by color 45 // conversion if the requested preview color format for the 46 // preview frames is _not_ YV12. The reason that YV12 is used 47 // for actual preview is because that is the only color format 48 // supported by gralloc. Matching the preview cor format with 49 // gralloc color format improves performance since no color 50 // conversion is needed for preview. 51 // 52 // -- we only support two preview color formats that client 53 // applications can set: NV21 and YUV420/YV12. 54 55 namespace android { 56 57 struct addrs { 58 uint32_t type; // make sure that this is 4 byte. 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 gralloc_module_t const* CameraHardwareSec::mGrallocHal; 75 76 CameraHardwareSec::CameraHardwareSec(int cameraId, camera_device_t *dev) 77 : 78 mCaptureInProgress(false), 79 mParameters(), 80 mCameraSensorName(NULL), 81 mSkipFrame(0), 82 mNotifyCb(0), 83 mDataCb(0), 84 mDataCbTimestamp(0), 85 mCallbackCookie(0), 86 mMsgEnabled(0), 87 mRecordRunning(false), 88 mPostViewWidth(0), 89 mPostViewHeight(0), 90 mPostViewSize(0), 91 mHalDevice(dev) 92 { 93 LOGV("%s :", __func__); 94 int ret = 0; 95 96 mPreviewWindow = NULL; 97 mSecCamera = SecCamera::createInstance(); 98 99 mRawHeap = NULL; 100 mPreviewHeap = NULL; 101 mRecordHeap = NULL; 102 103 if (!mGrallocHal) { 104 ret = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, (const hw_module_t **)&mGrallocHal); 105 if (ret) 106 LOGE("ERR(%s):Fail on loading gralloc HAL", __func__); 107 } 108 109 ret = mSecCamera->initCamera(cameraId); 110 if (ret < 0) { 111 LOGE("ERR(%s):Fail on mSecCamera init", __func__); 112 } 113 114 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); 115 LOGV("mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d", 116 mPostViewWidth,mPostViewHeight,mPostViewSize); 117 118 initDefaultParameters(cameraId); 119 120 mExitAutoFocusThread = false; 121 mExitPreviewThread = false; 122 /* whether the PreviewThread is active in preview or stopped. we 123 * create the thread but it is initially in stopped state. 124 */ 125 mPreviewRunning = false; 126 mPreviewStartDeferred = false; 127 mPreviewThread = new PreviewThread(this); 128 mAutoFocusThread = new AutoFocusThread(this); 129 mPictureThread = new PictureThread(this); 130 } 131 132 int CameraHardwareSec::getCameraId() const 133 { 134 return mSecCamera->getCameraId(); 135 } 136 137 void CameraHardwareSec::initDefaultParameters(int cameraId) 138 { 139 if (mSecCamera == NULL) { 140 LOGE("ERR(%s):mSecCamera object is NULL", __func__); 141 return; 142 } 143 144 CameraParameters p; 145 CameraParameters ip; 146 147 mCameraSensorName = mSecCamera->getCameraSensorName(); 148 LOGV("CameraSensorName: %s", mCameraSensorName); 149 150 int preview_max_width = 0; 151 int preview_max_height = 0; 152 int snapshot_max_width = 0; 153 int snapshot_max_height = 0; 154 155 if (cameraId == SecCamera::CAMERA_ID_BACK) { 156 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 157 "720x480,640x480,352x288,176x144"); 158 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 159 "2560x1920,2048x1536,1600x1200,1280x960,640x480"); 160 } else { 161 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES, 162 "640x480,320x240,176x144"); 163 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES, 164 "640x480"); 165 } 166 167 p.getSupportedPreviewSizes(mSupportedPreviewSizes); 168 169 // If these fail, then we are using an invalid cameraId and we'll leave the 170 // sizes at zero to catch the error. 171 if (mSecCamera->getPreviewMaxSize(&preview_max_width, 172 &preview_max_height) < 0) 173 LOGE("getPreviewMaxSize fail (%d / %d) \n", 174 preview_max_width, preview_max_height); 175 if (mSecCamera->getSnapshotMaxSize(&snapshot_max_width, 176 &snapshot_max_height) < 0) 177 LOGE("getSnapshotMaxSize fail (%d / %d) \n", 178 snapshot_max_width, snapshot_max_height); 179 String8 previewColorString; 180 previewColorString = CameraParameters::PIXEL_FORMAT_YUV420SP; 181 previewColorString.append(","); 182 previewColorString.append(CameraParameters::PIXEL_FORMAT_YUV420P); 183 p.setPreviewFormat(CameraParameters::PIXEL_FORMAT_YUV420SP); 184 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FORMATS, previewColorString.string()); 185 p.set(CameraParameters::KEY_VIDEO_FRAME_FORMAT, CameraParameters::PIXEL_FORMAT_YUV420P); 186 p.setPreviewSize(preview_max_width, preview_max_height); 187 188 p.setPictureFormat(CameraParameters::PIXEL_FORMAT_JPEG); 189 p.setPictureSize(snapshot_max_width, snapshot_max_height); 190 p.set(CameraParameters::KEY_JPEG_QUALITY, "100"); // maximum quality 191 p.set(CameraParameters::KEY_SUPPORTED_PICTURE_FORMATS, 192 CameraParameters::PIXEL_FORMAT_JPEG); 193 194 String8 parameterString; 195 196 if (cameraId == SecCamera::CAMERA_ID_BACK) { 197 parameterString = CameraParameters::FOCUS_MODE_AUTO; 198 parameterString.append(","); 199 parameterString.append(CameraParameters::FOCUS_MODE_INFINITY); 200 parameterString.append(","); 201 parameterString.append(CameraParameters::FOCUS_MODE_MACRO); 202 p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 203 parameterString.string()); 204 p.set(CameraParameters::KEY_FOCUS_MODE, 205 CameraParameters::FOCUS_MODE_AUTO); 206 p.set(CameraParameters::KEY_FOCUS_DISTANCES, 207 BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR); 208 p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 209 "320x240,0x0"); 210 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "320"); 211 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "240"); 212 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "30"); 213 p.setPreviewFrameRate(30); 214 } else { 215 parameterString = CameraParameters::FOCUS_MODE_FIXED; 216 p.set(CameraParameters::KEY_SUPPORTED_FOCUS_MODES, 217 parameterString.string()); 218 p.set(CameraParameters::KEY_FOCUS_MODE, 219 CameraParameters::FOCUS_MODE_FIXED); 220 p.set(CameraParameters::KEY_FOCUS_DISTANCES, 221 FRONT_CAMERA_FOCUS_DISTANCES_STR); 222 p.set(CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES, 223 "160x120,0x0"); 224 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, "160"); 225 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, "120"); 226 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FRAME_RATES, "15"); 227 p.setPreviewFrameRate(15); 228 } 229 230 parameterString = CameraParameters::EFFECT_NONE; 231 parameterString.append(","); 232 parameterString.append(CameraParameters::EFFECT_MONO); 233 parameterString.append(","); 234 parameterString.append(CameraParameters::EFFECT_NEGATIVE); 235 parameterString.append(","); 236 parameterString.append(CameraParameters::EFFECT_SEPIA); 237 p.set(CameraParameters::KEY_SUPPORTED_EFFECTS, parameterString.string()); 238 239 if (cameraId == SecCamera::CAMERA_ID_BACK) { 240 parameterString = CameraParameters::FLASH_MODE_ON; 241 parameterString.append(","); 242 parameterString.append(CameraParameters::FLASH_MODE_OFF); 243 parameterString.append(","); 244 parameterString.append(CameraParameters::FLASH_MODE_AUTO); 245 parameterString.append(","); 246 parameterString.append(CameraParameters::FLASH_MODE_TORCH); 247 p.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, 248 parameterString.string()); 249 p.set(CameraParameters::KEY_FLASH_MODE, 250 CameraParameters::FLASH_MODE_OFF); 251 252 parameterString = CameraParameters::SCENE_MODE_AUTO; 253 parameterString.append(","); 254 parameterString.append(CameraParameters::SCENE_MODE_PORTRAIT); 255 parameterString.append(","); 256 parameterString.append(CameraParameters::SCENE_MODE_LANDSCAPE); 257 parameterString.append(","); 258 parameterString.append(CameraParameters::SCENE_MODE_NIGHT); 259 parameterString.append(","); 260 parameterString.append(CameraParameters::SCENE_MODE_BEACH); 261 parameterString.append(","); 262 parameterString.append(CameraParameters::SCENE_MODE_SNOW); 263 parameterString.append(","); 264 parameterString.append(CameraParameters::SCENE_MODE_SUNSET); 265 parameterString.append(","); 266 parameterString.append(CameraParameters::SCENE_MODE_FIREWORKS); 267 parameterString.append(","); 268 parameterString.append(CameraParameters::SCENE_MODE_SPORTS); 269 parameterString.append(","); 270 parameterString.append(CameraParameters::SCENE_MODE_PARTY); 271 parameterString.append(","); 272 parameterString.append(CameraParameters::SCENE_MODE_CANDLELIGHT); 273 p.set(CameraParameters::KEY_SUPPORTED_SCENE_MODES, 274 parameterString.string()); 275 p.set(CameraParameters::KEY_SCENE_MODE, 276 CameraParameters::SCENE_MODE_AUTO); 277 278 /* we have two ranges, 4-30fps for night mode and 279 * 15-30fps for all others 280 */ 281 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)"); 282 p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "15000,30000"); 283 284 p.set(CameraParameters::KEY_FOCAL_LENGTH, "3.43"); 285 } else { 286 p.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(7500,30000)"); 287 p.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, "7500,30000"); 288 289 p.set(CameraParameters::KEY_FOCAL_LENGTH, "0.9"); 290 } 291 292 parameterString = CameraParameters::WHITE_BALANCE_AUTO; 293 parameterString.append(","); 294 parameterString.append(CameraParameters::WHITE_BALANCE_INCANDESCENT); 295 parameterString.append(","); 296 parameterString.append(CameraParameters::WHITE_BALANCE_FLUORESCENT); 297 parameterString.append(","); 298 parameterString.append(CameraParameters::WHITE_BALANCE_DAYLIGHT); 299 parameterString.append(","); 300 parameterString.append(CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT); 301 p.set(CameraParameters::KEY_SUPPORTED_WHITE_BALANCE, 302 parameterString.string()); 303 304 ip.set("sharpness-min", 0); 305 ip.set("sharpness-max", 4); 306 ip.set("saturation-min", 0); 307 ip.set("saturation-max", 4); 308 ip.set("contrast-min", 0); 309 ip.set("contrast-max", 4); 310 311 p.set(CameraParameters::KEY_JPEG_THUMBNAIL_QUALITY, "100"); 312 313 p.set(CameraParameters::KEY_ROTATION, 0); 314 p.set(CameraParameters::KEY_WHITE_BALANCE, CameraParameters::WHITE_BALANCE_AUTO); 315 316 p.set(CameraParameters::KEY_EFFECT, CameraParameters::EFFECT_NONE); 317 318 ip.set("sharpness", SHARPNESS_DEFAULT); 319 ip.set("contrast", CONTRAST_DEFAULT); 320 ip.set("saturation", SATURATION_DEFAULT); 321 ip.set("iso", "auto"); 322 ip.set("metering", "center"); 323 324 ip.set("wdr", 0); 325 ip.set("chk_dataline", 0); 326 if (cameraId == SecCamera::CAMERA_ID_FRONT) { 327 ip.set("vtmode", 0); 328 ip.set("blur", 0); 329 } 330 331 p.set(CameraParameters::KEY_HORIZONTAL_VIEW_ANGLE, "51.2"); 332 p.set(CameraParameters::KEY_VERTICAL_VIEW_ANGLE, "39.4"); 333 334 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, "0"); 335 p.set(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION, "4"); 336 p.set(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION, "-4"); 337 p.set(CameraParameters::KEY_EXPOSURE_COMPENSATION_STEP, "0.5"); 338 339 mParameters = p; 340 mInternalParameters = ip; 341 342 /* make sure mSecCamera has all the settings we do. applications 343 * aren't required to call setParameters themselves (only if they 344 * want to change something. 345 */ 346 setParameters(p); 347 mSecCamera->setISO(ISO_AUTO); 348 mSecCamera->setMetering(METERING_CENTER); 349 mSecCamera->setContrast(CONTRAST_DEFAULT); 350 mSecCamera->setSharpness(SHARPNESS_DEFAULT); 351 mSecCamera->setSaturation(SATURATION_DEFAULT); 352 if (cameraId == SecCamera::CAMERA_ID_BACK) 353 mSecCamera->setFrameRate(30); 354 else 355 mSecCamera->setFrameRate(15); 356 } 357 358 CameraHardwareSec::~CameraHardwareSec() 359 { 360 LOGV("%s", __func__); 361 mSecCamera->DeinitCamera(); 362 } 363 364 status_t CameraHardwareSec::setPreviewWindow(preview_stream_ops *w) 365 { 366 int min_bufs; 367 368 mPreviewWindow = w; 369 LOGV("%s: mPreviewWindow %p", __func__, mPreviewWindow); 370 371 if (!w) { 372 LOGE("preview window is NULL!"); 373 return OK; 374 } 375 376 mPreviewLock.lock(); 377 378 if (mPreviewRunning && !mPreviewStartDeferred) { 379 LOGI("stop preview (window change)"); 380 stopPreviewInternal(); 381 } 382 383 if (w->get_min_undequeued_buffer_count(w, &min_bufs)) { 384 LOGE("%s: could not retrieve min undequeued buffer count", __func__); 385 return INVALID_OPERATION; 386 } 387 388 if (min_bufs >= kBufferCount) { 389 LOGE("%s: min undequeued buffer count %d is too high (expecting at most %d)", __func__, 390 min_bufs, kBufferCount - 1); 391 } 392 393 LOGV("%s: setting buffer count to %d", __func__, kBufferCount); 394 if (w->set_buffer_count(w, kBufferCount)) { 395 LOGE("%s: could not set buffer count", __func__); 396 return INVALID_OPERATION; 397 } 398 399 int preview_width; 400 int preview_height; 401 mParameters.getPreviewSize(&preview_width, &preview_height); 402 int hal_pixel_format = HAL_PIXEL_FORMAT_YV12; 403 404 const char *str_preview_format = mParameters.getPreviewFormat(); 405 LOGV("%s: preview format %s", __func__, str_preview_format); 406 407 if (w->set_usage(w, GRALLOC_USAGE_SW_WRITE_OFTEN)) { 408 LOGE("%s: could not set usage on gralloc buffer", __func__); 409 return INVALID_OPERATION; 410 } 411 412 if (w->set_buffers_geometry(w, 413 preview_width, preview_height, 414 hal_pixel_format)) { 415 LOGE("%s: could not set buffers geometry to %s", 416 __func__, str_preview_format); 417 return INVALID_OPERATION; 418 } 419 420 if (mPreviewRunning && mPreviewStartDeferred) { 421 LOGV("start/resume preview"); 422 status_t ret = startPreviewInternal(); 423 if (ret == OK) { 424 mPreviewStartDeferred = false; 425 mPreviewCondition.signal(); 426 } 427 } 428 mPreviewLock.unlock(); 429 430 return OK; 431 } 432 433 void CameraHardwareSec::setCallbacks(camera_notify_callback notify_cb, 434 camera_data_callback data_cb, 435 camera_data_timestamp_callback data_cb_timestamp, 436 camera_request_memory get_memory, 437 void *user) 438 { 439 mNotifyCb = notify_cb; 440 mDataCb = data_cb; 441 mDataCbTimestamp = data_cb_timestamp; 442 mGetMemoryCb = get_memory; 443 mCallbackCookie = user; 444 } 445 446 void CameraHardwareSec::enableMsgType(int32_t msgType) 447 { 448 LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x", 449 __func__, msgType, mMsgEnabled); 450 mMsgEnabled |= msgType; 451 452 LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); 453 } 454 455 void CameraHardwareSec::disableMsgType(int32_t msgType) 456 { 457 LOGV("%s : msgType = 0x%x, mMsgEnabled before = 0x%x", 458 __func__, msgType, mMsgEnabled); 459 mMsgEnabled &= ~msgType; 460 LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); 461 } 462 463 bool CameraHardwareSec::msgTypeEnabled(int32_t msgType) 464 { 465 return (mMsgEnabled & msgType); 466 } 467 468 // --------------------------------------------------------------------------- 469 void CameraHardwareSec::setSkipFrame(int frame) 470 { 471 Mutex::Autolock lock(mSkipFrameLock); 472 if (frame < mSkipFrame) 473 return; 474 475 mSkipFrame = frame; 476 } 477 478 int CameraHardwareSec::previewThreadWrapper() 479 { 480 LOGI("%s: starting", __func__); 481 while (1) { 482 mPreviewLock.lock(); 483 while (!mPreviewRunning) { 484 LOGI("%s: calling mSecCamera->stopPreview() and waiting", __func__); 485 mSecCamera->stopPreview(); 486 /* signal that we're stopping */ 487 mPreviewStoppedCondition.signal(); 488 mPreviewCondition.wait(mPreviewLock); 489 LOGI("%s: return from wait", __func__); 490 } 491 mPreviewLock.unlock(); 492 493 if (mExitPreviewThread) { 494 LOGI("%s: exiting", __func__); 495 mSecCamera->stopPreview(); 496 return 0; 497 } 498 previewThread(); 499 } 500 } 501 502 int CameraHardwareSec::previewThread() 503 { 504 int index; 505 nsecs_t timestamp; 506 unsigned int phyYAddr; 507 unsigned int phyCAddr; 508 struct addrs *addrs; 509 510 index = mSecCamera->getPreview(); 511 if (index < 0) { 512 LOGE("ERR(%s):Fail on SecCamera->getPreview()", __func__); 513 return UNKNOWN_ERROR; 514 } 515 516 // LOGV("%s: index %d", __func__, index); 517 518 mSkipFrameLock.lock(); 519 if (mSkipFrame > 0) { 520 mSkipFrame--; 521 mSkipFrameLock.unlock(); 522 LOGV("%s: index %d skipping frame", __func__, index); 523 return NO_ERROR; 524 } 525 mSkipFrameLock.unlock(); 526 527 timestamp = systemTime(SYSTEM_TIME_MONOTONIC); 528 529 phyYAddr = mSecCamera->getPhyAddrY(index); 530 phyCAddr = mSecCamera->getPhyAddrC(index); 531 532 if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) { 533 LOGE("ERR(%s):Fail on SecCamera getPhyAddr Y addr = %0x C addr = %0x", 534 __func__, phyYAddr, phyCAddr); 535 return UNKNOWN_ERROR; 536 } 537 538 int width, height, frame_size, offset; 539 540 mSecCamera->getPreviewSize(&width, &height, &frame_size); 541 542 offset = frame_size * index; 543 544 if (mPreviewWindow && mGrallocHal) { 545 buffer_handle_t *buf_handle; 546 int stride; 547 if (0 != mPreviewWindow->dequeue_buffer(mPreviewWindow, &buf_handle, &stride)) { 548 LOGE("Could not dequeue gralloc buffer!\n"); 549 goto callbacks; 550 } 551 552 void *vaddr; 553 if (!mGrallocHal->lock(mGrallocHal, 554 *buf_handle, 555 GRALLOC_USAGE_SW_WRITE_OFTEN, 556 0, 0, width, height, &vaddr)) { 557 char *frame = ((char *)mPreviewHeap->data) + offset; 558 559 // the code below assumes YUV, not RGB 560 { 561 int h; 562 char *src = frame; 563 char *ptr = (char *)vaddr; 564 565 // Copy the Y plane, while observing the stride 566 for (h = 0; h < height; h++) { 567 memcpy(ptr, src, width); 568 ptr += stride; 569 src += width; 570 } 571 572 { 573 // U 574 char *v = ptr; 575 ptr += stride * height / 4; 576 for (h = 0; h < height / 2; h++) { 577 memcpy(ptr, src, width / 2); 578 ptr += stride / 2; 579 src += width / 2; 580 } 581 // V 582 ptr = v; 583 for (h = 0; h < height / 2; h++) { 584 memcpy(ptr, src, width / 2); 585 ptr += stride / 2; 586 src += width / 2; 587 } 588 } 589 } 590 591 mGrallocHal->unlock(mGrallocHal, *buf_handle); 592 } 593 else 594 LOGE("%s: could not obtain gralloc buffer", __func__); 595 596 if (0 != mPreviewWindow->enqueue_buffer(mPreviewWindow, buf_handle)) { 597 LOGE("Could not enqueue gralloc buffer!\n"); 598 goto callbacks; 599 } 600 } 601 602 callbacks: 603 // Notify the client of a new frame. 604 if (mMsgEnabled & CAMERA_MSG_PREVIEW_FRAME) { 605 const char * preview_format = mParameters.getPreviewFormat(); 606 if (!strcmp(preview_format, CameraParameters::PIXEL_FORMAT_YUV420SP)) { 607 // Color conversion from YUV420 to NV21 608 char *vu = ((char *)mPreviewHeap->data) + offset + width * height; 609 const int uv_size = (width * height) >> 1; 610 char saved_uv[uv_size]; 611 memcpy(saved_uv, vu, uv_size); 612 char *u = saved_uv; 613 char *v = u + (uv_size >> 1); 614 615 int h = 0; 616 while (h < width * height / 4) { 617 *vu++ = *v++; 618 *vu++ = *u++; 619 ++h; 620 } 621 } 622 mDataCb(CAMERA_MSG_PREVIEW_FRAME, mPreviewHeap, index, NULL, mCallbackCookie); 623 } 624 625 Mutex::Autolock lock(mRecordLock); 626 if (mRecordRunning == true) { 627 index = mSecCamera->getRecordFrame(); 628 if (index < 0) { 629 LOGE("ERR(%s):Fail on SecCamera->getRecord()", __func__); 630 return UNKNOWN_ERROR; 631 } 632 633 phyYAddr = mSecCamera->getRecPhyAddrY(index); 634 phyCAddr = mSecCamera->getRecPhyAddrC(index); 635 636 if (phyYAddr == 0xffffffff || phyCAddr == 0xffffffff) { 637 LOGE("ERR(%s):Fail on SecCamera getRectPhyAddr Y addr = %0x C addr = %0x", __func__, 638 phyYAddr, phyCAddr); 639 return UNKNOWN_ERROR; 640 } 641 642 addrs = (struct addrs *)mRecordHeap->data; 643 644 addrs[index].type = kMetadataBufferTypeCameraSource; 645 addrs[index].addr_y = phyYAddr; 646 addrs[index].addr_cbcr = phyCAddr; 647 addrs[index].buf_index = index; 648 649 // Notify the client of a new frame. 650 if (mMsgEnabled & CAMERA_MSG_VIDEO_FRAME) { 651 mDataCbTimestamp(timestamp, CAMERA_MSG_VIDEO_FRAME, 652 mRecordHeap, index, mCallbackCookie); 653 } else { 654 mSecCamera->releaseRecordFrame(index); 655 } 656 } 657 658 return NO_ERROR; 659 } 660 661 status_t CameraHardwareSec::startPreview() 662 { 663 int ret = 0; //s1 [Apply factory standard] 664 665 LOGV("%s :", __func__); 666 667 if (waitCaptureCompletion() != NO_ERROR) { 668 return TIMED_OUT; 669 } 670 671 mPreviewLock.lock(); 672 if (mPreviewRunning) { 673 // already running 674 LOGE("%s : preview thread already running", __func__); 675 mPreviewLock.unlock(); 676 return INVALID_OPERATION; 677 } 678 679 mPreviewRunning = true; 680 mPreviewStartDeferred = false; 681 682 if (!mPreviewWindow) { 683 LOGI("%s : deferring", __func__); 684 mPreviewStartDeferred = true; 685 mPreviewLock.unlock(); 686 return NO_ERROR; 687 } 688 689 ret = startPreviewInternal(); 690 if (ret == OK) 691 mPreviewCondition.signal(); 692 693 mPreviewLock.unlock(); 694 return ret; 695 } 696 697 status_t CameraHardwareSec::startPreviewInternal() 698 { 699 LOGV("%s", __func__); 700 701 int ret = mSecCamera->startPreview(); 702 LOGV("%s : mSecCamera->startPreview() returned %d", __func__, ret); 703 704 if (ret < 0) { 705 LOGE("ERR(%s):Fail on mSecCamera->startPreview()", __func__); 706 return UNKNOWN_ERROR; 707 } 708 709 setSkipFrame(INITIAL_SKIP_FRAME); 710 711 int width, height, frame_size; 712 713 mSecCamera->getPreviewSize(&width, &height, &frame_size); 714 715 LOGD("mPreviewHeap(fd(%d), size(%d), width(%d), height(%d))", 716 mSecCamera->getCameraFd(), frame_size, width, height); 717 if (mPreviewHeap) { 718 mPreviewHeap->release(mPreviewHeap); 719 mPreviewHeap = 0; 720 } 721 722 mPreviewHeap = mGetMemoryCb((int)mSecCamera->getCameraFd(), 723 frame_size, 724 kBufferCount, 725 0); // no cookie 726 727 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); 728 LOGV("CameraHardwareSec: mPostViewWidth = %d mPostViewHeight = %d mPostViewSize = %d", 729 mPostViewWidth,mPostViewHeight,mPostViewSize); 730 731 return NO_ERROR; 732 } 733 734 void CameraHardwareSec::stopPreviewInternal() 735 { 736 LOGV("%s :", __func__); 737 738 /* request that the preview thread stop. */ 739 if (mPreviewRunning) { 740 mPreviewRunning = false; 741 if (!mPreviewStartDeferred) { 742 mPreviewCondition.signal(); 743 /* wait until preview thread is stopped */ 744 mPreviewStoppedCondition.wait(mPreviewLock); 745 } 746 else 747 LOGV("%s : preview running but deferred, doing nothing", __func__); 748 } else 749 LOGI("%s : preview not running, doing nothing", __func__); 750 } 751 752 void CameraHardwareSec::stopPreview() 753 { 754 LOGV("%s :", __func__); 755 756 /* request that the preview thread stop. */ 757 mPreviewLock.lock(); 758 stopPreviewInternal(); 759 mPreviewLock.unlock(); 760 } 761 762 bool CameraHardwareSec::previewEnabled() 763 { 764 Mutex::Autolock lock(mPreviewLock); 765 LOGV("%s : %d", __func__, mPreviewRunning); 766 return mPreviewRunning; 767 } 768 769 // --------------------------------------------------------------------------- 770 771 status_t CameraHardwareSec::startRecording() 772 { 773 LOGV("%s :", __func__); 774 775 Mutex::Autolock lock(mRecordLock); 776 777 if (mRecordHeap) { 778 mRecordHeap->release(mRecordHeap); 779 mRecordHeap = 0; 780 } 781 mRecordHeap = mGetMemoryCb(-1, sizeof(struct addrs), kBufferCount, NULL); 782 if (!mRecordHeap) { 783 LOGE("ERR(%s): Record heap creation fail", __func__); 784 return UNKNOWN_ERROR; 785 } 786 787 if (mRecordRunning == false) { 788 if (mSecCamera->startRecord() < 0) { 789 LOGE("ERR(%s):Fail on mSecCamera->startRecord()", __func__); 790 return UNKNOWN_ERROR; 791 } 792 mRecordRunning = true; 793 } 794 return NO_ERROR; 795 } 796 797 void CameraHardwareSec::stopRecording() 798 { 799 LOGV("%s :", __func__); 800 801 Mutex::Autolock lock(mRecordLock); 802 803 if (mRecordRunning == true) { 804 if (mSecCamera->stopRecord() < 0) { 805 LOGE("ERR(%s):Fail on mSecCamera->stopRecord()", __func__); 806 return; 807 } 808 mRecordRunning = false; 809 } 810 } 811 812 bool CameraHardwareSec::recordingEnabled() 813 { 814 LOGV("%s :", __func__); 815 816 return mRecordRunning; 817 } 818 819 void CameraHardwareSec::releaseRecordingFrame(const void *opaque) 820 { 821 struct addrs *addrs = (struct addrs *)opaque; 822 mSecCamera->releaseRecordFrame(addrs->buf_index); 823 } 824 825 // --------------------------------------------------------------------------- 826 827 int CameraHardwareSec::autoFocusThread() 828 { 829 int count =0; 830 int af_status =0 ; 831 832 LOGV("%s : starting", __func__); 833 834 /* block until we're told to start. we don't want to use 835 * a restartable thread and requestExitAndWait() in cancelAutoFocus() 836 * because it would cause deadlock between our callbacks and the 837 * caller of cancelAutoFocus() which both want to grab the same lock 838 * in CameraServices layer. 839 */ 840 mFocusLock.lock(); 841 /* check early exit request */ 842 if (mExitAutoFocusThread) { 843 mFocusLock.unlock(); 844 LOGV("%s : exiting on request0", __func__); 845 return NO_ERROR; 846 } 847 mFocusCondition.wait(mFocusLock); 848 /* check early exit request */ 849 if (mExitAutoFocusThread) { 850 mFocusLock.unlock(); 851 LOGV("%s : exiting on request1", __func__); 852 return NO_ERROR; 853 } 854 mFocusLock.unlock(); 855 856 LOGV("%s : calling setAutoFocus", __func__); 857 if (mSecCamera->setAutofocus() < 0) { 858 LOGE("ERR(%s):Fail on mSecCamera->setAutofocus()", __func__); 859 return UNKNOWN_ERROR; 860 } 861 862 af_status = mSecCamera->getAutoFocusResult(); 863 864 if (af_status == 0x01) { 865 LOGV("%s : AF Success!!", __func__); 866 if (mMsgEnabled & CAMERA_MSG_FOCUS) 867 mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); 868 } else if (af_status == 0x02) { 869 LOGV("%s : AF Cancelled !!", __func__); 870 if (mMsgEnabled & CAMERA_MSG_FOCUS) { 871 /* CAMERA_MSG_FOCUS only takes a bool. true for 872 * finished and false for failure. cancel is still 873 * considered a true result. 874 */ 875 mNotifyCb(CAMERA_MSG_FOCUS, true, 0, mCallbackCookie); 876 } 877 } else { 878 LOGV("%s : AF Fail !!", __func__); 879 LOGV("%s : mMsgEnabled = 0x%x", __func__, mMsgEnabled); 880 if (mMsgEnabled & CAMERA_MSG_FOCUS) 881 mNotifyCb(CAMERA_MSG_FOCUS, false, 0, mCallbackCookie); 882 } 883 884 LOGV("%s : exiting with no error", __func__); 885 return NO_ERROR; 886 } 887 888 status_t CameraHardwareSec::autoFocus() 889 { 890 LOGV("%s :", __func__); 891 /* signal autoFocusThread to run once */ 892 mFocusCondition.signal(); 893 return NO_ERROR; 894 } 895 896 /* 2009.10.14 by icarus for added interface */ 897 status_t CameraHardwareSec::cancelAutoFocus() 898 { 899 LOGV("%s :", __func__); 900 901 // cancelAutoFocus should be allowed after preview is started. But if 902 // the preview is deferred, cancelAutoFocus will fail. Ignore it if that is 903 // the case. 904 if (mPreviewRunning && mPreviewStartDeferred) return NO_ERROR; 905 906 if (mSecCamera->cancelAutofocus() < 0) { 907 LOGE("ERR(%s):Fail on mSecCamera->cancelAutofocus()", __func__); 908 return UNKNOWN_ERROR; 909 } 910 911 return NO_ERROR; 912 } 913 914 int CameraHardwareSec::save_jpeg( unsigned char *real_jpeg, int jpeg_size) 915 { 916 FILE *yuv_fp = NULL; 917 char filename[100], *buffer = NULL; 918 919 /* file create/open, note to "wb" */ 920 yuv_fp = fopen("/data/camera_dump.jpeg", "wb"); 921 if (yuv_fp == NULL) { 922 LOGE("Save jpeg file open error"); 923 return -1; 924 } 925 926 LOGV("[BestIQ] real_jpeg size ========> %d\n", jpeg_size); 927 buffer = (char *) malloc(jpeg_size); 928 if (buffer == NULL) { 929 LOGE("Save YUV] buffer alloc failed"); 930 if (yuv_fp) 931 fclose(yuv_fp); 932 933 return -1; 934 } 935 936 memcpy(buffer, real_jpeg, jpeg_size); 937 938 fflush(stdout); 939 940 fwrite(buffer, 1, jpeg_size, yuv_fp); 941 942 fflush(yuv_fp); 943 944 if (yuv_fp) 945 fclose(yuv_fp); 946 if (buffer) 947 free(buffer); 948 949 return 0; 950 } 951 952 void CameraHardwareSec::save_postview(const char *fname, uint8_t *buf, uint32_t size) 953 { 954 int nw; 955 int cnt = 0; 956 uint32_t written = 0; 957 958 LOGD("opening file [%s]\n", fname); 959 int fd = open(fname, O_RDWR | O_CREAT); 960 if (fd < 0) { 961 LOGE("failed to create file [%s]: %s", fname, strerror(errno)); 962 return; 963 } 964 965 LOGD("writing %d bytes to file [%s]\n", size, fname); 966 while (written < size) { 967 nw = ::write(fd, buf + written, size - written); 968 if (nw < 0) { 969 LOGE("failed to write to file %d [%s]: %s",written,fname, strerror(errno)); 970 break; 971 } 972 written += nw; 973 cnt++; 974 } 975 LOGD("done writing %d bytes to file [%s] in %d passes\n",size, fname, cnt); 976 ::close(fd); 977 } 978 979 bool CameraHardwareSec::scaleDownYuv422(char *srcBuf, uint32_t srcWidth, uint32_t srcHeight, 980 char *dstBuf, uint32_t dstWidth, uint32_t dstHeight) 981 { 982 int32_t step_x, step_y; 983 int32_t iXsrc, iXdst; 984 int32_t x, y, src_y_start_pos, dst_pos, src_pos; 985 986 if (dstWidth % 2 != 0 || dstHeight % 2 != 0){ 987 LOGE("scale_down_yuv422: invalid width, height for scaling"); 988 return false; 989 } 990 991 step_x = srcWidth / dstWidth; 992 step_y = srcHeight / dstHeight; 993 994 dst_pos = 0; 995 for (uint32_t y = 0; y < dstHeight; y++) { 996 src_y_start_pos = (y * step_y * (srcWidth * 2)); 997 998 for (uint32_t x = 0; x < dstWidth; x += 2) { 999 src_pos = src_y_start_pos + (x * (step_x * 2)); 1000 1001 dstBuf[dst_pos++] = srcBuf[src_pos ]; 1002 dstBuf[dst_pos++] = srcBuf[src_pos + 1]; 1003 dstBuf[dst_pos++] = srcBuf[src_pos + 2]; 1004 dstBuf[dst_pos++] = srcBuf[src_pos + 3]; 1005 } 1006 } 1007 1008 return true; 1009 } 1010 1011 bool CameraHardwareSec::YUY2toNV21(void *srcBuf, void *dstBuf, uint32_t srcWidth, uint32_t srcHeight) 1012 { 1013 int32_t x, y, src_y_start_pos, dst_cbcr_pos, dst_pos, src_pos; 1014 unsigned char *srcBufPointer = (unsigned char *)srcBuf; 1015 unsigned char *dstBufPointer = (unsigned char *)dstBuf; 1016 1017 dst_pos = 0; 1018 dst_cbcr_pos = srcWidth*srcHeight; 1019 for (uint32_t y = 0; y < srcHeight; y++) { 1020 src_y_start_pos = (y * (srcWidth * 2)); 1021 1022 for (uint32_t x = 0; x < (srcWidth * 2); x += 2) { 1023 src_pos = src_y_start_pos + x; 1024 1025 dstBufPointer[dst_pos++] = srcBufPointer[src_pos]; 1026 } 1027 } 1028 for (uint32_t y = 0; y < srcHeight; y += 2) { 1029 src_y_start_pos = (y * (srcWidth * 2)); 1030 1031 for (uint32_t x = 0; x < (srcWidth * 2); x += 4) { 1032 src_pos = src_y_start_pos + x; 1033 1034 dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 3]; 1035 dstBufPointer[dst_cbcr_pos++] = srcBufPointer[src_pos + 1]; 1036 } 1037 } 1038 1039 return true; 1040 } 1041 1042 int CameraHardwareSec::pictureThread() 1043 { 1044 LOGV("%s :", __func__); 1045 1046 int jpeg_size = 0; 1047 int ret = NO_ERROR; 1048 unsigned char *jpeg_data = NULL; 1049 int postview_offset = 0; 1050 unsigned char *postview_data = NULL; 1051 1052 unsigned char *addr = NULL; 1053 int mPostViewWidth, mPostViewHeight, mPostViewSize; 1054 int mThumbWidth, mThumbHeight, mThumbSize; 1055 int cap_width, cap_height, cap_frame_size; 1056 int JpegImageSize, JpegExifSize; 1057 bool isLSISensor = false; 1058 1059 unsigned int output_size = 0; 1060 1061 mSecCamera->getPostViewConfig(&mPostViewWidth, &mPostViewHeight, &mPostViewSize); 1062 mSecCamera->getThumbnailConfig(&mThumbWidth, &mThumbHeight, &mThumbSize); 1063 int postviewHeapSize = mPostViewSize; 1064 mSecCamera->getSnapshotSize(&cap_width, &cap_height, &cap_frame_size); 1065 int mJpegHeapSize; 1066 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) 1067 mJpegHeapSize = cap_frame_size * SecCamera::getJpegRatio(); 1068 else 1069 mJpegHeapSize = cap_frame_size; 1070 1071 LOG_TIME_DEFINE(0) 1072 LOG_TIME_START(0) 1073 // sp<MemoryBase> buffer = new MemoryBase(mRawHeap, 0, mPostViewSize + 8); 1074 1075 struct addrs_cap *addrs = (struct addrs_cap *)mRawHeap->data; 1076 1077 addrs[0].width = mPostViewWidth; 1078 addrs[0].height = mPostViewHeight; 1079 LOGV("[5B] mPostViewWidth = %d mPostViewHeight = %d\n",mPostViewWidth,mPostViewHeight); 1080 1081 camera_memory_t *JpegHeap = mGetMemoryCb(-1, mJpegHeapSize, 1, 0); 1082 sp<MemoryHeapBase> PostviewHeap = new MemoryHeapBase(mPostViewSize); 1083 sp<MemoryHeapBase> ThumbnailHeap = new MemoryHeapBase(mThumbSize); 1084 1085 LOG_TIME_DEFINE(1) 1086 LOG_TIME_START(1) 1087 1088 int picture_size, picture_width, picture_height; 1089 mSecCamera->getSnapshotSize(&picture_width, &picture_height, &picture_size); 1090 int picture_format = mSecCamera->getSnapshotPixelFormat(); 1091 1092 unsigned int phyAddr; 1093 1094 // Modified the shutter sound timing for Jpeg capture 1095 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) 1096 mSecCamera->setSnapshotCmd(); 1097 if (mMsgEnabled & CAMERA_MSG_SHUTTER) { 1098 mNotifyCb(CAMERA_MSG_SHUTTER, 0, 0, mCallbackCookie); 1099 } 1100 1101 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK){ 1102 jpeg_data = mSecCamera->getJpeg(&jpeg_size, &phyAddr); 1103 if (jpeg_data == NULL) { 1104 LOGE("ERR(%s):Fail on SecCamera->getSnapshot()", __func__); 1105 ret = UNKNOWN_ERROR; 1106 goto out; 1107 } 1108 } else { 1109 if (mSecCamera->getSnapshotAndJpeg((unsigned char*)PostviewHeap->base(), 1110 (unsigned char*)JpegHeap->data, &output_size) < 0) { 1111 ret = UNKNOWN_ERROR; 1112 goto out; 1113 } 1114 LOGI("snapshotandjpeg done\n"); 1115 } 1116 1117 LOG_TIME_END(1) 1118 LOG_CAMERA("getSnapshotAndJpeg interval: %lu us", LOG_TIME(1)); 1119 1120 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) { 1121 isLSISensor = !strncmp((const char*)mCameraSensorName, "S5K4ECGX", 8); 1122 if(isLSISensor) { 1123 LOGI("== Camera Sensor Detect %s - Samsung LSI SOC 5M ==\n", mCameraSensorName); 1124 // LSI 5M SOC 1125 if (!SplitFrame(jpeg_data, SecCamera::getInterleaveDataSize(), 1126 SecCamera::getJpegLineLength(), 1127 mPostViewWidth * 2, mPostViewWidth, 1128 JpegHeap->data, &JpegImageSize, 1129 PostviewHeap->base(), &mPostViewSize)) { 1130 ret = UNKNOWN_ERROR; 1131 goto out; 1132 } 1133 } else { 1134 LOGI("== Camera Sensor Detect %s Sony SOC 5M ==\n", mCameraSensorName); 1135 decodeInterleaveData(jpeg_data, 1136 SecCamera::getInterleaveDataSize(), 1137 mPostViewWidth, mPostViewHeight, 1138 &JpegImageSize, JpegHeap->data, PostviewHeap->base()); 1139 } 1140 } else { 1141 JpegImageSize = static_cast<int>(output_size); 1142 } 1143 scaleDownYuv422((char *)PostviewHeap->base(), mPostViewWidth, mPostViewHeight, 1144 (char *)ThumbnailHeap->base(), mThumbWidth, mThumbHeight); 1145 1146 memcpy(mRawHeap->data, PostviewHeap->base(), postviewHeapSize); 1147 1148 if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE) { 1149 mDataCb(CAMERA_MSG_RAW_IMAGE, mRawHeap, 0, NULL, mCallbackCookie); 1150 } else if (mMsgEnabled & CAMERA_MSG_RAW_IMAGE_NOTIFY) { 1151 mNotifyCb(CAMERA_MSG_RAW_IMAGE_NOTIFY, 0, 0, mCallbackCookie); 1152 } 1153 1154 if (mMsgEnabled & CAMERA_MSG_COMPRESSED_IMAGE) { 1155 camera_memory_t *ExifHeap = 1156 mGetMemoryCb(-1, EXIF_FILE_SIZE + JPG_STREAM_BUF_SIZE, 1, 0); 1157 JpegExifSize = mSecCamera->getExif((unsigned char *)ExifHeap->data, 1158 (unsigned char *)ThumbnailHeap->base()); 1159 1160 LOGV("JpegExifSize=%d", JpegExifSize); 1161 1162 if (JpegExifSize < 0) { 1163 ret = UNKNOWN_ERROR; 1164 ExifHeap->release(ExifHeap); 1165 goto out; 1166 } 1167 1168 camera_memory_t *mem = mGetMemoryCb(-1, JpegImageSize + JpegExifSize, 1, 0); 1169 uint8_t *ptr = (uint8_t *) mem->data; 1170 memcpy(ptr, JpegHeap->data, 2); ptr += 2; 1171 memcpy(ptr, ExifHeap->data, JpegExifSize); ptr += JpegExifSize; 1172 memcpy(ptr, (uint8_t *) JpegHeap->data + 2, JpegImageSize - 2); 1173 mDataCb(CAMERA_MSG_COMPRESSED_IMAGE, mem, 0, NULL, mCallbackCookie); 1174 mem->release(mem); 1175 ExifHeap->release(ExifHeap); 1176 } 1177 1178 LOG_TIME_END(0) 1179 LOG_CAMERA("pictureThread interval: %lu us", LOG_TIME(0)); 1180 1181 LOGV("%s : pictureThread end", __func__); 1182 1183 out: 1184 JpegHeap->release(JpegHeap); 1185 mSecCamera->endSnapshot(); 1186 mCaptureLock.lock(); 1187 mCaptureInProgress = false; 1188 mCaptureCondition.broadcast(); 1189 mCaptureLock.unlock(); 1190 1191 return ret; 1192 } 1193 1194 status_t CameraHardwareSec::waitCaptureCompletion() { 1195 // 5 seconds timeout 1196 nsecs_t endTime = 5000000000LL + systemTime(SYSTEM_TIME_MONOTONIC); 1197 Mutex::Autolock lock(mCaptureLock); 1198 while (mCaptureInProgress) { 1199 nsecs_t remainingTime = endTime - systemTime(SYSTEM_TIME_MONOTONIC); 1200 if (remainingTime <= 0) { 1201 LOGE("Timed out waiting picture thread."); 1202 return TIMED_OUT; 1203 } 1204 LOGD("Waiting for picture thread to complete."); 1205 mCaptureCondition.waitRelative(mCaptureLock, remainingTime); 1206 } 1207 return NO_ERROR; 1208 } 1209 1210 status_t CameraHardwareSec::takePicture() 1211 { 1212 LOGV("%s :", __func__); 1213 1214 stopPreview(); 1215 1216 if (!mRawHeap) { 1217 int rawHeapSize = mPostViewSize; 1218 LOGV("mRawHeap : MemoryHeapBase(previewHeapSize(%d))", rawHeapSize); 1219 mRawHeap = mGetMemoryCb(-1, rawHeapSize, 1, 0); 1220 if (!mRawHeap) { 1221 LOGE("ERR(%s): Raw heap creation fail", __func__); 1222 } 1223 } 1224 1225 if (waitCaptureCompletion() != NO_ERROR) { 1226 return TIMED_OUT; 1227 } 1228 1229 if (mPictureThread->run("CameraPictureThread", PRIORITY_DEFAULT) != NO_ERROR) { 1230 LOGE("%s : couldn't run picture thread", __func__); 1231 return INVALID_OPERATION; 1232 } 1233 mCaptureLock.lock(); 1234 mCaptureInProgress = true; 1235 mCaptureLock.unlock(); 1236 1237 return NO_ERROR; 1238 } 1239 1240 status_t CameraHardwareSec::cancelPicture() 1241 { 1242 LOGV("%s", __func__); 1243 1244 if (mPictureThread.get()) { 1245 LOGV("%s: waiting for picture thread to exit", __func__); 1246 mPictureThread->requestExitAndWait(); 1247 LOGV("%s: picture thread has exited", __func__); 1248 } 1249 1250 return NO_ERROR; 1251 } 1252 1253 bool CameraHardwareSec::CheckVideoStartMarker(unsigned char *pBuf) 1254 { 1255 if (!pBuf) { 1256 LOGE("CheckVideoStartMarker() => pBuf is NULL\n"); 1257 return false; 1258 } 1259 1260 if (HIBYTE(VIDEO_COMMENT_MARKER_H) == * pBuf && LOBYTE(VIDEO_COMMENT_MARKER_H) == *(pBuf + 1) && 1261 HIBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 2) && LOBYTE(VIDEO_COMMENT_MARKER_L) == *(pBuf + 3)) 1262 return true; 1263 1264 return false; 1265 } 1266 1267 bool CameraHardwareSec::CheckEOIMarker(unsigned char *pBuf) 1268 { 1269 if (!pBuf) { 1270 LOGE("CheckEOIMarker() => pBuf is NULL\n"); 1271 return false; 1272 } 1273 1274 // EOI marker [FF D9] 1275 if (HIBYTE(JPEG_EOI_MARKER) == *pBuf && LOBYTE(JPEG_EOI_MARKER) == *(pBuf + 1)) 1276 return true; 1277 1278 return false; 1279 } 1280 1281 bool CameraHardwareSec::FindEOIMarkerInJPEG(unsigned char *pBuf, int dwBufSize, int *pnJPEGsize) 1282 { 1283 if (NULL == pBuf || 0 >= dwBufSize) { 1284 LOGE("FindEOIMarkerInJPEG() => There is no contents."); 1285 return false; 1286 } 1287 1288 unsigned char *pBufEnd = pBuf + dwBufSize; 1289 1290 while (pBuf < pBufEnd) { 1291 if (CheckEOIMarker(pBuf++)) 1292 return true; 1293 1294 (*pnJPEGsize)++; 1295 } 1296 1297 return false; 1298 } 1299 1300 bool CameraHardwareSec::SplitFrame(unsigned char *pFrame, int dwSize, 1301 int dwJPEGLineLength, int dwVideoLineLength, int dwVideoHeight, 1302 void *pJPEG, int *pdwJPEGSize, 1303 void *pVideo, int *pdwVideoSize) 1304 { 1305 LOGV("===========SplitFrame Start=============="); 1306 1307 if (NULL == pFrame || 0 >= dwSize) { 1308 LOGE("There is no contents (pFrame=%p, dwSize=%d", pFrame, dwSize); 1309 return false; 1310 } 1311 1312 if (0 == dwJPEGLineLength || 0 == dwVideoLineLength) { 1313 LOGE("There in no input information for decoding interleaved jpeg"); 1314 return false; 1315 } 1316 1317 unsigned char *pSrc = pFrame; 1318 unsigned char *pSrcEnd = pFrame + dwSize; 1319 1320 unsigned char *pJ = (unsigned char *)pJPEG; 1321 int dwJSize = 0; 1322 unsigned char *pV = (unsigned char *)pVideo; 1323 int dwVSize = 0; 1324 1325 bool bRet = false; 1326 bool isFinishJpeg = false; 1327 1328 while (pSrc < pSrcEnd) { 1329 // Check video start marker 1330 if (CheckVideoStartMarker(pSrc)) { 1331 int copyLength; 1332 1333 if (pSrc + dwVideoLineLength <= pSrcEnd) 1334 copyLength = dwVideoLineLength; 1335 else 1336 copyLength = pSrcEnd - pSrc - VIDEO_COMMENT_MARKER_LENGTH; 1337 1338 // Copy video data 1339 if (pV) { 1340 memcpy(pV, pSrc + VIDEO_COMMENT_MARKER_LENGTH, copyLength); 1341 pV += copyLength; 1342 dwVSize += copyLength; 1343 } 1344 1345 pSrc += copyLength + VIDEO_COMMENT_MARKER_LENGTH; 1346 } else { 1347 // Copy pure JPEG data 1348 int size = 0; 1349 int dwCopyBufLen = dwJPEGLineLength <= pSrcEnd-pSrc ? dwJPEGLineLength : pSrcEnd - pSrc; 1350 1351 if (FindEOIMarkerInJPEG((unsigned char *)pSrc, dwCopyBufLen, &size)) { 1352 isFinishJpeg = true; 1353 size += 2; // to count EOF marker size 1354 } else { 1355 if ((dwCopyBufLen == 1) && (pJPEG < pJ)) { 1356 unsigned char checkBuf[2] = { *(pJ - 1), *pSrc }; 1357 1358 if (CheckEOIMarker(checkBuf)) 1359 isFinishJpeg = true; 1360 } 1361 size = dwCopyBufLen; 1362 } 1363 1364 memcpy(pJ, pSrc, size); 1365 1366 dwJSize += size; 1367 1368 pJ += dwCopyBufLen; 1369 pSrc += dwCopyBufLen; 1370 } 1371 if (isFinishJpeg) 1372 break; 1373 } 1374 1375 if (isFinishJpeg) { 1376 bRet = true; 1377 if(pdwJPEGSize) 1378 *pdwJPEGSize = dwJSize; 1379 if(pdwVideoSize) 1380 *pdwVideoSize = dwVSize; 1381 } else { 1382 LOGE("DecodeInterleaveJPEG_WithOutDT() => Can not find EOI"); 1383 bRet = false; 1384 if(pdwJPEGSize) 1385 *pdwJPEGSize = 0; 1386 if(pdwVideoSize) 1387 *pdwVideoSize = 0; 1388 } 1389 LOGV("===========SplitFrame end=============="); 1390 1391 return bRet; 1392 } 1393 1394 int CameraHardwareSec::decodeInterleaveData(unsigned char *pInterleaveData, 1395 int interleaveDataSize, 1396 int yuvWidth, 1397 int yuvHeight, 1398 int *pJpegSize, 1399 void *pJpegData, 1400 void *pYuvData) 1401 { 1402 if (pInterleaveData == NULL) 1403 return false; 1404 1405 bool ret = true; 1406 unsigned int *interleave_ptr = (unsigned int *)pInterleaveData; 1407 unsigned char *jpeg_ptr = (unsigned char *)pJpegData; 1408 unsigned char *yuv_ptr = (unsigned char *)pYuvData; 1409 unsigned char *p; 1410 int jpeg_size = 0; 1411 int yuv_size = 0; 1412 1413 int i = 0; 1414 1415 LOGV("decodeInterleaveData Start~~~"); 1416 while (i < interleaveDataSize) { 1417 if ((*interleave_ptr == 0xFFFFFFFF) || (*interleave_ptr == 0x02FFFFFF) || 1418 (*interleave_ptr == 0xFF02FFFF)) { 1419 // Padding Data 1420 // LOGE("%d(%x) padding data\n", i, *interleave_ptr); 1421 interleave_ptr++; 1422 i += 4; 1423 } 1424 else if ((*interleave_ptr & 0xFFFF) == 0x05FF) { 1425 // Start-code of YUV Data 1426 // LOGE("%d(%x) yuv data\n", i, *interleave_ptr); 1427 p = (unsigned char *)interleave_ptr; 1428 p += 2; 1429 i += 2; 1430 1431 // Extract YUV Data 1432 if (pYuvData != NULL) { 1433 memcpy(yuv_ptr, p, yuvWidth * 2); 1434 yuv_ptr += yuvWidth * 2; 1435 yuv_size += yuvWidth * 2; 1436 } 1437 p += yuvWidth * 2; 1438 i += yuvWidth * 2; 1439 1440 // Check End-code of YUV Data 1441 if ((*p == 0xFF) && (*(p + 1) == 0x06)) { 1442 interleave_ptr = (unsigned int *)(p + 2); 1443 i += 2; 1444 } else { 1445 ret = false; 1446 break; 1447 } 1448 } else { 1449 // Extract JPEG Data 1450 // LOGE("%d(%x) jpg data, jpeg_size = %d bytes\n", i, *interleave_ptr, jpeg_size); 1451 if (pJpegData != NULL) { 1452 memcpy(jpeg_ptr, interleave_ptr, 4); 1453 jpeg_ptr += 4; 1454 jpeg_size += 4; 1455 } 1456 interleave_ptr++; 1457 i += 4; 1458 } 1459 } 1460 if (ret) { 1461 if (pJpegData != NULL) { 1462 // Remove Padding after EOI 1463 for (i = 0; i < 3; i++) { 1464 if (*(--jpeg_ptr) != 0xFF) { 1465 break; 1466 } 1467 jpeg_size--; 1468 } 1469 *pJpegSize = jpeg_size; 1470 1471 } 1472 // Check YUV Data Size 1473 if (pYuvData != NULL) { 1474 if (yuv_size != (yuvWidth * yuvHeight * 2)) { 1475 ret = false; 1476 } 1477 } 1478 } 1479 LOGV("decodeInterleaveData End~~~"); 1480 return ret; 1481 } 1482 1483 status_t CameraHardwareSec::dump(int fd) const 1484 { 1485 const size_t SIZE = 256; 1486 char buffer[SIZE]; 1487 String8 result; 1488 const Vector<String16> args; 1489 1490 if (mSecCamera != 0) { 1491 mSecCamera->dump(fd); 1492 mParameters.dump(fd, args); 1493 mInternalParameters.dump(fd, args); 1494 snprintf(buffer, 255, " preview running(%s)\n", mPreviewRunning?"true": "false"); 1495 result.append(buffer); 1496 } else { 1497 result.append("No camera client yet.\n"); 1498 } 1499 write(fd, result.string(), result.size()); 1500 return NO_ERROR; 1501 } 1502 1503 bool CameraHardwareSec::isSupportedPreviewSize(const int width, 1504 const int height) const 1505 { 1506 unsigned int i; 1507 1508 for (i = 0; i < mSupportedPreviewSizes.size(); i++) { 1509 if (mSupportedPreviewSizes[i].width == width && 1510 mSupportedPreviewSizes[i].height == height) 1511 return true; 1512 } 1513 1514 return false; 1515 } 1516 1517 bool CameraHardwareSec::isSupportedParameter(const char * const parm, 1518 const char * const supported_parm) const 1519 { 1520 const char *pStart; 1521 const char *pEnd; 1522 1523 if (!parm || !supported_parm) 1524 return false; 1525 1526 pStart = supported_parm; 1527 1528 while (true) { 1529 pEnd = strchr(pStart, ','); 1530 if (!pEnd) { 1531 if (!strcmp(parm, pStart)) 1532 return true; 1533 else 1534 return false; 1535 } 1536 if (!strncmp(parm, pStart, pEnd - pStart)) { 1537 return true; 1538 } 1539 pStart = pEnd + 1; 1540 } 1541 /* NOTREACHED */ 1542 } 1543 1544 status_t CameraHardwareSec::setParameters(const CameraParameters& params) 1545 { 1546 LOGV("%s :", __func__); 1547 1548 status_t ret = NO_ERROR; 1549 1550 /* if someone calls us while picture thread is running, it could screw 1551 * up the sensor quite a bit so return error. 1552 */ 1553 if (waitCaptureCompletion() != NO_ERROR) { 1554 return TIMED_OUT; 1555 } 1556 1557 // preview size 1558 int new_preview_width = 0; 1559 int new_preview_height = 0; 1560 params.getPreviewSize(&new_preview_width, &new_preview_height); 1561 const char *new_str_preview_format = params.getPreviewFormat(); 1562 LOGV("%s : new_preview_width x new_preview_height = %dx%d, format = %s", 1563 __func__, new_preview_width, new_preview_height, new_str_preview_format); 1564 1565 if (strcmp(new_str_preview_format, CameraParameters::PIXEL_FORMAT_YUV420SP) && 1566 strcmp(new_str_preview_format, CameraParameters::PIXEL_FORMAT_YUV420P)) { 1567 LOGE("Unsupported preview color format: %s", new_str_preview_format); 1568 return BAD_VALUE; 1569 } 1570 1571 if (0 < new_preview_width && 0 < new_preview_height && 1572 new_str_preview_format != NULL && 1573 isSupportedPreviewSize(new_preview_width, new_preview_height)) { 1574 int new_preview_format = V4L2_PIX_FMT_YUV420; 1575 1576 int current_preview_width, current_preview_height, current_frame_size; 1577 mSecCamera->getPreviewSize(¤t_preview_width, 1578 ¤t_preview_height, 1579 ¤t_frame_size); 1580 int current_pixel_format = mSecCamera->getPreviewPixelFormat(); 1581 1582 if (current_preview_width != new_preview_width || 1583 current_preview_height != new_preview_height || 1584 current_pixel_format != new_preview_format) { 1585 if (mSecCamera->setPreviewSize(new_preview_width, new_preview_height, 1586 new_preview_format) < 0) { 1587 LOGE("ERR(%s):Fail on mSecCamera->setPreviewSize(width(%d), height(%d), format(%d))", 1588 __func__, new_preview_width, new_preview_height, new_preview_format); 1589 ret = UNKNOWN_ERROR; 1590 } else { 1591 if (mPreviewWindow) { 1592 if (mPreviewRunning && !mPreviewStartDeferred) { 1593 LOGE("ERR(%s): preview is running, cannot change size and format!", 1594 __func__); 1595 ret = INVALID_OPERATION; 1596 } 1597 1598 LOGV("%s: mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow); 1599 LOGV("%s: mPreviewWindow->set_buffers_geometry (%p)", __func__, 1600 mPreviewWindow->set_buffers_geometry); 1601 mPreviewWindow->set_buffers_geometry(mPreviewWindow, 1602 new_preview_width, new_preview_height, 1603 new_preview_format); 1604 LOGV("%s: DONE mPreviewWindow (%p) set_buffers_geometry", __func__, mPreviewWindow); 1605 } 1606 1607 mParameters.setPreviewSize(new_preview_width, new_preview_height); 1608 mParameters.setPreviewFormat(new_str_preview_format); 1609 } 1610 } 1611 else LOGV("%s: preview size and format has not changed", __func__); 1612 } else { 1613 LOGE("%s: Invalid preview size(%dx%d)", 1614 __func__, new_preview_width, new_preview_height); 1615 1616 ret = INVALID_OPERATION; 1617 } 1618 1619 int new_picture_width = 0; 1620 int new_picture_height = 0; 1621 1622 params.getPictureSize(&new_picture_width, &new_picture_height); 1623 LOGV("%s : new_picture_width x new_picture_height = %dx%d", __func__, new_picture_width, new_picture_height); 1624 if (0 < new_picture_width && 0 < new_picture_height) { 1625 LOGV("%s: setSnapshotSize", __func__); 1626 if (mSecCamera->setSnapshotSize(new_picture_width, new_picture_height) < 0) { 1627 LOGE("ERR(%s):Fail on mSecCamera->setSnapshotSize(width(%d), height(%d))", 1628 __func__, new_picture_width, new_picture_height); 1629 ret = UNKNOWN_ERROR; 1630 } else { 1631 mParameters.setPictureSize(new_picture_width, new_picture_height); 1632 } 1633 } 1634 1635 // picture format 1636 const char *new_str_picture_format = params.getPictureFormat(); 1637 LOGV("%s : new_str_picture_format %s", __func__, new_str_picture_format); 1638 if (new_str_picture_format != NULL) { 1639 int new_picture_format = 0; 1640 1641 if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGB565)) 1642 new_picture_format = V4L2_PIX_FMT_RGB565; 1643 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_RGBA8888)) 1644 new_picture_format = V4L2_PIX_FMT_RGB32; 1645 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_YUV420SP)) 1646 new_picture_format = V4L2_PIX_FMT_NV21; 1647 else if (!strcmp(new_str_picture_format, "yuv420sp_custom")) 1648 new_picture_format = V4L2_PIX_FMT_NV12T; 1649 else if (!strcmp(new_str_picture_format, "yuv420p")) 1650 new_picture_format = V4L2_PIX_FMT_YUV420; 1651 else if (!strcmp(new_str_picture_format, "yuv422i")) 1652 new_picture_format = V4L2_PIX_FMT_YUYV; 1653 else if (!strcmp(new_str_picture_format, "uyv422i_custom")) //Zero copy UYVY format 1654 new_picture_format = V4L2_PIX_FMT_UYVY; 1655 else if (!strcmp(new_str_picture_format, "uyv422i")) //Non-zero copy UYVY format 1656 new_picture_format = V4L2_PIX_FMT_UYVY; 1657 else if (!strcmp(new_str_picture_format, CameraParameters::PIXEL_FORMAT_JPEG)) 1658 new_picture_format = V4L2_PIX_FMT_YUYV; 1659 else if (!strcmp(new_str_picture_format, "yuv422p")) 1660 new_picture_format = V4L2_PIX_FMT_YUV422P; 1661 else 1662 new_picture_format = V4L2_PIX_FMT_NV21; //for 3rd party 1663 1664 if (mSecCamera->setSnapshotPixelFormat(new_picture_format) < 0) { 1665 LOGE("ERR(%s):Fail on mSecCamera->setSnapshotPixelFormat(format(%d))", __func__, new_picture_format); 1666 ret = UNKNOWN_ERROR; 1667 } else { 1668 mParameters.setPictureFormat(new_str_picture_format); 1669 } 1670 } 1671 1672 //JPEG image quality 1673 int new_jpeg_quality = params.getInt(CameraParameters::KEY_JPEG_QUALITY); 1674 LOGV("%s : new_jpeg_quality %d", __func__, new_jpeg_quality); 1675 /* we ignore bad values */ 1676 if (new_jpeg_quality >=1 && new_jpeg_quality <= 100) { 1677 if (mSecCamera->setJpegQuality(new_jpeg_quality) < 0) { 1678 LOGE("ERR(%s):Fail on mSecCamera->setJpegQuality(quality(%d))", __func__, new_jpeg_quality); 1679 ret = UNKNOWN_ERROR; 1680 } else { 1681 mParameters.set(CameraParameters::KEY_JPEG_QUALITY, new_jpeg_quality); 1682 } 1683 } 1684 1685 // JPEG thumbnail size 1686 int new_jpeg_thumbnail_width = params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH); 1687 int new_jpeg_thumbnail_height= params.getInt(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT); 1688 if (0 <= new_jpeg_thumbnail_width && 0 <= new_jpeg_thumbnail_height) { 1689 if (mSecCamera->setJpegThumbnailSize(new_jpeg_thumbnail_width, new_jpeg_thumbnail_height) < 0) { 1690 LOGE("ERR(%s):Fail on mSecCamera->setJpegThumbnailSize(width(%d), height(%d))", __func__, new_jpeg_thumbnail_width, new_jpeg_thumbnail_height); 1691 ret = UNKNOWN_ERROR; 1692 } else { 1693 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH, new_jpeg_thumbnail_width); 1694 mParameters.set(CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT, new_jpeg_thumbnail_height); 1695 } 1696 } 1697 1698 // frame rate 1699 int new_frame_rate = params.getPreviewFrameRate(); 1700 /* ignore any fps request, we're determine fps automatically based 1701 * on scene mode. don't return an error because it causes CTS failure. 1702 */ 1703 if (new_frame_rate != mParameters.getPreviewFrameRate()) { 1704 LOGW("WARN(%s): request for preview frame %d not allowed, != %d\n", 1705 __func__, new_frame_rate, mParameters.getPreviewFrameRate()); 1706 } 1707 1708 // rotation 1709 int new_rotation = params.getInt(CameraParameters::KEY_ROTATION); 1710 LOGV("%s : new_rotation %d", __func__, new_rotation); 1711 if (0 <= new_rotation) { 1712 LOGV("%s : set orientation:%d\n", __func__, new_rotation); 1713 if (mSecCamera->setExifOrientationInfo(new_rotation) < 0) { 1714 LOGE("ERR(%s):Fail on mSecCamera->setExifOrientationInfo(%d)", __func__, new_rotation); 1715 ret = UNKNOWN_ERROR; 1716 } else { 1717 mParameters.set(CameraParameters::KEY_ROTATION, new_rotation); 1718 } 1719 } 1720 1721 // brightness 1722 int new_exposure_compensation = params.getInt(CameraParameters::KEY_EXPOSURE_COMPENSATION); 1723 int max_exposure_compensation = params.getInt(CameraParameters::KEY_MAX_EXPOSURE_COMPENSATION); 1724 int min_exposure_compensation = params.getInt(CameraParameters::KEY_MIN_EXPOSURE_COMPENSATION); 1725 LOGV("%s : new_exposure_compensation %d", __func__, new_exposure_compensation); 1726 if ((min_exposure_compensation <= new_exposure_compensation) && 1727 (max_exposure_compensation >= new_exposure_compensation)) { 1728 if (mSecCamera->setBrightness(new_exposure_compensation) < 0) { 1729 LOGE("ERR(%s):Fail on mSecCamera->setBrightness(brightness(%d))", __func__, new_exposure_compensation); 1730 ret = UNKNOWN_ERROR; 1731 } else { 1732 mParameters.set(CameraParameters::KEY_EXPOSURE_COMPENSATION, new_exposure_compensation); 1733 } 1734 } 1735 1736 // whitebalance 1737 const char *new_white_str = params.get(CameraParameters::KEY_WHITE_BALANCE); 1738 LOGV("%s : new_white_str %s", __func__, new_white_str); 1739 if (new_white_str != NULL) { 1740 int new_white = -1; 1741 1742 if (!strcmp(new_white_str, CameraParameters::WHITE_BALANCE_AUTO)) 1743 new_white = WHITE_BALANCE_AUTO; 1744 else if (!strcmp(new_white_str, 1745 CameraParameters::WHITE_BALANCE_DAYLIGHT)) 1746 new_white = WHITE_BALANCE_SUNNY; 1747 else if (!strcmp(new_white_str, 1748 CameraParameters::WHITE_BALANCE_CLOUDY_DAYLIGHT)) 1749 new_white = WHITE_BALANCE_CLOUDY; 1750 else if (!strcmp(new_white_str, 1751 CameraParameters::WHITE_BALANCE_FLUORESCENT)) 1752 new_white = WHITE_BALANCE_FLUORESCENT; 1753 else if (!strcmp(new_white_str, 1754 CameraParameters::WHITE_BALANCE_INCANDESCENT)) 1755 new_white = WHITE_BALANCE_TUNGSTEN; 1756 else { 1757 LOGE("ERR(%s):Invalid white balance(%s)", __func__, new_white_str); //twilight, shade, warm_flourescent 1758 ret = UNKNOWN_ERROR; 1759 } 1760 1761 if (0 <= new_white) { 1762 if (mSecCamera->setWhiteBalance(new_white) < 0) { 1763 LOGE("ERR(%s):Fail on mSecCamera->setWhiteBalance(white(%d))", __func__, new_white); 1764 ret = UNKNOWN_ERROR; 1765 } else { 1766 mParameters.set(CameraParameters::KEY_WHITE_BALANCE, new_white_str); 1767 } 1768 } 1769 } 1770 1771 // scene mode 1772 const char *new_scene_mode_str = params.get(CameraParameters::KEY_SCENE_MODE); 1773 const char *current_scene_mode_str = mParameters.get(CameraParameters::KEY_SCENE_MODE); 1774 1775 // fps range 1776 int new_min_fps = 0; 1777 int new_max_fps = 0; 1778 int current_min_fps, current_max_fps; 1779 params.getPreviewFpsRange(&new_min_fps, &new_max_fps); 1780 mParameters.getPreviewFpsRange(¤t_min_fps, ¤t_max_fps); 1781 /* our fps range is determined by the sensor, reject any request 1782 * that isn't exactly what we're already at. 1783 * but the check is performed when requesting only changing fps range 1784 */ 1785 if (new_scene_mode_str && current_scene_mode_str) { 1786 if (!strcmp(new_scene_mode_str, current_scene_mode_str)) { 1787 if ((new_min_fps != current_min_fps) || (new_max_fps != current_max_fps)) { 1788 LOGW("%s : requested new_min_fps = %d, new_max_fps = %d not allowed", 1789 __func__, new_min_fps, new_max_fps); 1790 LOGE("%s : current_min_fps = %d, current_max_fps = %d", 1791 __func__, current_min_fps, current_max_fps); 1792 ret = UNKNOWN_ERROR; 1793 } 1794 } 1795 } else { 1796 /* Check basic validation if scene mode is different */ 1797 if ((new_min_fps > new_max_fps) || 1798 (new_min_fps < 0) || (new_max_fps < 0)) 1799 ret = UNKNOWN_ERROR; 1800 } 1801 1802 const char *new_focus_mode_str = params.get(CameraParameters::KEY_FOCUS_MODE); 1803 1804 if (mSecCamera->getCameraId() == SecCamera::CAMERA_ID_BACK) { 1805 int new_scene_mode = -1; 1806 1807 const char *new_flash_mode_str = params.get(CameraParameters::KEY_FLASH_MODE); 1808 1809 // fps range is (15000,30000) by default. 1810 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(15000,30000)"); 1811 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 1812 "15000,30000"); 1813 1814 if (!strcmp(new_scene_mode_str, CameraParameters::SCENE_MODE_AUTO)) { 1815 new_scene_mode = SCENE_MODE_NONE; 1816 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "on,off,auto,torch"); 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 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "auto"); 1829 } else if (!strcmp(new_scene_mode_str, 1830 CameraParameters::SCENE_MODE_LANDSCAPE)) { 1831 new_scene_mode = SCENE_MODE_LANDSCAPE; 1832 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1833 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off"); 1834 } else if (!strcmp(new_scene_mode_str, 1835 CameraParameters::SCENE_MODE_SPORTS)) { 1836 new_scene_mode = SCENE_MODE_SPORTS; 1837 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1838 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off"); 1839 } else if (!strcmp(new_scene_mode_str, 1840 CameraParameters::SCENE_MODE_PARTY)) { 1841 new_scene_mode = SCENE_MODE_PARTY_INDOOR; 1842 new_flash_mode_str = CameraParameters::FLASH_MODE_AUTO; 1843 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "auto"); 1844 } else if ((!strcmp(new_scene_mode_str, 1845 CameraParameters::SCENE_MODE_BEACH)) || 1846 (!strcmp(new_scene_mode_str, 1847 CameraParameters::SCENE_MODE_SNOW))) { 1848 new_scene_mode = SCENE_MODE_BEACH_SNOW; 1849 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1850 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off"); 1851 } else if (!strcmp(new_scene_mode_str, 1852 CameraParameters::SCENE_MODE_SUNSET)) { 1853 new_scene_mode = SCENE_MODE_SUNSET; 1854 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1855 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off"); 1856 } else if (!strcmp(new_scene_mode_str, 1857 CameraParameters::SCENE_MODE_NIGHT)) { 1858 new_scene_mode = SCENE_MODE_NIGHTSHOT; 1859 mParameters.set(CameraParameters::KEY_SUPPORTED_PREVIEW_FPS_RANGE, "(4000,30000)"); 1860 mParameters.set(CameraParameters::KEY_PREVIEW_FPS_RANGE, 1861 "4000,30000"); 1862 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1863 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off"); 1864 } else if (!strcmp(new_scene_mode_str, 1865 CameraParameters::SCENE_MODE_FIREWORKS)) { 1866 new_scene_mode = SCENE_MODE_FIREWORKS; 1867 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1868 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off"); 1869 } else if (!strcmp(new_scene_mode_str, 1870 CameraParameters::SCENE_MODE_CANDLELIGHT)) { 1871 new_scene_mode = SCENE_MODE_CANDLE_LIGHT; 1872 new_flash_mode_str = CameraParameters::FLASH_MODE_OFF; 1873 mParameters.set(CameraParameters::KEY_SUPPORTED_FLASH_MODES, "off"); 1874 } else { 1875 LOGE("%s::unmatched scene_mode(%s)", 1876 __func__, new_scene_mode_str); //action, night-portrait, theatre, steadyphoto 1877 ret = UNKNOWN_ERROR; 1878 } 1879 } 1880 1881 // focus mode 1882 if (new_focus_mode_str != NULL) { 1883 int new_focus_mode = -1; 1884 1885 if (!strcmp(new_focus_mode_str, 1886 CameraParameters::FOCUS_MODE_AUTO)) { 1887 new_focus_mode = FOCUS_MODE_AUTO; 1888 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, 1889 BACK_CAMERA_AUTO_FOCUS_DISTANCES_STR); 1890 } 1891 else if (!strcmp(new_focus_mode_str, 1892 CameraParameters::FOCUS_MODE_MACRO)) { 1893 new_focus_mode = FOCUS_MODE_MACRO; 1894 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, 1895 BACK_CAMERA_MACRO_FOCUS_DISTANCES_STR); 1896 } 1897 else if (!strcmp(new_focus_mode_str, 1898 CameraParameters::FOCUS_MODE_INFINITY)) { 1899 new_focus_mode = FOCUS_MODE_INFINITY; 1900 mParameters.set(CameraParameters::KEY_FOCUS_DISTANCES, 1901 BACK_CAMERA_INFINITY_FOCUS_DISTANCES_STR); 1902 } 1903 else { 1904 LOGE("%s::unmatched focus_mode(%s)", __func__, new_focus_mode_str); 1905 ret = UNKNOWN_ERROR; 1906 } 1907 1908 if (0 <= new_focus_mode) { 1909 if (mSecCamera->setFocusMode(new_focus_mode) < 0) { 1910 LOGE("%s::mSecCamera->setFocusMode(%d) fail", __func__, new_focus_mode); 1911 ret = UNKNOWN_ERROR; 1912 } else { 1913 mParameters.set(CameraParameters::KEY_FOCUS_MODE, new_focus_mode_str); 1914 } 1915 } 1916 } 1917 1918 // flash.. 1919 if (new_flash_mode_str != NULL) { 1920 int new_flash_mode = -1; 1921 1922 if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_OFF)) 1923 new_flash_mode = FLASH_MODE_OFF; 1924 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_AUTO)) 1925 new_flash_mode = FLASH_MODE_AUTO; 1926 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_ON)) 1927 new_flash_mode = FLASH_MODE_ON; 1928 else if (!strcmp(new_flash_mode_str, CameraParameters::FLASH_MODE_TORCH)) 1929 new_flash_mode = FLASH_MODE_TORCH; 1930 else { 1931 LOGE("%s::unmatched flash_mode(%s)", __func__, new_flash_mode_str); //red-eye 1932 ret = UNKNOWN_ERROR; 1933 } 1934 if (0 <= new_flash_mode) { 1935 if (mSecCamera->setFlashMode(new_flash_mode) < 0) { 1936 LOGE("%s::mSecCamera->setFlashMode(%d) fail", __func__, new_flash_mode); 1937 ret = UNKNOWN_ERROR; 1938 } else { 1939 mParameters.set(CameraParameters::KEY_FLASH_MODE, new_flash_mode_str); 1940 } 1941 } 1942 } 1943 1944 // scene.. 1945 if (0 <= new_scene_mode) { 1946 if (mSecCamera->setSceneMode(new_scene_mode) < 0) { 1947 LOGE("%s::mSecCamera->setSceneMode(%d) fail", __func__, new_scene_mode); 1948 ret = UNKNOWN_ERROR; 1949 } else { 1950 mParameters.set(CameraParameters::KEY_SCENE_MODE, new_scene_mode_str); 1951 } 1952 } 1953 } else { 1954 if (!isSupportedParameter(new_focus_mode_str, 1955 mParameters.get(CameraParameters::KEY_SUPPORTED_FOCUS_MODES))) { 1956 LOGE("%s: Unsupported focus mode: %s", __func__, new_focus_mode_str); 1957 ret = UNKNOWN_ERROR; 1958 } 1959 } 1960 1961 // --------------------------------------------------------------------------- 1962 1963 // image effect 1964 const char *new_image_effect_str = params.get(CameraParameters::KEY_EFFECT); 1965 if (new_image_effect_str != NULL) { 1966 1967 int new_image_effect = -1; 1968 1969 if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NONE)) 1970 new_image_effect = IMAGE_EFFECT_NONE; 1971 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_MONO)) 1972 new_image_effect = IMAGE_EFFECT_BNW; 1973 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_SEPIA)) 1974 new_image_effect = IMAGE_EFFECT_SEPIA; 1975 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_AQUA)) 1976 new_image_effect = IMAGE_EFFECT_AQUA; 1977 else if (!strcmp(new_image_effect_str, CameraParameters::EFFECT_NEGATIVE)) 1978 new_image_effect = IMAGE_EFFECT_NEGATIVE; 1979 else { 1980 //posterize, whiteboard, blackboard, solarize 1981 LOGE("ERR(%s):Invalid effect(%s)", __func__, new_image_effect_str); 1982 ret = UNKNOWN_ERROR; 1983 } 1984 1985 if (new_image_effect >= 0) { 1986 if (mSecCamera->setImageEffect(new_image_effect) < 0) { 1987 LOGE("ERR(%s):Fail on mSecCamera->setImageEffect(effect(%d))", __func__, new_image_effect); 1988 ret = UNKNOWN_ERROR; 1989 } else { 1990 const char *old_image_effect_str = mParameters.get(CameraParameters::KEY_EFFECT); 1991 1992 if (old_image_effect_str) { 1993 if (strcmp(old_image_effect_str, new_image_effect_str)) { 1994 setSkipFrame(EFFECT_SKIP_FRAME); 1995 } 1996 } 1997 1998 mParameters.set(CameraParameters::KEY_EFFECT, new_image_effect_str); 1999 } 2000 } 2001 } 2002 2003 //vt mode 2004 int new_vtmode = mInternalParameters.getInt("vtmode"); 2005 if (0 <= new_vtmode) { 2006 if (mSecCamera->setVTmode(new_vtmode) < 0) { 2007 LOGE("ERR(%s):Fail on mSecCamera->setVTMode(%d)", __func__, new_vtmode); 2008 ret = UNKNOWN_ERROR; 2009 } 2010 } 2011 2012 //contrast 2013 int new_contrast = mInternalParameters.getInt("contrast"); 2014 2015 if (0 <= new_contrast) { 2016 if (mSecCamera->setContrast(new_contrast) < 0) { 2017 LOGE("ERR(%s):Fail on mSecCamera->setContrast(%d)", __func__, new_contrast); 2018 ret = UNKNOWN_ERROR; 2019 } 2020 } 2021 2022 //WDR 2023 int new_wdr = mInternalParameters.getInt("wdr"); 2024 2025 if (0 <= new_wdr) { 2026 if (mSecCamera->setWDR(new_wdr) < 0) { 2027 LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_wdr); 2028 ret = UNKNOWN_ERROR; 2029 } 2030 } 2031 2032 //anti shake 2033 int new_anti_shake = mInternalParameters.getInt("anti-shake"); 2034 2035 if (0 <= new_anti_shake) { 2036 if (mSecCamera->setAntiShake(new_anti_shake) < 0) { 2037 LOGE("ERR(%s):Fail on mSecCamera->setWDR(%d)", __func__, new_anti_shake); 2038 ret = UNKNOWN_ERROR; 2039 } 2040 } 2041 2042 // gps latitude 2043 const char *new_gps_latitude_str = params.get(CameraParameters::KEY_GPS_LATITUDE); 2044 if (mSecCamera->setGPSLatitude(new_gps_latitude_str) < 0) { 2045 LOGE("%s::mSecCamera->setGPSLatitude(%s) fail", __func__, new_gps_latitude_str); 2046 ret = UNKNOWN_ERROR; 2047 } else { 2048 if (new_gps_latitude_str) { 2049 mParameters.set(CameraParameters::KEY_GPS_LATITUDE, new_gps_latitude_str); 2050 } else { 2051 mParameters.remove(CameraParameters::KEY_GPS_LATITUDE); 2052 } 2053 } 2054 2055 // gps longitude 2056 const char *new_gps_longitude_str = params.get(CameraParameters::KEY_GPS_LONGITUDE); 2057 2058 if (mSecCamera->setGPSLongitude(new_gps_longitude_str) < 0) { 2059 LOGE("%s::mSecCamera->setGPSLongitude(%s) fail", __func__, new_gps_longitude_str); 2060 ret = UNKNOWN_ERROR; 2061 } else { 2062 if (new_gps_longitude_str) { 2063 mParameters.set(CameraParameters::KEY_GPS_LONGITUDE, new_gps_longitude_str); 2064 } else { 2065 mParameters.remove(CameraParameters::KEY_GPS_LONGITUDE); 2066 } 2067 } 2068 2069 // gps altitude 2070 const char *new_gps_altitude_str = params.get(CameraParameters::KEY_GPS_ALTITUDE); 2071 2072 if (mSecCamera->setGPSAltitude(new_gps_altitude_str) < 0) { 2073 LOGE("%s::mSecCamera->setGPSAltitude(%s) fail", __func__, new_gps_altitude_str); 2074 ret = UNKNOWN_ERROR; 2075 } else { 2076 if (new_gps_altitude_str) { 2077 mParameters.set(CameraParameters::KEY_GPS_ALTITUDE, new_gps_altitude_str); 2078 } else { 2079 mParameters.remove(CameraParameters::KEY_GPS_ALTITUDE); 2080 } 2081 } 2082 2083 // gps timestamp 2084 const char *new_gps_timestamp_str = params.get(CameraParameters::KEY_GPS_TIMESTAMP); 2085 2086 if (mSecCamera->setGPSTimeStamp(new_gps_timestamp_str) < 0) { 2087 LOGE("%s::mSecCamera->setGPSTimeStamp(%s) fail", __func__, new_gps_timestamp_str); 2088 ret = UNKNOWN_ERROR; 2089 } else { 2090 if (new_gps_timestamp_str) { 2091 mParameters.set(CameraParameters::KEY_GPS_TIMESTAMP, new_gps_timestamp_str); 2092 } else { 2093 mParameters.remove(CameraParameters::KEY_GPS_TIMESTAMP); 2094 } 2095 } 2096 2097 // gps processing method 2098 const char *new_gps_processing_method_str = params.get(CameraParameters::KEY_GPS_PROCESSING_METHOD); 2099 2100 if (mSecCamera->setGPSProcessingMethod(new_gps_processing_method_str) < 0) { 2101 LOGE("%s::mSecCamera->setGPSProcessingMethod(%s) fail", __func__, new_gps_processing_method_str); 2102 ret = UNKNOWN_ERROR; 2103 } else { 2104 if (new_gps_processing_method_str) { 2105 mParameters.set(CameraParameters::KEY_GPS_PROCESSING_METHOD, new_gps_processing_method_str); 2106 } else { 2107 mParameters.remove(CameraParameters::KEY_GPS_PROCESSING_METHOD); 2108 } 2109 } 2110 2111 // Recording size 2112 int new_recording_width = mInternalParameters.getInt("recording-size-width"); 2113 int new_recording_height= mInternalParameters.getInt("recording-size-height"); 2114 2115 if (0 < new_recording_width && 0 < new_recording_height) { 2116 if (mSecCamera->setRecordingSize(new_recording_width, new_recording_height) < 0) { 2117 LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_recording_width, new_recording_height); 2118 ret = UNKNOWN_ERROR; 2119 } 2120 } else { 2121 if (mSecCamera->setRecordingSize(new_preview_width, new_preview_height) < 0) { 2122 LOGE("ERR(%s):Fail on mSecCamera->setRecordingSize(width(%d), height(%d))", __func__, new_preview_width, new_preview_height); 2123 ret = UNKNOWN_ERROR; 2124 } 2125 } 2126 2127 //gamma 2128 const char *new_gamma_str = mInternalParameters.get("video_recording_gamma"); 2129 2130 if (new_gamma_str != NULL) { 2131 int new_gamma = -1; 2132 if (!strcmp(new_gamma_str, "off")) 2133 new_gamma = GAMMA_OFF; 2134 else if (!strcmp(new_gamma_str, "on")) 2135 new_gamma = GAMMA_ON; 2136 else { 2137 LOGE("%s::unmatched gamma(%s)", __func__, new_gamma_str); 2138 ret = UNKNOWN_ERROR; 2139 } 2140 2141 if (0 <= new_gamma) { 2142 if (mSecCamera->setGamma(new_gamma) < 0) { 2143 LOGE("%s::mSecCamera->setGamma(%d) fail", __func__, new_gamma); 2144 ret = UNKNOWN_ERROR; 2145 } 2146 } 2147 } 2148 2149 //slow ae 2150 const char *new_slow_ae_str = mInternalParameters.get("slow_ae"); 2151 2152 if (new_slow_ae_str != NULL) { 2153 int new_slow_ae = -1; 2154 2155 if (!strcmp(new_slow_ae_str, "off")) 2156 new_slow_ae = SLOW_AE_OFF; 2157 else if (!strcmp(new_slow_ae_str, "on")) 2158 new_slow_ae = SLOW_AE_ON; 2159 else { 2160 LOGE("%s::unmatched slow_ae(%s)", __func__, new_slow_ae_str); 2161 ret = UNKNOWN_ERROR; 2162 } 2163 2164 if (0 <= new_slow_ae) { 2165 if (mSecCamera->setSlowAE(new_slow_ae) < 0) { 2166 LOGE("%s::mSecCamera->setSlowAE(%d) fail", __func__, new_slow_ae); 2167 ret = UNKNOWN_ERROR; 2168 } 2169 } 2170 } 2171 2172 /*Camcorder fix fps*/ 2173 int new_sensor_mode = mInternalParameters.getInt("cam_mode"); 2174 2175 if (0 <= new_sensor_mode) { 2176 if (mSecCamera->setSensorMode(new_sensor_mode) < 0) { 2177 LOGE("ERR(%s):Fail on mSecCamera->setSensorMode(%d)", __func__, new_sensor_mode); 2178 ret = UNKNOWN_ERROR; 2179 } 2180 } else { 2181 new_sensor_mode=0; 2182 } 2183 2184 /*Shot mode*/ 2185 int new_shot_mode = mInternalParameters.getInt("shot_mode"); 2186 2187 if (0 <= new_shot_mode) { 2188 if (mSecCamera->setShotMode(new_shot_mode) < 0) { 2189 LOGE("ERR(%s):Fail on mSecCamera->setShotMode(%d)", __func__, new_shot_mode); 2190 ret = UNKNOWN_ERROR; 2191 } 2192 } else { 2193 new_shot_mode=0; 2194 } 2195 2196 //blur for Video call 2197 int new_blur_level = mInternalParameters.getInt("blur"); 2198 2199 if (0 <= new_blur_level) { 2200 if (mSecCamera->setBlur(new_blur_level) < 0) { 2201 LOGE("ERR(%s):Fail on mSecCamera->setBlur(%d)", __func__, new_blur_level); 2202 ret = UNKNOWN_ERROR; 2203 } 2204 } 2205 2206 2207 // chk_dataline 2208 int new_dataline = mInternalParameters.getInt("chk_dataline"); 2209 2210 if (0 <= new_dataline) { 2211 if (mSecCamera->setDataLineCheck(new_dataline) < 0) { 2212 LOGE("ERR(%s):Fail on mSecCamera->setDataLineCheck(%d)", __func__, new_dataline); 2213 ret = UNKNOWN_ERROR; 2214 } 2215 } 2216 LOGV("%s return ret = %d", __func__, ret); 2217 2218 return ret; 2219 } 2220 2221 CameraParameters CameraHardwareSec::getParameters() const 2222 { 2223 LOGV("%s :", __func__); 2224 return mParameters; 2225 } 2226 2227 status_t CameraHardwareSec::sendCommand(int32_t command, int32_t arg1, int32_t arg2) 2228 { 2229 return BAD_VALUE; 2230 } 2231 2232 void CameraHardwareSec::release() 2233 { 2234 LOGV("%s", __func__); 2235 2236 /* shut down any threads we have that might be running. do it here 2237 * instead of the destructor. we're guaranteed to be on another thread 2238 * than the ones below. if we used the destructor, since the threads 2239 * have a reference to this object, we could wind up trying to wait 2240 * for ourself to exit, which is a deadlock. 2241 */ 2242 if (mPreviewThread != NULL) { 2243 /* this thread is normally already in it's threadLoop but blocked 2244 * on the condition variable or running. signal it so it wakes 2245 * up and can exit. 2246 */ 2247 mPreviewThread->requestExit(); 2248 mExitPreviewThread = true; 2249 mPreviewRunning = true; /* let it run so it can exit */ 2250 mPreviewCondition.signal(); 2251 mPreviewThread->requestExitAndWait(); 2252 mPreviewThread.clear(); 2253 } 2254 if (mAutoFocusThread != NULL) { 2255 /* this thread is normally already in it's threadLoop but blocked 2256 * on the condition variable. signal it so it wakes up and can exit. 2257 */ 2258 mFocusLock.lock(); 2259 mAutoFocusThread->requestExit(); 2260 mExitAutoFocusThread = true; 2261 mFocusCondition.signal(); 2262 mFocusLock.unlock(); 2263 mAutoFocusThread->requestExitAndWait(); 2264 mAutoFocusThread.clear(); 2265 } 2266 if (mPictureThread != NULL) { 2267 mPictureThread->requestExitAndWait(); 2268 mPictureThread.clear(); 2269 } 2270 2271 if (mRawHeap) { 2272 mRawHeap->release(mRawHeap); 2273 mRawHeap = 0; 2274 } 2275 if (mPreviewHeap) { 2276 mPreviewHeap->release(mPreviewHeap); 2277 mPreviewHeap = 0; 2278 } 2279 if (mRecordHeap) { 2280 mRecordHeap->release(mRecordHeap); 2281 mRecordHeap = 0; 2282 } 2283 2284 /* close after all the heaps are cleared since those 2285 * could have dup'd our file descriptor. 2286 */ 2287 mSecCamera->DeinitCamera(); 2288 } 2289 2290 status_t CameraHardwareSec::storeMetaDataInBuffers(bool enable) 2291 { 2292 // FIXME: 2293 // metadata buffer mode can be turned on or off. 2294 // Samsung needs to fix this. 2295 if (!enable) { 2296 LOGE("Non-metadata buffer mode is not supported!"); 2297 return INVALID_OPERATION; 2298 } 2299 return OK; 2300 } 2301 2302 static CameraInfo sCameraInfo[] = { 2303 { 2304 CAMERA_FACING_BACK, 2305 90, /* orientation */ 2306 }, 2307 { 2308 CAMERA_FACING_FRONT, 2309 270, /* orientation */ 2310 } 2311 }; 2312 2313 /** Close this device */ 2314 2315 static camera_device_t *g_cam_device; 2316 2317 static int HAL_camera_device_close(struct hw_device_t* device) 2318 { 2319 LOGI("%s", __func__); 2320 if (device) { 2321 camera_device_t *cam_device = (camera_device_t *)device; 2322 delete static_cast<CameraHardwareSec *>(cam_device->priv); 2323 free(cam_device); 2324 g_cam_device = 0; 2325 } 2326 return 0; 2327 } 2328 2329 static inline CameraHardwareSec *obj(struct camera_device *dev) 2330 { 2331 return reinterpret_cast<CameraHardwareSec *>(dev->priv); 2332 } 2333 2334 /** Set the preview_stream_ops to which preview frames are sent */ 2335 static int HAL_camera_device_set_preview_window(struct camera_device *dev, 2336 struct preview_stream_ops *buf) 2337 { 2338 LOGV("%s", __func__); 2339 return obj(dev)->setPreviewWindow(buf); 2340 } 2341 2342 /** Set the notification and data callbacks */ 2343 static void HAL_camera_device_set_callbacks(struct camera_device *dev, 2344 camera_notify_callback notify_cb, 2345 camera_data_callback data_cb, 2346 camera_data_timestamp_callback data_cb_timestamp, 2347 camera_request_memory get_memory, 2348 void* user) 2349 { 2350 LOGV("%s", __func__); 2351 obj(dev)->setCallbacks(notify_cb, data_cb, data_cb_timestamp, 2352 get_memory, 2353 user); 2354 } 2355 2356 /** 2357 * The following three functions all take a msg_type, which is a bitmask of 2358 * the messages defined in include/ui/Camera.h 2359 */ 2360 2361 /** 2362 * Enable a message, or set of messages. 2363 */ 2364 static void HAL_camera_device_enable_msg_type(struct camera_device *dev, int32_t msg_type) 2365 { 2366 LOGV("%s", __func__); 2367 obj(dev)->enableMsgType(msg_type); 2368 } 2369 2370 /** 2371 * Disable a message, or a set of messages. 2372 * 2373 * Once received a call to disableMsgType(CAMERA_MSG_VIDEO_FRAME), camera 2374 * HAL should not rely on its client to call releaseRecordingFrame() to 2375 * release video recording frames sent out by the cameral HAL before and 2376 * after the disableMsgType(CAMERA_MSG_VIDEO_FRAME) call. Camera HAL 2377 * clients must not modify/access any video recording frame after calling 2378 * disableMsgType(CAMERA_MSG_VIDEO_FRAME). 2379 */ 2380 static void HAL_camera_device_disable_msg_type(struct camera_device *dev, int32_t msg_type) 2381 { 2382 LOGV("%s", __func__); 2383 obj(dev)->disableMsgType(msg_type); 2384 } 2385 2386 /** 2387 * Query whether a message, or a set of messages, is enabled. Note that 2388 * this is operates as an AND, if any of the messages queried are off, this 2389 * will return false. 2390 */ 2391 static int HAL_camera_device_msg_type_enabled(struct camera_device *dev, int32_t msg_type) 2392 { 2393 LOGV("%s", __func__); 2394 return obj(dev)->msgTypeEnabled(msg_type); 2395 } 2396 2397 /** 2398 * Start preview mode. 2399 */ 2400 static int HAL_camera_device_start_preview(struct camera_device *dev) 2401 { 2402 LOGV("%s", __func__); 2403 return obj(dev)->startPreview(); 2404 } 2405 2406 /** 2407 * Stop a previously started preview. 2408 */ 2409 static void HAL_camera_device_stop_preview(struct camera_device *dev) 2410 { 2411 LOGV("%s", __func__); 2412 obj(dev)->stopPreview(); 2413 } 2414 2415 /** 2416 * Returns true if preview is enabled. 2417 */ 2418 static int HAL_camera_device_preview_enabled(struct camera_device *dev) 2419 { 2420 LOGV("%s", __func__); 2421 return obj(dev)->previewEnabled(); 2422 } 2423 2424 /** 2425 * Request the camera HAL to store meta data or real YUV data in the video 2426 * buffers sent out via CAMERA_MSG_VIDEO_FRAME for a recording session. If 2427 * it is not called, the default camera HAL behavior is to store real YUV 2428 * data in the video buffers. 2429 * 2430 * This method should be called before startRecording() in order to be 2431 * effective. 2432 * 2433 * If meta data is stored in the video buffers, it is up to the receiver of 2434 * the video buffers to interpret the contents and to find the actual frame 2435 * data with the help of the meta data in the buffer. How this is done is 2436 * outside of the scope of this method. 2437 * 2438 * Some camera HALs may not support storing meta data in the video buffers, 2439 * but all camera HALs should support storing real YUV data in the video 2440 * buffers. If the camera HAL does not support storing the meta data in the 2441 * video buffers when it is requested to do do, INVALID_OPERATION must be 2442 * returned. It is very useful for the camera HAL to pass meta data rather 2443 * than the actual frame data directly to the video encoder, since the 2444 * amount of the uncompressed frame data can be very large if video size is 2445 * large. 2446 * 2447 * @param enable if true to instruct the camera HAL to store 2448 * meta data in the video buffers; false to instruct 2449 * the camera HAL to store real YUV data in the video 2450 * buffers. 2451 * 2452 * @return OK on success. 2453 */ 2454 static int HAL_camera_device_store_meta_data_in_buffers(struct camera_device *dev, int enable) 2455 { 2456 LOGV("%s", __func__); 2457 return obj(dev)->storeMetaDataInBuffers(enable); 2458 } 2459 2460 /** 2461 * Start record mode. When a record image is available, a 2462 * CAMERA_MSG_VIDEO_FRAME message is sent with the corresponding 2463 * frame. Every record frame must be released by a camera HAL client via 2464 * releaseRecordingFrame() before the client calls 2465 * disableMsgType(CAMERA_MSG_VIDEO_FRAME). After the client calls 2466 * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's 2467 * responsibility to manage the life-cycle of the video recording frames, 2468 * and the client must not modify/access any video recording frames. 2469 */ 2470 static int HAL_camera_device_start_recording(struct camera_device *dev) 2471 { 2472 LOGV("%s", __func__); 2473 return obj(dev)->startRecording(); 2474 } 2475 2476 /** 2477 * Stop a previously started recording. 2478 */ 2479 static void HAL_camera_device_stop_recording(struct camera_device *dev) 2480 { 2481 LOGV("%s", __func__); 2482 obj(dev)->stopRecording(); 2483 } 2484 2485 /** 2486 * Returns true if recording is enabled. 2487 */ 2488 static int HAL_camera_device_recording_enabled(struct camera_device *dev) 2489 { 2490 LOGV("%s", __func__); 2491 return obj(dev)->recordingEnabled(); 2492 } 2493 2494 /** 2495 * Release a record frame previously returned by CAMERA_MSG_VIDEO_FRAME. 2496 * 2497 * It is camera HAL client's responsibility to release video recording 2498 * frames sent out by the camera HAL before the camera HAL receives a call 2499 * to disableMsgType(CAMERA_MSG_VIDEO_FRAME). After it receives the call to 2500 * disableMsgType(CAMERA_MSG_VIDEO_FRAME), it is the camera HAL's 2501 * responsibility to manage the life-cycle of the video recording frames. 2502 */ 2503 static void HAL_camera_device_release_recording_frame(struct camera_device *dev, 2504 const void *opaque) 2505 { 2506 LOGV("%s", __func__); 2507 obj(dev)->releaseRecordingFrame(opaque); 2508 } 2509 2510 /** 2511 * Start auto focus, the notification callback routine is called with 2512 * CAMERA_MSG_FOCUS once when focusing is complete. autoFocus() will be 2513 * called again if another auto focus is needed. 2514 */ 2515 static int HAL_camera_device_auto_focus(struct camera_device *dev) 2516 { 2517 LOGV("%s", __func__); 2518 return obj(dev)->autoFocus(); 2519 } 2520 2521 /** 2522 * Cancels auto-focus function. If the auto-focus is still in progress, 2523 * this function will cancel it. Whether the auto-focus is in progress or 2524 * not, this function will return the focus position to the default. If 2525 * the camera does not support auto-focus, this is a no-op. 2526 */ 2527 static int HAL_camera_device_cancel_auto_focus(struct camera_device *dev) 2528 { 2529 LOGV("%s", __func__); 2530 return obj(dev)->cancelAutoFocus(); 2531 } 2532 2533 /** 2534 * Take a picture. 2535 */ 2536 static int HAL_camera_device_take_picture(struct camera_device *dev) 2537 { 2538 LOGV("%s", __func__); 2539 return obj(dev)->takePicture(); 2540 } 2541 2542 /** 2543 * Cancel a picture that was started with takePicture. Calling this method 2544 * when no picture is being taken is a no-op. 2545 */ 2546 static int HAL_camera_device_cancel_picture(struct camera_device *dev) 2547 { 2548 LOGV("%s", __func__); 2549 return obj(dev)->cancelPicture(); 2550 } 2551 2552 /** 2553 * Set the camera parameters. This returns BAD_VALUE if any parameter is 2554 * invalid or not supported. 2555 */ 2556 static int HAL_camera_device_set_parameters(struct camera_device *dev, 2557 const char *parms) 2558 { 2559 LOGV("%s", __func__); 2560 String8 str(parms); 2561 CameraParameters p(str); 2562 return obj(dev)->setParameters(p); 2563 } 2564 2565 /** Return the camera parameters. */ 2566 char *HAL_camera_device_get_parameters(struct camera_device *dev) 2567 { 2568 LOGV("%s", __func__); 2569 String8 str; 2570 CameraParameters parms = obj(dev)->getParameters(); 2571 str = parms.flatten(); 2572 return strdup(str.string()); 2573 } 2574 2575 void HAL_camera_device_put_parameters(struct camera_device *dev, char *parms) 2576 { 2577 LOGV("%s", __func__); 2578 free(parms); 2579 } 2580 2581 /** 2582 * Send command to camera driver. 2583 */ 2584 static int HAL_camera_device_send_command(struct camera_device *dev, 2585 int32_t cmd, int32_t arg1, int32_t arg2) 2586 { 2587 LOGV("%s", __func__); 2588 return obj(dev)->sendCommand(cmd, arg1, arg2); 2589 } 2590 2591 /** 2592 * Release the hardware resources owned by this object. Note that this is 2593 * *not* done in the destructor. 2594 */ 2595 static void HAL_camera_device_release(struct camera_device *dev) 2596 { 2597 LOGV("%s", __func__); 2598 obj(dev)->release(); 2599 } 2600 2601 /** 2602 * Dump state of the camera hardware 2603 */ 2604 static int HAL_camera_device_dump(struct camera_device *dev, int fd) 2605 { 2606 LOGV("%s", __func__); 2607 return obj(dev)->dump(fd); 2608 } 2609 2610 static int HAL_getNumberOfCameras() 2611 { 2612 LOGV("%s", __func__); 2613 return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]); 2614 } 2615 2616 static int HAL_getCameraInfo(int cameraId, struct camera_info *cameraInfo) 2617 { 2618 LOGV("%s", __func__); 2619 memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo)); 2620 return 0; 2621 } 2622 2623 #define SET_METHOD(m) m : HAL_camera_device_##m 2624 2625 static camera_device_ops_t camera_device_ops = { 2626 SET_METHOD(set_preview_window), 2627 SET_METHOD(set_callbacks), 2628 SET_METHOD(enable_msg_type), 2629 SET_METHOD(disable_msg_type), 2630 SET_METHOD(msg_type_enabled), 2631 SET_METHOD(start_preview), 2632 SET_METHOD(stop_preview), 2633 SET_METHOD(preview_enabled), 2634 SET_METHOD(store_meta_data_in_buffers), 2635 SET_METHOD(start_recording), 2636 SET_METHOD(stop_recording), 2637 SET_METHOD(recording_enabled), 2638 SET_METHOD(release_recording_frame), 2639 SET_METHOD(auto_focus), 2640 SET_METHOD(cancel_auto_focus), 2641 SET_METHOD(take_picture), 2642 SET_METHOD(cancel_picture), 2643 SET_METHOD(set_parameters), 2644 SET_METHOD(get_parameters), 2645 SET_METHOD(put_parameters), 2646 SET_METHOD(send_command), 2647 SET_METHOD(release), 2648 SET_METHOD(dump), 2649 }; 2650 2651 #undef SET_METHOD 2652 2653 static int HAL_camera_device_open(const struct hw_module_t* module, 2654 const char *id, 2655 struct hw_device_t** device) 2656 { 2657 LOGV("%s", __func__); 2658 2659 int cameraId = atoi(id); 2660 if (cameraId < 0 || cameraId >= HAL_getNumberOfCameras()) { 2661 LOGE("Invalid camera ID %s", id); 2662 return -EINVAL; 2663 } 2664 2665 if (g_cam_device) { 2666 if (obj(g_cam_device)->getCameraId() == cameraId) { 2667 LOGV("returning existing camera ID %s", id); 2668 goto done; 2669 } else { 2670 LOGE("Cannot open camera %d. camera %d is already running!", 2671 cameraId, obj(g_cam_device)->getCameraId()); 2672 return -ENOSYS; 2673 } 2674 } 2675 2676 g_cam_device = (camera_device_t *)malloc(sizeof(camera_device_t)); 2677 if (!g_cam_device) 2678 return -ENOMEM; 2679 2680 g_cam_device->common.tag = HARDWARE_DEVICE_TAG; 2681 g_cam_device->common.version = 1; 2682 g_cam_device->common.module = const_cast<hw_module_t *>(module); 2683 g_cam_device->common.close = HAL_camera_device_close; 2684 2685 g_cam_device->ops = &camera_device_ops; 2686 2687 LOGI("%s: open camera %s", __func__, id); 2688 2689 g_cam_device->priv = new CameraHardwareSec(cameraId, g_cam_device); 2690 2691 done: 2692 *device = (hw_device_t *)g_cam_device; 2693 LOGI("%s: opened camera %s (%p)", __func__, id, *device); 2694 return 0; 2695 } 2696 2697 static hw_module_methods_t camera_module_methods = { 2698 open : HAL_camera_device_open 2699 }; 2700 2701 extern "C" { 2702 struct camera_module HAL_MODULE_INFO_SYM = { 2703 common : { 2704 tag : HARDWARE_MODULE_TAG, 2705 version_major : 1, 2706 version_minor : 0, 2707 id : CAMERA_HARDWARE_MODULE_ID, 2708 name : "Crespo camera HAL", 2709 author : "Samsung Corporation", 2710 methods : &camera_module_methods, 2711 }, 2712 get_number_of_cameras : HAL_getNumberOfCameras, 2713 get_camera_info : HAL_getCameraInfo 2714 }; 2715 } 2716 2717 }; // namespace android 2718
