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