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