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