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