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