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