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