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