1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "Camera2" 18 #define ATRACE_TAG ATRACE_TAG_CAMERA 19 //#define LOG_NDEBUG 0 20 21 #include <utils/Log.h> 22 #include <utils/Trace.h> 23 24 #include <cutils/properties.h> 25 #include <gui/SurfaceTextureClient.h> 26 #include <gui/Surface.h> 27 #include "camera2/Parameters.h" 28 #include "Camera2Client.h" 29 30 #define ALOG1(...) ALOGD_IF(gLogLevel >= 1, __VA_ARGS__); 31 #define ALOG2(...) ALOGD_IF(gLogLevel >= 2, __VA_ARGS__); 32 33 namespace android { 34 using namespace camera2; 35 36 static int getCallingPid() { 37 return IPCThreadState::self()->getCallingPid(); 38 } 39 40 static int getCallingUid() { 41 return IPCThreadState::self()->getCallingUid(); 42 } 43 44 // Interface used by CameraService 45 46 Camera2Client::Camera2Client(const sp<CameraService>& cameraService, 47 const sp<ICameraClient>& cameraClient, 48 int cameraId, 49 int cameraFacing, 50 int clientPid, 51 int servicePid): 52 Client(cameraService, cameraClient, 53 cameraId, cameraFacing, clientPid, servicePid), 54 mSharedCameraClient(cameraClient), 55 mParameters(cameraId, cameraFacing) 56 { 57 ATRACE_CALL(); 58 ALOGI("Camera %d: Opened", cameraId); 59 60 mDevice = new Camera2Device(cameraId); 61 62 SharedParameters::Lock l(mParameters); 63 l.mParameters.state = Parameters::DISCONNECTED; 64 } 65 66 status_t Camera2Client::checkPid(const char* checkLocation) const { 67 int callingPid = getCallingPid(); 68 if (callingPid == mClientPid) return NO_ERROR; 69 70 ALOGE("%s: attempt to use a locked camera from a different process" 71 " (old pid %d, new pid %d)", checkLocation, mClientPid, callingPid); 72 return PERMISSION_DENIED; 73 } 74 75 status_t Camera2Client::initialize(camera_module_t *module) 76 { 77 ATRACE_CALL(); 78 ALOGV("%s: Initializing client for camera %d", __FUNCTION__, mCameraId); 79 status_t res; 80 81 res = mDevice->initialize(module); 82 if (res != OK) { 83 ALOGE("%s: Camera %d: unable to initialize device: %s (%d)", 84 __FUNCTION__, mCameraId, strerror(-res), res); 85 return NO_INIT; 86 } 87 88 res = mDevice->setNotifyCallback(this); 89 90 SharedParameters::Lock l(mParameters); 91 92 res = l.mParameters.initialize(&(mDevice->info())); 93 if (res != OK) { 94 ALOGE("%s: Camera %d: unable to build defaults: %s (%d)", 95 __FUNCTION__, mCameraId, strerror(-res), res); 96 return NO_INIT; 97 } 98 99 String8 threadName; 100 101 mStreamingProcessor = new StreamingProcessor(this); 102 103 mFrameProcessor = new FrameProcessor(this); 104 threadName = String8::format("C2-%d-FrameProc", 105 mCameraId); 106 mFrameProcessor->run(threadName.string()); 107 108 mCaptureSequencer = new CaptureSequencer(this); 109 threadName = String8::format("C2-%d-CaptureSeq", 110 mCameraId); 111 mCaptureSequencer->run(threadName.string()); 112 113 mJpegProcessor = new JpegProcessor(this, mCaptureSequencer); 114 threadName = String8::format("C2-%d-JpegProc", 115 mCameraId); 116 mJpegProcessor->run(threadName.string()); 117 118 mZslProcessor = new ZslProcessor(this, mCaptureSequencer); 119 threadName = String8::format("C2-%d-ZslProc", 120 mCameraId); 121 mZslProcessor->run(threadName.string()); 122 123 mCallbackProcessor = new CallbackProcessor(this); 124 threadName = String8::format("C2-%d-CallbkProc", 125 mCameraId); 126 mCallbackProcessor->run(threadName.string()); 127 128 if (gLogLevel >= 1) { 129 ALOGD("%s: Default parameters converted from camera %d:", __FUNCTION__, 130 mCameraId); 131 ALOGD("%s", l.mParameters.paramsFlattened.string()); 132 } 133 134 return OK; 135 } 136 137 Camera2Client::~Camera2Client() { 138 ATRACE_CALL(); 139 140 mDestructionStarted = true; 141 142 disconnect(); 143 144 ALOGI("Camera %d: Closed", mCameraId); 145 } 146 147 status_t Camera2Client::dump(int fd, const Vector<String16>& args) { 148 String8 result; 149 result.appendFormat("Client2[%d] (%p) PID: %d, dump:\n", 150 mCameraId, 151 getCameraClient()->asBinder().get(), 152 mClientPid); 153 result.append(" State: "); 154 #define CASE_APPEND_ENUM(x) case x: result.append(#x "\n"); break; 155 156 const Parameters& p = mParameters.unsafeAccess(); 157 158 result.append(Parameters::getStateName(p.state)); 159 160 result.append("\n Current parameters:\n"); 161 result.appendFormat(" Preview size: %d x %d\n", 162 p.previewWidth, p.previewHeight); 163 result.appendFormat(" Preview FPS range: %d - %d\n", 164 p.previewFpsRange[0], p.previewFpsRange[1]); 165 result.appendFormat(" Preview HAL pixel format: 0x%x\n", 166 p.previewFormat); 167 result.appendFormat(" Preview transform: %x\n", 168 p.previewTransform); 169 result.appendFormat(" Picture size: %d x %d\n", 170 p.pictureWidth, p.pictureHeight); 171 result.appendFormat(" Jpeg thumbnail size: %d x %d\n", 172 p.jpegThumbSize[0], p.jpegThumbSize[1]); 173 result.appendFormat(" Jpeg quality: %d, thumbnail quality: %d\n", 174 p.jpegQuality, p.jpegThumbQuality); 175 result.appendFormat(" Jpeg rotation: %d\n", p.jpegRotation); 176 result.appendFormat(" GPS tags %s\n", 177 p.gpsEnabled ? "enabled" : "disabled"); 178 if (p.gpsEnabled) { 179 result.appendFormat(" GPS lat x long x alt: %f x %f x %f\n", 180 p.gpsCoordinates[0], p.gpsCoordinates[1], 181 p.gpsCoordinates[2]); 182 result.appendFormat(" GPS timestamp: %lld\n", 183 p.gpsTimestamp); 184 result.appendFormat(" GPS processing method: %s\n", 185 p.gpsProcessingMethod.string()); 186 } 187 188 result.append(" White balance mode: "); 189 switch (p.wbMode) { 190 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_AUTO) 191 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_INCANDESCENT) 192 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_FLUORESCENT) 193 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_WARM_FLUORESCENT) 194 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_DAYLIGHT) 195 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_CLOUDY_DAYLIGHT) 196 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_TWILIGHT) 197 CASE_APPEND_ENUM(ANDROID_CONTROL_AWB_SHADE) 198 default: result.append("UNKNOWN\n"); 199 } 200 201 result.append(" Effect mode: "); 202 switch (p.effectMode) { 203 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_OFF) 204 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_MONO) 205 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_NEGATIVE) 206 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SOLARIZE) 207 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_SEPIA) 208 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_POSTERIZE) 209 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_WHITEBOARD) 210 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_BLACKBOARD) 211 CASE_APPEND_ENUM(ANDROID_CONTROL_EFFECT_AQUA) 212 default: result.append("UNKNOWN\n"); 213 } 214 215 result.append(" Antibanding mode: "); 216 switch (p.antibandingMode) { 217 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_AUTO) 218 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_OFF) 219 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_50HZ) 220 CASE_APPEND_ENUM(ANDROID_CONTROL_AE_ANTIBANDING_60HZ) 221 default: result.append("UNKNOWN\n"); 222 } 223 224 result.append(" Scene mode: "); 225 switch (p.sceneMode) { 226 case ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED: 227 result.append("AUTO\n"); break; 228 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_ACTION) 229 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PORTRAIT) 230 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_LANDSCAPE) 231 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT) 232 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_NIGHT_PORTRAIT) 233 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_THEATRE) 234 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BEACH) 235 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SNOW) 236 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SUNSET) 237 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_STEADYPHOTO) 238 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_FIREWORKS) 239 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_SPORTS) 240 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_PARTY) 241 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_CANDLELIGHT) 242 CASE_APPEND_ENUM(ANDROID_CONTROL_SCENE_MODE_BARCODE) 243 default: result.append("UNKNOWN\n"); 244 } 245 246 result.append(" Flash mode: "); 247 switch (p.flashMode) { 248 CASE_APPEND_ENUM(Parameters::FLASH_MODE_OFF) 249 CASE_APPEND_ENUM(Parameters::FLASH_MODE_AUTO) 250 CASE_APPEND_ENUM(Parameters::FLASH_MODE_ON) 251 CASE_APPEND_ENUM(Parameters::FLASH_MODE_TORCH) 252 CASE_APPEND_ENUM(Parameters::FLASH_MODE_RED_EYE) 253 CASE_APPEND_ENUM(Parameters::FLASH_MODE_INVALID) 254 default: result.append("UNKNOWN\n"); 255 } 256 257 result.append(" Focus mode: "); 258 switch (p.focusMode) { 259 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_AUTO) 260 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_MACRO) 261 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) 262 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_CONTINUOUS_PICTURE) 263 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_EDOF) 264 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INFINITY) 265 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_FIXED) 266 CASE_APPEND_ENUM(Parameters::FOCUS_MODE_INVALID) 267 default: result.append("UNKNOWN\n"); 268 } 269 270 result.append(" Focus state: "); 271 switch (p.focusState) { 272 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_INACTIVE) 273 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN) 274 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED) 275 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN) 276 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED) 277 CASE_APPEND_ENUM(ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED) 278 default: result.append("UNKNOWN\n"); 279 } 280 281 result.append(" Focusing areas:\n"); 282 for (size_t i = 0; i < p.focusingAreas.size(); i++) { 283 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 284 p.focusingAreas[i].left, 285 p.focusingAreas[i].top, 286 p.focusingAreas[i].right, 287 p.focusingAreas[i].bottom, 288 p.focusingAreas[i].weight); 289 } 290 291 result.appendFormat(" Exposure compensation index: %d\n", 292 p.exposureCompensation); 293 294 result.appendFormat(" AE lock %s, AWB lock %s\n", 295 p.autoExposureLock ? "enabled" : "disabled", 296 p.autoWhiteBalanceLock ? "enabled" : "disabled" ); 297 298 result.appendFormat(" Metering areas:\n"); 299 for (size_t i = 0; i < p.meteringAreas.size(); i++) { 300 result.appendFormat(" [ (%d, %d, %d, %d), weight %d ]\n", 301 p.meteringAreas[i].left, 302 p.meteringAreas[i].top, 303 p.meteringAreas[i].right, 304 p.meteringAreas[i].bottom, 305 p.meteringAreas[i].weight); 306 } 307 308 result.appendFormat(" Zoom index: %d\n", p.zoom); 309 result.appendFormat(" Video size: %d x %d\n", p.videoWidth, 310 p.videoHeight); 311 312 result.appendFormat(" Recording hint is %s\n", 313 p.recordingHint ? "set" : "not set"); 314 315 result.appendFormat(" Video stabilization is %s\n", 316 p.videoStabilization ? "enabled" : "disabled"); 317 318 result.append(" Current streams:\n"); 319 result.appendFormat(" Preview stream ID: %d\n", 320 getPreviewStreamId()); 321 result.appendFormat(" Capture stream ID: %d\n", 322 getCaptureStreamId()); 323 result.appendFormat(" Recording stream ID: %d\n", 324 getRecordingStreamId()); 325 326 result.append(" Quirks for this camera:\n"); 327 bool haveQuirk = false; 328 if (p.quirks.triggerAfWithAuto) { 329 result.appendFormat(" triggerAfWithAuto\n"); 330 haveQuirk = true; 331 } 332 if (p.quirks.useZslFormat) { 333 result.appendFormat(" useZslFormat\n"); 334 haveQuirk = true; 335 } 336 if (p.quirks.meteringCropRegion) { 337 result.appendFormat(" meteringCropRegion\n"); 338 haveQuirk = true; 339 } 340 if (!haveQuirk) { 341 result.appendFormat(" none\n"); 342 } 343 344 write(fd, result.string(), result.size()); 345 346 mStreamingProcessor->dump(fd, args); 347 348 mCaptureSequencer->dump(fd, args); 349 350 mFrameProcessor->dump(fd, args); 351 352 mZslProcessor->dump(fd, args); 353 354 result = " Device dump:\n"; 355 write(fd, result.string(), result.size()); 356 357 status_t res = mDevice->dump(fd, args); 358 if (res != OK) { 359 result = String8::format(" Error dumping device: %s (%d)", 360 strerror(-res), res); 361 write(fd, result.string(), result.size()); 362 } 363 364 #undef CASE_APPEND_ENUM 365 return NO_ERROR; 366 } 367 368 // ICamera interface 369 370 void Camera2Client::disconnect() { 371 ATRACE_CALL(); 372 Mutex::Autolock icl(mICameraLock); 373 status_t res; 374 375 // Allow both client and the media server to disconnect at all times 376 int callingPid = getCallingPid(); 377 if (callingPid != mClientPid && callingPid != mServicePid) return; 378 379 if (mDevice == 0) return; 380 381 ALOGV("Camera %d: Shutting down", mCameraId); 382 383 stopPreviewL(); 384 385 { 386 SharedParameters::Lock l(mParameters); 387 if (l.mParameters.state == Parameters::DISCONNECTED) return; 388 l.mParameters.state = Parameters::DISCONNECTED; 389 } 390 391 mStreamingProcessor->deletePreviewStream(); 392 mStreamingProcessor->deleteRecordingStream(); 393 mJpegProcessor->deleteStream(); 394 mCallbackProcessor->deleteStream(); 395 mZslProcessor->deleteStream(); 396 397 mFrameProcessor->requestExit(); 398 mCaptureSequencer->requestExit(); 399 mJpegProcessor->requestExit(); 400 mZslProcessor->requestExit(); 401 mCallbackProcessor->requestExit(); 402 403 ALOGV("Camera %d: Waiting for threads", mCameraId); 404 405 mFrameProcessor->join(); 406 mCaptureSequencer->join(); 407 mJpegProcessor->join(); 408 mZslProcessor->join(); 409 mCallbackProcessor->join(); 410 411 ALOGV("Camera %d: Disconnecting device", mCameraId); 412 413 mDevice->disconnect(); 414 415 mDevice.clear(); 416 417 CameraService::Client::disconnect(); 418 } 419 420 status_t Camera2Client::connect(const sp<ICameraClient>& client) { 421 ATRACE_CALL(); 422 ALOGV("%s: E", __FUNCTION__); 423 Mutex::Autolock icl(mICameraLock); 424 425 if (mClientPid != 0 && getCallingPid() != mClientPid) { 426 ALOGE("%s: Camera %d: Connection attempt from pid %d; " 427 "current locked to pid %d", __FUNCTION__, 428 mCameraId, getCallingPid(), mClientPid); 429 return BAD_VALUE; 430 } 431 432 mClientPid = getCallingPid(); 433 434 mCameraClient = client; 435 mSharedCameraClient = client; 436 437 return OK; 438 } 439 440 status_t Camera2Client::lock() { 441 ATRACE_CALL(); 442 ALOGV("%s: E", __FUNCTION__); 443 Mutex::Autolock icl(mICameraLock); 444 ALOGV("%s: Camera %d: Lock call from pid %d; current client pid %d", 445 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 446 447 if (mClientPid == 0) { 448 mClientPid = getCallingPid(); 449 return OK; 450 } 451 452 if (mClientPid != getCallingPid()) { 453 ALOGE("%s: Camera %d: Lock call from pid %d; currently locked to pid %d", 454 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 455 return EBUSY; 456 } 457 458 return OK; 459 } 460 461 status_t Camera2Client::unlock() { 462 ATRACE_CALL(); 463 ALOGV("%s: E", __FUNCTION__); 464 Mutex::Autolock icl(mICameraLock); 465 ALOGV("%s: Camera %d: Unlock call from pid %d; current client pid %d", 466 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 467 468 if (mClientPid == getCallingPid()) { 469 SharedParameters::Lock l(mParameters); 470 if (l.mParameters.state == Parameters::RECORD || 471 l.mParameters.state == Parameters::VIDEO_SNAPSHOT) { 472 ALOGD("Not allowed to unlock camera during recording."); 473 return INVALID_OPERATION; 474 } 475 mClientPid = 0; 476 mCameraClient.clear(); 477 mSharedCameraClient.clear(); 478 return OK; 479 } 480 481 ALOGE("%s: Camera %d: Unlock call from pid %d; currently locked to pid %d", 482 __FUNCTION__, mCameraId, getCallingPid(), mClientPid); 483 return EBUSY; 484 } 485 486 status_t Camera2Client::setPreviewDisplay( 487 const sp<Surface>& surface) { 488 ATRACE_CALL(); 489 ALOGV("%s: E", __FUNCTION__); 490 Mutex::Autolock icl(mICameraLock); 491 status_t res; 492 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 493 494 sp<IBinder> binder; 495 sp<ANativeWindow> window; 496 if (surface != 0) { 497 binder = surface->asBinder(); 498 window = surface; 499 } 500 501 return setPreviewWindowL(binder,window); 502 } 503 504 status_t Camera2Client::setPreviewTexture( 505 const sp<ISurfaceTexture>& surfaceTexture) { 506 ATRACE_CALL(); 507 ALOGV("%s: E", __FUNCTION__); 508 Mutex::Autolock icl(mICameraLock); 509 status_t res; 510 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 511 512 sp<IBinder> binder; 513 sp<ANativeWindow> window; 514 if (surfaceTexture != 0) { 515 binder = surfaceTexture->asBinder(); 516 window = new SurfaceTextureClient(surfaceTexture); 517 } 518 return setPreviewWindowL(binder, window); 519 } 520 521 status_t Camera2Client::setPreviewWindowL(const sp<IBinder>& binder, 522 sp<ANativeWindow> window) { 523 ATRACE_CALL(); 524 status_t res; 525 526 if (binder == mPreviewSurface) { 527 ALOGV("%s: Camera %d: New window is same as old window", 528 __FUNCTION__, mCameraId); 529 return NO_ERROR; 530 } 531 532 Parameters::State state; 533 { 534 SharedParameters::Lock l(mParameters); 535 state = l.mParameters.state; 536 } 537 switch (state) { 538 case Parameters::DISCONNECTED: 539 case Parameters::RECORD: 540 case Parameters::STILL_CAPTURE: 541 case Parameters::VIDEO_SNAPSHOT: 542 ALOGE("%s: Camera %d: Cannot set preview display while in state %s", 543 __FUNCTION__, mCameraId, 544 Parameters::getStateName(state)); 545 return INVALID_OPERATION; 546 case Parameters::STOPPED: 547 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 548 // OK 549 break; 550 case Parameters::PREVIEW: 551 // Already running preview - need to stop and create a new stream 552 mStreamingProcessor->stopStream(); 553 state = Parameters::WAITING_FOR_PREVIEW_WINDOW; 554 break; 555 } 556 557 mPreviewSurface = binder; 558 res = mStreamingProcessor->setPreviewWindow(window); 559 if (res != OK) { 560 ALOGE("%s: Unable to set new preview window: %s (%d)", 561 __FUNCTION__, strerror(-res), res); 562 return res; 563 } 564 565 if (state == Parameters::WAITING_FOR_PREVIEW_WINDOW) { 566 SharedParameters::Lock l(mParameters); 567 l.mParameters.state = state; 568 return startPreviewL(l.mParameters, false); 569 } 570 571 return OK; 572 } 573 574 void Camera2Client::setPreviewCallbackFlag(int flag) { 575 ATRACE_CALL(); 576 ALOGV("%s: Camera %d: Flag 0x%x", __FUNCTION__, mCameraId, flag); 577 Mutex::Autolock icl(mICameraLock); 578 status_t res; 579 if ( checkPid(__FUNCTION__) != OK) return; 580 581 SharedParameters::Lock l(mParameters); 582 setPreviewCallbackFlagL(l.mParameters, flag); 583 } 584 585 void Camera2Client::setPreviewCallbackFlagL(Parameters ¶ms, int flag) { 586 status_t res = OK; 587 if (flag & CAMERA_FRAME_CALLBACK_FLAG_ONE_SHOT_MASK) { 588 ALOGV("%s: setting oneshot", __FUNCTION__); 589 params.previewCallbackOneShot = true; 590 } 591 if (params.previewCallbackFlags != (uint32_t)flag) { 592 params.previewCallbackFlags = flag; 593 switch(params.state) { 594 case Parameters::PREVIEW: 595 res = startPreviewL(params, true); 596 break; 597 case Parameters::RECORD: 598 case Parameters::VIDEO_SNAPSHOT: 599 res = startRecordingL(params, true); 600 break; 601 default: 602 break; 603 } 604 if (res != OK) { 605 ALOGE("%s: Camera %d: Unable to refresh request in state %s", 606 __FUNCTION__, mCameraId, 607 Parameters::getStateName(params.state)); 608 } 609 } 610 611 } 612 613 status_t Camera2Client::startPreview() { 614 ATRACE_CALL(); 615 ALOGV("%s: E", __FUNCTION__); 616 Mutex::Autolock icl(mICameraLock); 617 status_t res; 618 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 619 SharedParameters::Lock l(mParameters); 620 return startPreviewL(l.mParameters, false); 621 } 622 623 status_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) { 624 ATRACE_CALL(); 625 status_t res; 626 627 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart); 628 629 if ( (params.state == Parameters::PREVIEW || 630 params.state == Parameters::RECORD || 631 params.state == Parameters::VIDEO_SNAPSHOT) 632 && !restart) { 633 // Succeed attempt to re-enter a streaming state 634 ALOGI("%s: Camera %d: Preview already active, ignoring restart", 635 __FUNCTION__, mCameraId); 636 return OK; 637 } 638 if (params.state > Parameters::PREVIEW && !restart) { 639 ALOGE("%s: Can't start preview in state %s", 640 __FUNCTION__, 641 Parameters::getStateName(params.state)); 642 return INVALID_OPERATION; 643 } 644 645 if (!mStreamingProcessor->haveValidPreviewWindow()) { 646 params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW; 647 return OK; 648 } 649 params.state = Parameters::STOPPED; 650 651 res = mStreamingProcessor->updatePreviewStream(params); 652 if (res != OK) { 653 ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)", 654 __FUNCTION__, mCameraId, strerror(-res), res); 655 return res; 656 } 657 658 Vector<uint8_t> outputStreams; 659 bool callbacksEnabled = params.previewCallbackFlags & 660 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK; 661 if (callbacksEnabled) { 662 res = mCallbackProcessor->updateStream(params); 663 if (res != OK) { 664 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)", 665 __FUNCTION__, mCameraId, strerror(-res), res); 666 return res; 667 } 668 outputStreams.push(getCallbackStreamId()); 669 } 670 if (params.zslMode && !params.recordingHint) { 671 res = mZslProcessor->updateStream(params); 672 if (res != OK) { 673 ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)", 674 __FUNCTION__, mCameraId, strerror(-res), res); 675 return res; 676 } 677 outputStreams.push(getZslStreamId()); 678 } 679 680 outputStreams.push(getPreviewStreamId()); 681 682 if (!params.recordingHint) { 683 if (!restart) { 684 res = mStreamingProcessor->updatePreviewRequest(params); 685 if (res != OK) { 686 ALOGE("%s: Camera %d: Can't set up preview request: " 687 "%s (%d)", __FUNCTION__, mCameraId, 688 strerror(-res), res); 689 return res; 690 } 691 } 692 res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW, 693 outputStreams); 694 } else { 695 // With recording hint set, we're going to be operating under the 696 // assumption that the user will record video. To optimize recording 697 // startup time, create the necessary output streams for recording and 698 // video snapshot now if they don't already exist. 699 res = mJpegProcessor->updateStream(params); 700 if (res != OK) { 701 ALOGE("%s: Camera %d: Can't pre-configure still image " 702 "stream: %s (%d)", 703 __FUNCTION__, mCameraId, strerror(-res), res); 704 return res; 705 } 706 707 if (!restart) { 708 res = mStreamingProcessor->updateRecordingRequest(params); 709 if (res != OK) { 710 ALOGE("%s: Camera %d: Can't set up preview request with " 711 "record hint: %s (%d)", __FUNCTION__, mCameraId, 712 strerror(-res), res); 713 return res; 714 } 715 } 716 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD, 717 outputStreams); 718 } 719 if (res != OK) { 720 ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)", 721 __FUNCTION__, mCameraId, strerror(-res), res); 722 return res; 723 } 724 725 params.state = Parameters::PREVIEW; 726 return OK; 727 } 728 729 void Camera2Client::stopPreview() { 730 ATRACE_CALL(); 731 ALOGV("%s: E", __FUNCTION__); 732 Mutex::Autolock icl(mICameraLock); 733 status_t res; 734 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 735 stopPreviewL(); 736 } 737 738 void Camera2Client::stopPreviewL() { 739 ATRACE_CALL(); 740 status_t res; 741 const nsecs_t kStopCaptureTimeout = 3000000000LL; // 3 seconds 742 Parameters::State state; 743 { 744 SharedParameters::Lock l(mParameters); 745 state = l.mParameters.state; 746 } 747 748 switch (state) { 749 case Parameters::DISCONNECTED: 750 ALOGE("%s: Camera %d: Call before initialized", 751 __FUNCTION__, mCameraId); 752 break; 753 case Parameters::STOPPED: 754 case Parameters::VIDEO_SNAPSHOT: 755 case Parameters::STILL_CAPTURE: 756 mCaptureSequencer->waitUntilIdle(kStopCaptureTimeout); 757 // no break 758 case Parameters::RECORD: 759 case Parameters::PREVIEW: 760 mStreamingProcessor->stopStream(); 761 res = mDevice->waitUntilDrained(); 762 if (res != OK) { 763 ALOGE("%s: Camera %d: Waiting to stop streaming failed: %s (%d)", 764 __FUNCTION__, mCameraId, strerror(-res), res); 765 } 766 // no break 767 case Parameters::WAITING_FOR_PREVIEW_WINDOW: { 768 SharedParameters::Lock l(mParameters); 769 l.mParameters.state = Parameters::STOPPED; 770 commandStopFaceDetectionL(l.mParameters); 771 break; 772 } 773 default: 774 ALOGE("%s: Camera %d: Unknown state %d", __FUNCTION__, mCameraId, 775 state); 776 } 777 } 778 779 bool Camera2Client::previewEnabled() { 780 ATRACE_CALL(); 781 Mutex::Autolock icl(mICameraLock); 782 status_t res; 783 if ( (res = checkPid(__FUNCTION__) ) != OK) return false; 784 785 SharedParameters::Lock l(mParameters); 786 return l.mParameters.state == Parameters::PREVIEW; 787 } 788 789 status_t Camera2Client::storeMetaDataInBuffers(bool enabled) { 790 ATRACE_CALL(); 791 Mutex::Autolock icl(mICameraLock); 792 status_t res; 793 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 794 795 SharedParameters::Lock l(mParameters); 796 switch (l.mParameters.state) { 797 case Parameters::RECORD: 798 case Parameters::VIDEO_SNAPSHOT: 799 ALOGE("%s: Camera %d: Can't be called in state %s", 800 __FUNCTION__, mCameraId, 801 Parameters::getStateName(l.mParameters.state)); 802 return INVALID_OPERATION; 803 default: 804 // OK 805 break; 806 } 807 808 l.mParameters.storeMetadataInBuffers = enabled; 809 810 return OK; 811 } 812 813 status_t Camera2Client::startRecording() { 814 ATRACE_CALL(); 815 ALOGV("%s: E", __FUNCTION__); 816 Mutex::Autolock icl(mICameraLock); 817 status_t res; 818 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 819 SharedParameters::Lock l(mParameters); 820 821 return startRecordingL(l.mParameters, false); 822 } 823 824 status_t Camera2Client::startRecordingL(Parameters ¶ms, bool restart) { 825 status_t res; 826 827 ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart); 828 829 switch (params.state) { 830 case Parameters::STOPPED: 831 res = startPreviewL(params, false); 832 if (res != OK) return res; 833 break; 834 case Parameters::PREVIEW: 835 // Ready to go 836 break; 837 case Parameters::RECORD: 838 case Parameters::VIDEO_SNAPSHOT: 839 // OK to call this when recording is already on, just skip unless 840 // we're looking to restart 841 if (!restart) return OK; 842 break; 843 default: 844 ALOGE("%s: Camera %d: Can't start recording in state %s", 845 __FUNCTION__, mCameraId, 846 Parameters::getStateName(params.state)); 847 return INVALID_OPERATION; 848 }; 849 850 if (!params.storeMetadataInBuffers) { 851 ALOGE("%s: Camera %d: Recording only supported in metadata mode, but " 852 "non-metadata recording mode requested!", __FUNCTION__, 853 mCameraId); 854 return INVALID_OPERATION; 855 } 856 857 if (!restart) { 858 mCameraService->playSound(CameraService::SOUND_RECORDING); 859 mStreamingProcessor->updateRecordingRequest(params); 860 if (res != OK) { 861 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)", 862 __FUNCTION__, mCameraId, strerror(-res), res); 863 return res; 864 } 865 } 866 867 res = mStreamingProcessor->updateRecordingStream(params); 868 if (res != OK) { 869 ALOGE("%s: Camera %d: Unable to update recording stream: %s (%d)", 870 __FUNCTION__, mCameraId, strerror(-res), res); 871 return res; 872 } 873 874 Vector<uint8_t> outputStreams; 875 bool callbacksEnabled = params.previewCallbackFlags & 876 CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK; 877 if (callbacksEnabled) { 878 res = mCallbackProcessor->updateStream(params); 879 if (res != OK) { 880 ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)", 881 __FUNCTION__, mCameraId, strerror(-res), res); 882 return res; 883 } 884 outputStreams.push(getCallbackStreamId()); 885 } 886 outputStreams.push(getPreviewStreamId()); 887 outputStreams.push(getRecordingStreamId()); 888 889 res = mStreamingProcessor->startStream(StreamingProcessor::RECORD, 890 outputStreams); 891 if (res != OK) { 892 ALOGE("%s: Camera %d: Unable to start recording stream: %s (%d)", 893 __FUNCTION__, mCameraId, strerror(-res), res); 894 return res; 895 } 896 897 if (params.state < Parameters::RECORD) { 898 params.state = Parameters::RECORD; 899 } 900 901 return OK; 902 } 903 904 void Camera2Client::stopRecording() { 905 ATRACE_CALL(); 906 ALOGV("%s: E", __FUNCTION__); 907 Mutex::Autolock icl(mICameraLock); 908 SharedParameters::Lock l(mParameters); 909 910 status_t res; 911 if ( (res = checkPid(__FUNCTION__) ) != OK) return; 912 913 switch (l.mParameters.state) { 914 case Parameters::RECORD: 915 // OK to stop 916 break; 917 case Parameters::STOPPED: 918 case Parameters::PREVIEW: 919 case Parameters::STILL_CAPTURE: 920 case Parameters::VIDEO_SNAPSHOT: 921 default: 922 ALOGE("%s: Camera %d: Can't stop recording in state %s", 923 __FUNCTION__, mCameraId, 924 Parameters::getStateName(l.mParameters.state)); 925 return; 926 }; 927 928 mCameraService->playSound(CameraService::SOUND_RECORDING); 929 930 res = startPreviewL(l.mParameters, true); 931 if (res != OK) { 932 ALOGE("%s: Camera %d: Unable to return to preview", 933 __FUNCTION__, mCameraId); 934 } 935 } 936 937 bool Camera2Client::recordingEnabled() { 938 ATRACE_CALL(); 939 Mutex::Autolock icl(mICameraLock); 940 941 if ( checkPid(__FUNCTION__) != OK) return false; 942 943 return recordingEnabledL(); 944 } 945 946 bool Camera2Client::recordingEnabledL() { 947 ATRACE_CALL(); 948 SharedParameters::Lock l(mParameters); 949 950 return (l.mParameters.state == Parameters::RECORD 951 || l.mParameters.state == Parameters::VIDEO_SNAPSHOT); 952 } 953 954 void Camera2Client::releaseRecordingFrame(const sp<IMemory>& mem) { 955 ATRACE_CALL(); 956 Mutex::Autolock icl(mICameraLock); 957 if ( checkPid(__FUNCTION__) != OK) return; 958 959 mStreamingProcessor->releaseRecordingFrame(mem); 960 } 961 962 status_t Camera2Client::autoFocus() { 963 ATRACE_CALL(); 964 Mutex::Autolock icl(mICameraLock); 965 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 966 status_t res; 967 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 968 969 int triggerId; 970 bool notifyImmediately = false; 971 bool notifySuccess = false; 972 { 973 SharedParameters::Lock l(mParameters); 974 if (l.mParameters.state < Parameters::PREVIEW) { 975 return INVALID_OPERATION; 976 } 977 978 /** 979 * If the camera does not support auto-focus, it is a no-op and 980 * onAutoFocus(boolean, Camera) callback will be called immediately 981 * with a fake value of success set to true. 982 */ 983 if (l.mParameters.focusMode == Parameters::FOCUS_MODE_FIXED) { 984 notifyImmediately = true; 985 notifySuccess = true; 986 } 987 /** 988 * If we're in CAF mode, and AF has already been locked, just fire back 989 * the callback right away; the HAL would not send a notification since 990 * no state change would happen on a AF trigger. 991 */ 992 if ( (l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_PICTURE || 993 l.mParameters.focusMode == Parameters::FOCUS_MODE_CONTINUOUS_VIDEO) && 994 l.mParameters.focusState == ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED ) { 995 notifyImmediately = true; 996 notifySuccess = true; 997 } 998 /** 999 * Send immediate notification back to client 1000 */ 1001 if (notifyImmediately) { 1002 SharedCameraClient::Lock l(mSharedCameraClient); 1003 if (l.mCameraClient != 0) { 1004 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS, 1005 notifySuccess ? 1 : 0, 0); 1006 } 1007 return OK; 1008 } 1009 /** 1010 * Handle quirk mode for AF in scene modes 1011 */ 1012 if (l.mParameters.quirks.triggerAfWithAuto && 1013 l.mParameters.sceneMode != ANDROID_CONTROL_SCENE_MODE_UNSUPPORTED && 1014 l.mParameters.focusMode != Parameters::FOCUS_MODE_AUTO && 1015 !l.mParameters.focusingAreas[0].isEmpty()) { 1016 ALOGV("%s: Quirk: Switching from focusMode %d to AUTO", 1017 __FUNCTION__, l.mParameters.focusMode); 1018 l.mParameters.shadowFocusMode = l.mParameters.focusMode; 1019 l.mParameters.focusMode = Parameters::FOCUS_MODE_AUTO; 1020 updateRequests(l.mParameters); 1021 } 1022 1023 l.mParameters.currentAfTriggerId = ++l.mParameters.afTriggerCounter; 1024 triggerId = l.mParameters.currentAfTriggerId; 1025 } 1026 syncWithDevice(); 1027 1028 mDevice->triggerAutofocus(triggerId); 1029 1030 return OK; 1031 } 1032 1033 status_t Camera2Client::cancelAutoFocus() { 1034 ATRACE_CALL(); 1035 Mutex::Autolock icl(mICameraLock); 1036 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 1037 status_t res; 1038 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1039 1040 int triggerId; 1041 { 1042 SharedParameters::Lock l(mParameters); 1043 triggerId = ++l.mParameters.afTriggerCounter; 1044 1045 // When using triggerAfWithAuto quirk, may need to reset focus mode to 1046 // the real state at this point. No need to cancel explicitly if 1047 // changing the AF mode. 1048 if (l.mParameters.shadowFocusMode != Parameters::FOCUS_MODE_INVALID) { 1049 ALOGV("%s: Quirk: Restoring focus mode to %d", __FUNCTION__, 1050 l.mParameters.shadowFocusMode); 1051 l.mParameters.focusMode = l.mParameters.shadowFocusMode; 1052 l.mParameters.shadowFocusMode = Parameters::FOCUS_MODE_INVALID; 1053 updateRequests(l.mParameters); 1054 1055 return OK; 1056 } 1057 } 1058 syncWithDevice(); 1059 1060 mDevice->triggerCancelAutofocus(triggerId); 1061 1062 return OK; 1063 } 1064 1065 status_t Camera2Client::takePicture(int msgType) { 1066 ATRACE_CALL(); 1067 Mutex::Autolock icl(mICameraLock); 1068 status_t res; 1069 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1070 1071 { 1072 SharedParameters::Lock l(mParameters); 1073 switch (l.mParameters.state) { 1074 case Parameters::DISCONNECTED: 1075 case Parameters::STOPPED: 1076 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 1077 ALOGE("%s: Camera %d: Cannot take picture without preview enabled", 1078 __FUNCTION__, mCameraId); 1079 return INVALID_OPERATION; 1080 case Parameters::PREVIEW: 1081 // Good to go for takePicture 1082 res = commandStopFaceDetectionL(l.mParameters); 1083 if (res != OK) { 1084 ALOGE("%s: Camera %d: Unable to stop face detection for still capture", 1085 __FUNCTION__, mCameraId); 1086 return res; 1087 } 1088 l.mParameters.state = Parameters::STILL_CAPTURE; 1089 break; 1090 case Parameters::RECORD: 1091 // Good to go for video snapshot 1092 l.mParameters.state = Parameters::VIDEO_SNAPSHOT; 1093 break; 1094 case Parameters::STILL_CAPTURE: 1095 case Parameters::VIDEO_SNAPSHOT: 1096 ALOGE("%s: Camera %d: Already taking a picture", 1097 __FUNCTION__, mCameraId); 1098 return INVALID_OPERATION; 1099 } 1100 1101 ALOGV("%s: Camera %d: Starting picture capture", __FUNCTION__, mCameraId); 1102 1103 res = mJpegProcessor->updateStream(l.mParameters); 1104 if (res != OK) { 1105 ALOGE("%s: Camera %d: Can't set up still image stream: %s (%d)", 1106 __FUNCTION__, mCameraId, strerror(-res), res); 1107 return res; 1108 } 1109 } 1110 1111 // Need HAL to have correct settings before (possibly) triggering precapture 1112 syncWithDevice(); 1113 1114 res = mCaptureSequencer->startCapture(); 1115 if (res != OK) { 1116 ALOGE("%s: Camera %d: Unable to start capture: %s (%d)", 1117 __FUNCTION__, mCameraId, strerror(-res), res); 1118 } 1119 1120 return res; 1121 } 1122 1123 status_t Camera2Client::setParameters(const String8& params) { 1124 ATRACE_CALL(); 1125 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 1126 Mutex::Autolock icl(mICameraLock); 1127 status_t res; 1128 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1129 1130 SharedParameters::Lock l(mParameters); 1131 1132 res = l.mParameters.set(params); 1133 if (res != OK) return res; 1134 1135 res = updateRequests(l.mParameters); 1136 1137 return res; 1138 } 1139 1140 String8 Camera2Client::getParameters() const { 1141 ATRACE_CALL(); 1142 ALOGV("%s: Camera %d", __FUNCTION__, mCameraId); 1143 Mutex::Autolock icl(mICameraLock); 1144 if ( checkPid(__FUNCTION__) != OK) return String8(); 1145 1146 SharedParameters::ReadLock l(mParameters); 1147 1148 return l.mParameters.get(); 1149 } 1150 1151 status_t Camera2Client::sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) { 1152 ATRACE_CALL(); 1153 Mutex::Autolock icl(mICameraLock); 1154 status_t res; 1155 if ( (res = checkPid(__FUNCTION__) ) != OK) return res; 1156 1157 ALOGV("%s: Camera %d: Command %d (%d, %d)", __FUNCTION__, mCameraId, 1158 cmd, arg1, arg2); 1159 1160 switch (cmd) { 1161 case CAMERA_CMD_START_SMOOTH_ZOOM: 1162 return commandStartSmoothZoomL(); 1163 case CAMERA_CMD_STOP_SMOOTH_ZOOM: 1164 return commandStopSmoothZoomL(); 1165 case CAMERA_CMD_SET_DISPLAY_ORIENTATION: 1166 return commandSetDisplayOrientationL(arg1); 1167 case CAMERA_CMD_ENABLE_SHUTTER_SOUND: 1168 return commandEnableShutterSoundL(arg1 == 1); 1169 case CAMERA_CMD_PLAY_RECORDING_SOUND: 1170 return commandPlayRecordingSoundL(); 1171 case CAMERA_CMD_START_FACE_DETECTION: 1172 return commandStartFaceDetectionL(arg1); 1173 case CAMERA_CMD_STOP_FACE_DETECTION: { 1174 SharedParameters::Lock l(mParameters); 1175 return commandStopFaceDetectionL(l.mParameters); 1176 } 1177 case CAMERA_CMD_ENABLE_FOCUS_MOVE_MSG: 1178 return commandEnableFocusMoveMsgL(arg1 == 1); 1179 case CAMERA_CMD_PING: 1180 return commandPingL(); 1181 case CAMERA_CMD_SET_VIDEO_BUFFER_COUNT: 1182 return commandSetVideoBufferCountL(arg1); 1183 default: 1184 ALOGE("%s: Unknown command %d (arguments %d, %d)", 1185 __FUNCTION__, cmd, arg1, arg2); 1186 return BAD_VALUE; 1187 } 1188 } 1189 1190 status_t Camera2Client::commandStartSmoothZoomL() { 1191 ALOGE("%s: Unimplemented!", __FUNCTION__); 1192 return OK; 1193 } 1194 1195 status_t Camera2Client::commandStopSmoothZoomL() { 1196 ALOGE("%s: Unimplemented!", __FUNCTION__); 1197 return OK; 1198 } 1199 1200 status_t Camera2Client::commandSetDisplayOrientationL(int degrees) { 1201 int transform = Parameters::degToTransform(degrees, 1202 mCameraFacing == CAMERA_FACING_FRONT); 1203 if (transform == -1) { 1204 ALOGE("%s: Camera %d: Error setting %d as display orientation value", 1205 __FUNCTION__, mCameraId, degrees); 1206 return BAD_VALUE; 1207 } 1208 SharedParameters::Lock l(mParameters); 1209 if (transform != l.mParameters.previewTransform && 1210 getPreviewStreamId() != NO_STREAM) { 1211 mDevice->setStreamTransform(getPreviewStreamId(), transform); 1212 } 1213 l.mParameters.previewTransform = transform; 1214 return OK; 1215 } 1216 1217 status_t Camera2Client::commandEnableShutterSoundL(bool enable) { 1218 SharedParameters::Lock l(mParameters); 1219 if (enable) { 1220 l.mParameters.playShutterSound = true; 1221 return OK; 1222 } 1223 1224 // Disabling shutter sound may not be allowed. In that case only 1225 // allow the mediaserver process to disable the sound. 1226 char value[PROPERTY_VALUE_MAX]; 1227 property_get("ro.camera.sound.forced", value, "0"); 1228 if (strncmp(value, "0", 2) != 0) { 1229 // Disabling shutter sound is not allowed. Deny if the current 1230 // process is not mediaserver. 1231 if (getCallingPid() != getpid()) { 1232 ALOGE("Failed to disable shutter sound. Permission denied (pid %d)", 1233 getCallingPid()); 1234 return PERMISSION_DENIED; 1235 } 1236 } 1237 1238 l.mParameters.playShutterSound = false; 1239 return OK; 1240 } 1241 1242 status_t Camera2Client::commandPlayRecordingSoundL() { 1243 mCameraService->playSound(CameraService::SOUND_RECORDING); 1244 return OK; 1245 } 1246 1247 status_t Camera2Client::commandStartFaceDetectionL(int type) { 1248 ALOGV("%s: Camera %d: Starting face detection", 1249 __FUNCTION__, mCameraId); 1250 status_t res; 1251 SharedParameters::Lock l(mParameters); 1252 switch (l.mParameters.state) { 1253 case Parameters::DISCONNECTED: 1254 case Parameters::STOPPED: 1255 case Parameters::WAITING_FOR_PREVIEW_WINDOW: 1256 case Parameters::STILL_CAPTURE: 1257 ALOGE("%s: Camera %d: Cannot start face detection without preview active", 1258 __FUNCTION__, mCameraId); 1259 return INVALID_OPERATION; 1260 case Parameters::PREVIEW: 1261 case Parameters::RECORD: 1262 case Parameters::VIDEO_SNAPSHOT: 1263 // Good to go for starting face detect 1264 break; 1265 } 1266 // Ignoring type 1267 if (l.mParameters.fastInfo.bestFaceDetectMode == 1268 ANDROID_STATS_FACE_DETECTION_OFF) { 1269 ALOGE("%s: Camera %d: Face detection not supported", 1270 __FUNCTION__, mCameraId); 1271 return INVALID_OPERATION; 1272 } 1273 if (l.mParameters.enableFaceDetect) return OK; 1274 1275 l.mParameters.enableFaceDetect = true; 1276 1277 res = updateRequests(l.mParameters); 1278 1279 return res; 1280 } 1281 1282 status_t Camera2Client::commandStopFaceDetectionL(Parameters ¶ms) { 1283 status_t res = OK; 1284 ALOGV("%s: Camera %d: Stopping face detection", 1285 __FUNCTION__, mCameraId); 1286 1287 if (!params.enableFaceDetect) return OK; 1288 1289 params.enableFaceDetect = false; 1290 1291 if (params.state == Parameters::PREVIEW 1292 || params.state == Parameters::RECORD 1293 || params.state == Parameters::VIDEO_SNAPSHOT) { 1294 res = updateRequests(params); 1295 } 1296 1297 return res; 1298 } 1299 1300 status_t Camera2Client::commandEnableFocusMoveMsgL(bool enable) { 1301 SharedParameters::Lock l(mParameters); 1302 l.mParameters.enableFocusMoveMessages = enable; 1303 1304 return OK; 1305 } 1306 1307 status_t Camera2Client::commandPingL() { 1308 // Always ping back if access is proper and device is alive 1309 SharedParameters::Lock l(mParameters); 1310 if (l.mParameters.state != Parameters::DISCONNECTED) { 1311 return OK; 1312 } else { 1313 return NO_INIT; 1314 } 1315 } 1316 1317 status_t Camera2Client::commandSetVideoBufferCountL(size_t count) { 1318 if (recordingEnabledL()) { 1319 ALOGE("%s: Camera %d: Error setting video buffer count after " 1320 "recording was started", __FUNCTION__, mCameraId); 1321 return INVALID_OPERATION; 1322 } 1323 1324 return mStreamingProcessor->setRecordingBufferCount(count); 1325 } 1326 1327 /** Device-related methods */ 1328 1329 void Camera2Client::notifyError(int errorCode, int arg1, int arg2) { 1330 ALOGE("Error condition %d reported by HAL, arguments %d, %d", errorCode, arg1, arg2); 1331 } 1332 1333 void Camera2Client::notifyShutter(int frameNumber, nsecs_t timestamp) { 1334 ALOGV("%s: Shutter notification for frame %d at time %lld", __FUNCTION__, 1335 frameNumber, timestamp); 1336 } 1337 1338 void Camera2Client::notifyAutoFocus(uint8_t newState, int triggerId) { 1339 ALOGV("%s: Autofocus state now %d, last trigger %d", 1340 __FUNCTION__, newState, triggerId); 1341 bool sendCompletedMessage = false; 1342 bool sendMovingMessage = false; 1343 1344 bool success = false; 1345 bool afInMotion = false; 1346 { 1347 SharedParameters::Lock l(mParameters); 1348 l.mParameters.focusState = newState; 1349 switch (l.mParameters.focusMode) { 1350 case Parameters::FOCUS_MODE_AUTO: 1351 case Parameters::FOCUS_MODE_MACRO: 1352 // Don't send notifications upstream if they're not for the current AF 1353 // trigger. For example, if cancel was called in between, or if we 1354 // already sent a notification about this AF call. 1355 if (triggerId != l.mParameters.currentAfTriggerId) break; 1356 switch (newState) { 1357 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1358 success = true; 1359 // no break 1360 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1361 sendCompletedMessage = true; 1362 l.mParameters.currentAfTriggerId = -1; 1363 break; 1364 case ANDROID_CONTROL_AF_STATE_ACTIVE_SCAN: 1365 // Just starting focusing, ignore 1366 break; 1367 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1368 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1369 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1370 default: 1371 // Unexpected in AUTO/MACRO mode 1372 ALOGE("%s: Unexpected AF state transition in AUTO/MACRO mode: %d", 1373 __FUNCTION__, newState); 1374 break; 1375 } 1376 break; 1377 case Parameters::FOCUS_MODE_CONTINUOUS_VIDEO: 1378 case Parameters::FOCUS_MODE_CONTINUOUS_PICTURE: 1379 switch (newState) { 1380 case ANDROID_CONTROL_AF_STATE_FOCUSED_LOCKED: 1381 success = true; 1382 // no break 1383 case ANDROID_CONTROL_AF_STATE_NOT_FOCUSED_LOCKED: 1384 // Don't send notifications upstream if they're not for 1385 // the current AF trigger. For example, if cancel was 1386 // called in between, or if we already sent a 1387 // notification about this AF call. 1388 // Send both a 'AF done' callback and a 'AF move' callback 1389 if (triggerId != l.mParameters.currentAfTriggerId) break; 1390 sendCompletedMessage = true; 1391 afInMotion = false; 1392 if (l.mParameters.enableFocusMoveMessages && 1393 l.mParameters.afInMotion) { 1394 sendMovingMessage = true; 1395 } 1396 l.mParameters.currentAfTriggerId = -1; 1397 break; 1398 case ANDROID_CONTROL_AF_STATE_INACTIVE: 1399 // Cancel was called, or we switched state; care if 1400 // currently moving 1401 afInMotion = false; 1402 if (l.mParameters.enableFocusMoveMessages && 1403 l.mParameters.afInMotion) { 1404 sendMovingMessage = true; 1405 } 1406 break; 1407 case ANDROID_CONTROL_AF_STATE_PASSIVE_SCAN: 1408 // Start passive scan, inform upstream 1409 afInMotion = true; 1410 // no break 1411 case ANDROID_CONTROL_AF_STATE_PASSIVE_FOCUSED: 1412 // Stop passive scan, inform upstream 1413 if (l.mParameters.enableFocusMoveMessages) { 1414 sendMovingMessage = true; 1415 } 1416 break; 1417 } 1418 l.mParameters.afInMotion = afInMotion; 1419 break; 1420 case Parameters::FOCUS_MODE_EDOF: 1421 case Parameters::FOCUS_MODE_INFINITY: 1422 case Parameters::FOCUS_MODE_FIXED: 1423 default: 1424 if (newState != ANDROID_CONTROL_AF_STATE_INACTIVE) { 1425 ALOGE("%s: Unexpected AF state change %d " 1426 "(ID %d) in focus mode %d", 1427 __FUNCTION__, newState, triggerId, 1428 l.mParameters.focusMode); 1429 } 1430 } 1431 } 1432 if (sendMovingMessage) { 1433 SharedCameraClient::Lock l(mSharedCameraClient); 1434 if (l.mCameraClient != 0) { 1435 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS_MOVE, 1436 afInMotion ? 1 : 0, 0); 1437 } 1438 } 1439 if (sendCompletedMessage) { 1440 SharedCameraClient::Lock l(mSharedCameraClient); 1441 if (l.mCameraClient != 0) { 1442 l.mCameraClient->notifyCallback(CAMERA_MSG_FOCUS, 1443 success ? 1 : 0, 0); 1444 } 1445 } 1446 } 1447 1448 void Camera2Client::notifyAutoExposure(uint8_t newState, int triggerId) { 1449 ALOGV("%s: Autoexposure state now %d, last trigger %d", 1450 __FUNCTION__, newState, triggerId); 1451 mCaptureSequencer->notifyAutoExposure(newState, triggerId); 1452 } 1453 1454 void Camera2Client::notifyAutoWhitebalance(uint8_t newState, int triggerId) { 1455 ALOGV("%s: Auto-whitebalance state now %d, last trigger %d", 1456 __FUNCTION__, newState, triggerId); 1457 } 1458 1459 int Camera2Client::getCameraId() const { 1460 return mCameraId; 1461 } 1462 1463 const sp<Camera2Device>& Camera2Client::getCameraDevice() { 1464 return mDevice; 1465 } 1466 1467 const sp<CameraService>& Camera2Client::getCameraService() { 1468 return mCameraService; 1469 } 1470 1471 camera2::SharedParameters& Camera2Client::getParameters() { 1472 return mParameters; 1473 } 1474 1475 int Camera2Client::getPreviewStreamId() const { 1476 return mStreamingProcessor->getPreviewStreamId(); 1477 } 1478 1479 int Camera2Client::getCaptureStreamId() const { 1480 return mJpegProcessor->getStreamId(); 1481 } 1482 1483 int Camera2Client::getCallbackStreamId() const { 1484 return mCallbackProcessor->getStreamId(); 1485 } 1486 1487 int Camera2Client::getRecordingStreamId() const { 1488 return mStreamingProcessor->getRecordingStreamId(); 1489 } 1490 1491 int Camera2Client::getZslStreamId() const { 1492 return mZslProcessor->getStreamId(); 1493 } 1494 1495 status_t Camera2Client::registerFrameListener(int32_t minId, int32_t maxId, 1496 wp<camera2::FrameProcessor::FilteredListener> listener) { 1497 return mFrameProcessor->registerListener(minId, maxId, listener); 1498 } 1499 1500 status_t Camera2Client::removeFrameListener(int32_t minId, int32_t maxId, 1501 wp<camera2::FrameProcessor::FilteredListener> listener) { 1502 return mFrameProcessor->removeListener(minId, maxId, listener); 1503 } 1504 1505 status_t Camera2Client::stopStream() { 1506 return mStreamingProcessor->stopStream(); 1507 } 1508 1509 Camera2Client::SharedCameraClient::Lock::Lock(SharedCameraClient &client): 1510 mCameraClient(client.mCameraClient), 1511 mSharedClient(client) { 1512 mSharedClient.mCameraClientLock.lock(); 1513 } 1514 1515 Camera2Client::SharedCameraClient::Lock::~Lock() { 1516 mSharedClient.mCameraClientLock.unlock(); 1517 } 1518 1519 Camera2Client::SharedCameraClient::SharedCameraClient(const sp<ICameraClient>&client): 1520 mCameraClient(client) { 1521 } 1522 1523 Camera2Client::SharedCameraClient& Camera2Client::SharedCameraClient::operator=( 1524 const sp<ICameraClient>&client) { 1525 Mutex::Autolock l(mCameraClientLock); 1526 mCameraClient = client; 1527 return *this; 1528 } 1529 1530 void Camera2Client::SharedCameraClient::clear() { 1531 Mutex::Autolock l(mCameraClientLock); 1532 mCameraClient.clear(); 1533 } 1534 1535 const int32_t Camera2Client::kPreviewRequestIdStart; 1536 const int32_t Camera2Client::kPreviewRequestIdEnd; 1537 const int32_t Camera2Client::kRecordingRequestIdStart; 1538 const int32_t Camera2Client::kRecordingRequestIdEnd; 1539 const int32_t Camera2Client::kCaptureRequestIdStart; 1540 const int32_t Camera2Client::kCaptureRequestIdEnd; 1541 1542 /** Utility methods */ 1543 1544 status_t Camera2Client::updateRequests(Parameters ¶ms) { 1545 status_t res; 1546 1547 ALOGV("%s: Camera %d: state = %d", __FUNCTION__, getCameraId(), params.state); 1548 1549 res = mStreamingProcessor->incrementStreamingIds(); 1550 if (res != OK) { 1551 ALOGE("%s: Camera %d: Unable to increment request IDs: %s (%d)", 1552 __FUNCTION__, mCameraId, strerror(-res), res); 1553 return res; 1554 } 1555 1556 res = mStreamingProcessor->updatePreviewRequest(params); 1557 if (res != OK) { 1558 ALOGE("%s: Camera %d: Unable to update preview request: %s (%d)", 1559 __FUNCTION__, mCameraId, strerror(-res), res); 1560 return res; 1561 } 1562 res = mStreamingProcessor->updateRecordingRequest(params); 1563 if (res != OK) { 1564 ALOGE("%s: Camera %d: Unable to update recording request: %s (%d)", 1565 __FUNCTION__, mCameraId, strerror(-res), res); 1566 return res; 1567 } 1568 1569 if (params.state == Parameters::PREVIEW) { 1570 res = startPreviewL(params, true); 1571 if (res != OK) { 1572 ALOGE("%s: Camera %d: Error streaming new preview request: %s (%d)", 1573 __FUNCTION__, mCameraId, strerror(-res), res); 1574 return res; 1575 } 1576 } else if (params.state == Parameters::RECORD || 1577 params.state == Parameters::VIDEO_SNAPSHOT) { 1578 res = startRecordingL(params, true); 1579 if (res != OK) { 1580 ALOGE("%s: Camera %d: Error streaming new record request: %s (%d)", 1581 __FUNCTION__, mCameraId, strerror(-res), res); 1582 return res; 1583 } 1584 } 1585 return res; 1586 } 1587 1588 1589 size_t Camera2Client::calculateBufferSize(int width, int height, 1590 int format, int stride) { 1591 switch (format) { 1592 case HAL_PIXEL_FORMAT_YCbCr_422_SP: // NV16 1593 return width * height * 2; 1594 case HAL_PIXEL_FORMAT_YCrCb_420_SP: // NV21 1595 return width * height * 3 / 2; 1596 case HAL_PIXEL_FORMAT_YCbCr_422_I: // YUY2 1597 return width * height * 2; 1598 case HAL_PIXEL_FORMAT_YV12: { // YV12 1599 size_t ySize = stride * height; 1600 size_t uvStride = (stride / 2 + 0xF) & ~0xF; 1601 size_t uvSize = uvStride * height / 2; 1602 return ySize + uvSize * 2; 1603 } 1604 case HAL_PIXEL_FORMAT_RGB_565: 1605 return width * height * 2; 1606 case HAL_PIXEL_FORMAT_RGBA_8888: 1607 return width * height * 4; 1608 case HAL_PIXEL_FORMAT_RAW_SENSOR: 1609 return width * height * 2; 1610 default: 1611 ALOGE("%s: Unknown preview format: %x", 1612 __FUNCTION__, format); 1613 return 0; 1614 } 1615 } 1616 1617 status_t Camera2Client::syncWithDevice() { 1618 ATRACE_CALL(); 1619 const nsecs_t kMaxSyncTimeout = 500000000; // 500 ms 1620 status_t res; 1621 1622 int32_t activeRequestId = mStreamingProcessor->getActiveRequestId(); 1623 if (activeRequestId == 0) return OK; 1624 1625 res = mDevice->waitUntilRequestReceived(activeRequestId, kMaxSyncTimeout); 1626 if (res == TIMED_OUT) { 1627 ALOGE("%s: Camera %d: Timed out waiting sync with HAL", 1628 __FUNCTION__, mCameraId); 1629 } else if (res != OK) { 1630 ALOGE("%s: Camera %d: Error while waiting to sync with HAL", 1631 __FUNCTION__, mCameraId); 1632 } 1633 return res; 1634 } 1635 1636 } // namespace android 1637
