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