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