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