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