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