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