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