1 /* 2 * Copyright (C) 2015 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_NDEBUG 0 18 #define LOG_TAG "ACameraDevice" 19 20 #include <vector> 21 #include <inttypes.h> 22 #include <android/hardware/ICameraService.h> 23 #include <camera2/SubmitInfo.h> 24 #include <gui/Surface.h> 25 #include "ACameraDevice.h" 26 #include "ACameraMetadata.h" 27 #include "ACaptureRequest.h" 28 #include "ACameraCaptureSession.h" 29 30 using namespace android; 31 32 namespace android { 33 // Static member definitions 34 const char* CameraDevice::kContextKey = "Context"; 35 const char* CameraDevice::kDeviceKey = "Device"; 36 const char* CameraDevice::kErrorCodeKey = "ErrorCode"; 37 const char* CameraDevice::kCallbackFpKey = "Callback"; 38 const char* CameraDevice::kSessionSpKey = "SessionSp"; 39 const char* CameraDevice::kCaptureRequestKey = "CaptureRequest"; 40 const char* CameraDevice::kTimeStampKey = "TimeStamp"; 41 const char* CameraDevice::kCaptureResultKey = "CaptureResult"; 42 const char* CameraDevice::kCaptureFailureKey = "CaptureFailure"; 43 const char* CameraDevice::kSequenceIdKey = "SequenceId"; 44 const char* CameraDevice::kFrameNumberKey = "FrameNumber"; 45 const char* CameraDevice::kAnwKey = "Anw"; 46 47 /** 48 * CameraDevice Implementation 49 */ 50 CameraDevice::CameraDevice( 51 const char* id, 52 ACameraDevice_StateCallbacks* cb, 53 std::unique_ptr<ACameraMetadata> chars, 54 ACameraDevice* wrapper) : 55 mCameraId(id), 56 mAppCallbacks(*cb), 57 mChars(std::move(chars)), 58 mServiceCallback(new ServiceCallback(this)), 59 mWrapper(wrapper), 60 mInError(false), 61 mError(ACAMERA_OK), 62 mIdle(true), 63 mCurrentSession(nullptr) { 64 mClosing = false; 65 // Setup looper thread to perfrom device callbacks to app 66 mCbLooper = new ALooper; 67 mCbLooper->setName("C2N-dev-looper"); 68 status_t err = mCbLooper->start( 69 /*runOnCallingThread*/false, 70 /*canCallJava*/ true, 71 PRIORITY_DEFAULT); 72 if (err != OK) { 73 ALOGE("%s: Unable to start camera device callback looper: %s (%d)", 74 __FUNCTION__, strerror(-err), err); 75 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 76 } 77 mHandler = new CallbackHandler(); 78 mCbLooper->registerHandler(mHandler); 79 80 const CameraMetadata& metadata = mChars->getInternalData(); 81 camera_metadata_ro_entry entry = metadata.find(ANDROID_REQUEST_PARTIAL_RESULT_COUNT); 82 if (entry.count != 1) { 83 ALOGW("%s: bad count %zu for partial result count", __FUNCTION__, entry.count); 84 mPartialResultCount = 1; 85 } else { 86 mPartialResultCount = entry.data.i32[0]; 87 } 88 89 entry = metadata.find(ANDROID_LENS_INFO_SHADING_MAP_SIZE); 90 if (entry.count != 2) { 91 ALOGW("%s: bad count %zu for shading map size", __FUNCTION__, entry.count); 92 mShadingMapSize[0] = 0; 93 mShadingMapSize[1] = 0; 94 } else { 95 mShadingMapSize[0] = entry.data.i32[0]; 96 mShadingMapSize[1] = entry.data.i32[1]; 97 } 98 } 99 100 // Device close implementaiton 101 CameraDevice::~CameraDevice() { 102 sp<ACameraCaptureSession> session = mCurrentSession.promote(); 103 { 104 Mutex::Autolock _l(mDeviceLock); 105 if (!isClosed()) { 106 disconnectLocked(session); 107 } 108 mCurrentSession = nullptr; 109 if (mCbLooper != nullptr) { 110 mCbLooper->unregisterHandler(mHandler->id()); 111 mCbLooper->stop(); 112 } 113 } 114 mCbLooper.clear(); 115 mHandler.clear(); 116 } 117 118 void 119 CameraDevice::postSessionMsgAndCleanup(sp<AMessage>& msg) { 120 msg->post(); 121 msg.clear(); 122 sp<AMessage> cleanupMsg = new AMessage(kWhatCleanUpSessions, mHandler); 123 cleanupMsg->post(); 124 } 125 126 // TODO: cached created request? 127 camera_status_t 128 CameraDevice::createCaptureRequest( 129 ACameraDevice_request_template templateId, 130 ACaptureRequest** request) const { 131 Mutex::Autolock _l(mDeviceLock); 132 camera_status_t ret = checkCameraClosedOrErrorLocked(); 133 if (ret != ACAMERA_OK) { 134 return ret; 135 } 136 if (mRemote == nullptr) { 137 return ACAMERA_ERROR_CAMERA_DISCONNECTED; 138 } 139 CameraMetadata rawRequest; 140 binder::Status remoteRet = mRemote->createDefaultRequest(templateId, &rawRequest); 141 if (remoteRet.serviceSpecificErrorCode() == 142 hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) { 143 ALOGW("Create capture request failed! template %d is not supported on this device", 144 templateId); 145 return ACAMERA_ERROR_INVALID_PARAMETER; 146 } else if (!remoteRet.isOk()) { 147 ALOGE("Create capture request failed: %s", remoteRet.toString8().string()); 148 return ACAMERA_ERROR_UNKNOWN; 149 } 150 ACaptureRequest* outReq = new ACaptureRequest(); 151 outReq->settings = new ACameraMetadata(rawRequest.release(), ACameraMetadata::ACM_REQUEST); 152 outReq->targets = new ACameraOutputTargets(); 153 *request = outReq; 154 return ACAMERA_OK; 155 } 156 157 camera_status_t 158 CameraDevice::createCaptureSession( 159 const ACaptureSessionOutputContainer* outputs, 160 const ACaptureRequest* sessionParameters, 161 const ACameraCaptureSession_stateCallbacks* callbacks, 162 /*out*/ACameraCaptureSession** session) { 163 sp<ACameraCaptureSession> currentSession = mCurrentSession.promote(); 164 Mutex::Autolock _l(mDeviceLock); 165 camera_status_t ret = checkCameraClosedOrErrorLocked(); 166 if (ret != ACAMERA_OK) { 167 return ret; 168 } 169 170 if (currentSession != nullptr) { 171 currentSession->closeByDevice(); 172 stopRepeatingLocked(); 173 } 174 175 // Create new session 176 ret = configureStreamsLocked(outputs, sessionParameters); 177 if (ret != ACAMERA_OK) { 178 ALOGE("Fail to create new session. cannot configure streams"); 179 return ret; 180 } 181 182 ACameraCaptureSession* newSession = new ACameraCaptureSession( 183 mNextSessionId++, outputs, callbacks, this); 184 185 // set new session as current session 186 newSession->incStrong((void *) ACameraDevice_createCaptureSession); 187 mCurrentSession = newSession; 188 mFlushing = false; 189 *session = newSession; 190 return ACAMERA_OK; 191 } 192 193 camera_status_t 194 CameraDevice::captureLocked( 195 sp<ACameraCaptureSession> session, 196 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 197 int numRequests, ACaptureRequest** requests, 198 /*optional*/int* captureSequenceId) { 199 return submitRequestsLocked( 200 session, cbs, numRequests, requests, captureSequenceId, /*isRepeating*/false); 201 } 202 203 camera_status_t 204 CameraDevice::setRepeatingRequestsLocked( 205 sp<ACameraCaptureSession> session, 206 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 207 int numRequests, ACaptureRequest** requests, 208 /*optional*/int* captureSequenceId) { 209 return submitRequestsLocked( 210 session, cbs, numRequests, requests, captureSequenceId, /*isRepeating*/true); 211 } 212 213 camera_status_t 214 CameraDevice::submitRequestsLocked( 215 sp<ACameraCaptureSession> session, 216 /*optional*/ACameraCaptureSession_captureCallbacks* cbs, 217 int numRequests, ACaptureRequest** requests, 218 /*optional*/int* captureSequenceId, 219 bool isRepeating) { 220 camera_status_t ret = checkCameraClosedOrErrorLocked(); 221 if (ret != ACAMERA_OK) { 222 ALOGE("Camera %s submit capture request failed! ret %d", getId(), ret); 223 return ret; 224 } 225 226 // Form two vectors of capture request, one for internal tracking 227 std::vector<hardware::camera2::CaptureRequest> requestList; 228 Vector<sp<CaptureRequest> > requestsV; 229 requestsV.setCapacity(numRequests); 230 for (int i = 0; i < numRequests; i++) { 231 sp<CaptureRequest> req; 232 ret = allocateCaptureRequest(requests[i], req); 233 if (ret != ACAMERA_OK) { 234 ALOGE("Convert capture request to internal format failure! ret %d", ret); 235 return ret; 236 } 237 if (req->mSurfaceList.empty()) { 238 ALOGE("Capture request without output target cannot be submitted!"); 239 return ACAMERA_ERROR_INVALID_PARAMETER; 240 } 241 requestList.push_back(*(req.get())); 242 requestsV.push_back(req); 243 } 244 245 if (isRepeating) { 246 ret = stopRepeatingLocked(); 247 if (ret != ACAMERA_OK) { 248 ALOGE("Camera %s stop repeating failed! ret %d", getId(), ret); 249 return ret; 250 } 251 } 252 253 binder::Status remoteRet; 254 hardware::camera2::utils::SubmitInfo info; 255 remoteRet = mRemote->submitRequestList(requestList, isRepeating, &info); 256 int sequenceId = info.mRequestId; 257 int64_t lastFrameNumber = info.mLastFrameNumber; 258 if (sequenceId < 0) { 259 ALOGE("Camera %s submit request remote failure: ret %d", getId(), sequenceId); 260 return ACAMERA_ERROR_UNKNOWN; 261 } 262 263 CallbackHolder cbHolder(session, requestsV, isRepeating, cbs); 264 mSequenceCallbackMap.insert(std::make_pair(sequenceId, cbHolder)); 265 266 if (isRepeating) { 267 // stopRepeating above should have cleanup repeating sequence id 268 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 269 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 270 return ACAMERA_ERROR_CAMERA_DEVICE; 271 } 272 mRepeatingSequenceId = sequenceId; 273 } else { 274 mSequenceLastFrameNumberMap.insert(std::make_pair(sequenceId, lastFrameNumber)); 275 } 276 277 if (mIdle) { 278 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 279 msg->setPointer(kContextKey, session->mUserSessionCallback.context); 280 msg->setObject(kSessionSpKey, session); 281 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onActive); 282 postSessionMsgAndCleanup(msg); 283 } 284 mIdle = false; 285 mBusySession = session; 286 287 if (captureSequenceId) { 288 *captureSequenceId = sequenceId; 289 } 290 return ACAMERA_OK; 291 } 292 293 camera_status_t CameraDevice::updateOutputConfigurationLocked(ACaptureSessionOutput *output) { 294 camera_status_t ret = checkCameraClosedOrErrorLocked(); 295 if (ret != ACAMERA_OK) { 296 return ret; 297 } 298 299 if (output == nullptr) { 300 return ACAMERA_ERROR_INVALID_PARAMETER; 301 } 302 303 if (!output->mIsShared) { 304 ALOGE("Error output configuration is not shared"); 305 return ACAMERA_ERROR_INVALID_OPERATION; 306 } 307 308 int32_t streamId = -1; 309 for (auto& kvPair : mConfiguredOutputs) { 310 if (kvPair.second.first == output->mWindow) { 311 streamId = kvPair.first; 312 break; 313 } 314 } 315 if (streamId < 0) { 316 ALOGE("Error: Invalid output configuration"); 317 return ACAMERA_ERROR_INVALID_PARAMETER; 318 } 319 320 sp<IGraphicBufferProducer> iGBP(nullptr); 321 ret = getIGBPfromAnw(output->mWindow, iGBP); 322 if (ret != ACAMERA_OK) { 323 ALOGE("Camera device %s failed to extract graphic producer from native window", 324 getId()); 325 return ret; 326 } 327 328 OutputConfiguration outConfig(iGBP, output->mRotation, OutputConfiguration::INVALID_SET_ID, 329 true); 330 331 for (auto& anw : output->mSharedWindows) { 332 ret = getIGBPfromAnw(anw, iGBP); 333 if (ret != ACAMERA_OK) { 334 ALOGE("Camera device %s failed to extract graphic producer from native window", 335 getId()); 336 return ret; 337 } 338 outConfig.addGraphicProducer(iGBP); 339 } 340 341 auto remoteRet = mRemote->updateOutputConfiguration(streamId, outConfig); 342 if (!remoteRet.isOk()) { 343 switch (remoteRet.serviceSpecificErrorCode()) { 344 case hardware::ICameraService::ERROR_INVALID_OPERATION: 345 ALOGE("Camera device %s invalid operation: %s", getId(), 346 remoteRet.toString8().string()); 347 return ACAMERA_ERROR_INVALID_OPERATION; 348 break; 349 case hardware::ICameraService::ERROR_ALREADY_EXISTS: 350 ALOGE("Camera device %s output surface already exists: %s", getId(), 351 remoteRet.toString8().string()); 352 return ACAMERA_ERROR_INVALID_PARAMETER; 353 break; 354 case hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT: 355 ALOGE("Camera device %s invalid input argument: %s", getId(), 356 remoteRet.toString8().string()); 357 return ACAMERA_ERROR_INVALID_PARAMETER; 358 break; 359 default: 360 ALOGE("Camera device %s failed to add shared output: %s", getId(), 361 remoteRet.toString8().string()); 362 return ACAMERA_ERROR_UNKNOWN; 363 } 364 } 365 mConfiguredOutputs[streamId] = std::make_pair(output->mWindow, outConfig); 366 367 return ACAMERA_OK; 368 } 369 370 camera_status_t 371 CameraDevice::allocateCaptureRequest( 372 const ACaptureRequest* request, /*out*/sp<CaptureRequest>& outReq) { 373 camera_status_t ret; 374 sp<CaptureRequest> req(new CaptureRequest()); 375 req->mPhysicalCameraSettings.push_back({std::string(mCameraId.string()), 376 request->settings->getInternalData()}); 377 req->mIsReprocess = false; // NDK does not support reprocessing yet 378 req->mContext = request->context; 379 req->mSurfaceConverted = true; // set to true, and fill in stream/surface idx to speed up IPC 380 381 for (auto outputTarget : request->targets->mOutputs) { 382 ANativeWindow* anw = outputTarget.mWindow; 383 sp<Surface> surface; 384 ret = getSurfaceFromANativeWindow(anw, surface); 385 if (ret != ACAMERA_OK) { 386 ALOGE("Bad output target in capture request! ret %d", ret); 387 return ret; 388 } 389 req->mSurfaceList.push_back(surface); 390 391 bool found = false; 392 // lookup stream/surface ID 393 for (const auto& kvPair : mConfiguredOutputs) { 394 int streamId = kvPair.first; 395 const OutputConfiguration& outConfig = kvPair.second.second; 396 const auto& gbps = outConfig.getGraphicBufferProducers(); 397 for (int surfaceId = 0; surfaceId < (int) gbps.size(); surfaceId++) { 398 if (gbps[surfaceId] == surface->getIGraphicBufferProducer()) { 399 found = true; 400 req->mStreamIdxList.push_back(streamId); 401 req->mSurfaceIdxList.push_back(surfaceId); 402 break; 403 } 404 } 405 if (found) { 406 break; 407 } 408 } 409 if (!found) { 410 ALOGE("Unconfigured output target %p in capture request!", anw); 411 return ret; 412 } 413 } 414 415 outReq = req; 416 return ACAMERA_OK; 417 } 418 419 ACaptureRequest* 420 CameraDevice::allocateACaptureRequest(sp<CaptureRequest>& req) { 421 ACaptureRequest* pRequest = new ACaptureRequest(); 422 CameraMetadata clone = req->mPhysicalCameraSettings.begin()->settings; 423 pRequest->settings = new ACameraMetadata(clone.release(), ACameraMetadata::ACM_REQUEST); 424 pRequest->targets = new ACameraOutputTargets(); 425 for (size_t i = 0; i < req->mSurfaceList.size(); i++) { 426 ANativeWindow* anw = static_cast<ANativeWindow*>(req->mSurfaceList[i].get()); 427 ACameraOutputTarget outputTarget(anw); 428 pRequest->targets->mOutputs.insert(outputTarget); 429 } 430 pRequest->context = req->mContext; 431 return pRequest; 432 } 433 434 void 435 CameraDevice::freeACaptureRequest(ACaptureRequest* req) { 436 if (req == nullptr) { 437 return; 438 } 439 delete req->settings; 440 delete req->targets; 441 delete req; 442 } 443 444 void 445 CameraDevice::notifySessionEndOfLifeLocked(ACameraCaptureSession* session) { 446 if (isClosed()) { 447 // Device is closing already. do nothing 448 return; 449 } 450 451 if (mCurrentSession != session) { 452 // Session has been replaced by other seesion or device is closed 453 return; 454 } 455 mCurrentSession = nullptr; 456 457 // Should not happen 458 if (!session->mIsClosed) { 459 ALOGE("Error: unclosed session %p reaches end of life!", session); 460 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 461 return; 462 } 463 464 // No new session, unconfigure now 465 camera_status_t ret = configureStreamsLocked(nullptr, nullptr); 466 if (ret != ACAMERA_OK) { 467 ALOGE("Unconfigure stream failed. Device might still be configured! ret %d", ret); 468 } 469 } 470 471 void 472 CameraDevice::disconnectLocked(sp<ACameraCaptureSession>& session) { 473 if (mClosing.exchange(true)) { 474 // Already closing, just return 475 ALOGW("Camera device %s is already closing.", getId()); 476 return; 477 } 478 479 if (mRemote != nullptr) { 480 mRemote->disconnect(); 481 } 482 mRemote = nullptr; 483 484 if (session != nullptr) { 485 session->closeByDevice(); 486 } 487 } 488 489 camera_status_t 490 CameraDevice::stopRepeatingLocked() { 491 camera_status_t ret = checkCameraClosedOrErrorLocked(); 492 if (ret != ACAMERA_OK) { 493 ALOGE("Camera %s stop repeating failed! ret %d", getId(), ret); 494 return ret; 495 } 496 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 497 int repeatingSequenceId = mRepeatingSequenceId; 498 mRepeatingSequenceId = REQUEST_ID_NONE; 499 500 int64_t lastFrameNumber; 501 binder::Status remoteRet = mRemote->cancelRequest(repeatingSequenceId, &lastFrameNumber); 502 if (remoteRet.serviceSpecificErrorCode() == 503 hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) { 504 ALOGV("Repeating request is already stopped."); 505 return ACAMERA_OK; 506 } else if (!remoteRet.isOk()) { 507 ALOGE("Stop repeating request fails in remote: %s", remoteRet.toString8().string()); 508 return ACAMERA_ERROR_UNKNOWN; 509 } 510 checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber); 511 } 512 return ACAMERA_OK; 513 } 514 515 camera_status_t 516 CameraDevice::flushLocked(ACameraCaptureSession* session) { 517 camera_status_t ret = checkCameraClosedOrErrorLocked(); 518 if (ret != ACAMERA_OK) { 519 ALOGE("Camera %s abort captures failed! ret %d", getId(), ret); 520 return ret; 521 } 522 523 // This should never happen because creating a new session will close 524 // previous one and thus reject any API call from previous session. 525 // But still good to check here in case something unexpected happen. 526 if (mCurrentSession != session) { 527 ALOGE("Camera %s session %p is not current active session!", getId(), session); 528 return ACAMERA_ERROR_INVALID_OPERATION; 529 } 530 531 if (mFlushing) { 532 ALOGW("Camera %s is already aborting captures", getId()); 533 return ACAMERA_OK; 534 } 535 536 mFlushing = true; 537 538 // Send onActive callback to guarantee there is always active->ready transition 539 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 540 msg->setPointer(kContextKey, session->mUserSessionCallback.context); 541 msg->setObject(kSessionSpKey, session); 542 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onActive); 543 postSessionMsgAndCleanup(msg); 544 545 // If device is already idling, send callback and exit early 546 if (mIdle) { 547 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 548 msg->setPointer(kContextKey, session->mUserSessionCallback.context); 549 msg->setObject(kSessionSpKey, session); 550 msg->setPointer(kCallbackFpKey, (void*) session->mUserSessionCallback.onReady); 551 postSessionMsgAndCleanup(msg); 552 mFlushing = false; 553 return ACAMERA_OK; 554 } 555 556 int64_t lastFrameNumber; 557 binder::Status remoteRet = mRemote->flush(&lastFrameNumber); 558 if (!remoteRet.isOk()) { 559 ALOGE("Abort captures fails in remote: %s", remoteRet.toString8().string()); 560 return ACAMERA_ERROR_UNKNOWN; 561 } 562 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 563 checkRepeatingSequenceCompleteLocked(mRepeatingSequenceId, lastFrameNumber); 564 } 565 return ACAMERA_OK; 566 } 567 568 camera_status_t 569 CameraDevice::waitUntilIdleLocked() { 570 camera_status_t ret = checkCameraClosedOrErrorLocked(); 571 if (ret != ACAMERA_OK) { 572 ALOGE("Wait until camera %s idle failed! ret %d", getId(), ret); 573 return ret; 574 } 575 576 if (mRepeatingSequenceId != REQUEST_ID_NONE) { 577 ALOGE("Camera device %s won't go to idle when there is repeating request!", getId()); 578 return ACAMERA_ERROR_INVALID_OPERATION; 579 } 580 581 binder::Status remoteRet = mRemote->waitUntilIdle(); 582 if (!remoteRet.isOk()) { 583 ALOGE("Camera device %s waitUntilIdle failed: %s", getId(), remoteRet.toString8().string()); 584 // TODO: define a function to convert status_t -> camera_status_t 585 return ACAMERA_ERROR_UNKNOWN; 586 } 587 588 return ACAMERA_OK; 589 } 590 591 camera_status_t 592 CameraDevice::getIGBPfromAnw( 593 ANativeWindow* anw, 594 sp<IGraphicBufferProducer>& out) { 595 sp<Surface> surface; 596 camera_status_t ret = getSurfaceFromANativeWindow(anw, surface); 597 if (ret != ACAMERA_OK) { 598 return ret; 599 } 600 out = surface->getIGraphicBufferProducer(); 601 return ACAMERA_OK; 602 } 603 604 camera_status_t 605 CameraDevice::getSurfaceFromANativeWindow( 606 ANativeWindow* anw, sp<Surface>& out) { 607 if (anw == nullptr) { 608 ALOGE("Error: output ANativeWindow is null"); 609 return ACAMERA_ERROR_INVALID_PARAMETER; 610 } 611 int value; 612 int err = (*anw->query)(anw, NATIVE_WINDOW_CONCRETE_TYPE, &value); 613 if (err != OK || value != NATIVE_WINDOW_SURFACE) { 614 ALOGE("Error: ANativeWindow is not backed by Surface!"); 615 return ACAMERA_ERROR_INVALID_PARAMETER; 616 } 617 sp<Surface> surface(static_cast<Surface*>(anw)); 618 out = surface; 619 return ACAMERA_OK; 620 } 621 622 camera_status_t 623 CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outputs, 624 const ACaptureRequest* sessionParameters) { 625 ACaptureSessionOutputContainer emptyOutput; 626 if (outputs == nullptr) { 627 outputs = &emptyOutput; 628 } 629 630 camera_status_t ret = checkCameraClosedOrErrorLocked(); 631 if (ret != ACAMERA_OK) { 632 return ret; 633 } 634 635 std::set<std::pair<ANativeWindow*, OutputConfiguration>> outputSet; 636 for (auto outConfig : outputs->mOutputs) { 637 ANativeWindow* anw = outConfig.mWindow; 638 sp<IGraphicBufferProducer> iGBP(nullptr); 639 ret = getIGBPfromAnw(anw, iGBP); 640 if (ret != ACAMERA_OK) { 641 return ret; 642 } 643 outputSet.insert(std::make_pair( 644 anw, OutputConfiguration(iGBP, outConfig.mRotation, 645 OutputConfiguration::INVALID_SET_ID, outConfig.mIsShared))); 646 } 647 auto addSet = outputSet; 648 std::vector<int> deleteList; 649 650 // Determine which streams need to be created, which to be deleted 651 for (auto& kvPair : mConfiguredOutputs) { 652 int streamId = kvPair.first; 653 auto& outputPair = kvPair.second; 654 if (outputSet.count(outputPair) == 0) { 655 deleteList.push_back(streamId); // Need to delete a no longer needed stream 656 } else { 657 addSet.erase(outputPair); // No need to add already existing stream 658 } 659 } 660 661 ret = stopRepeatingLocked(); 662 if (ret != ACAMERA_OK) { 663 ALOGE("Camera device %s stop repeating failed, ret %d", getId(), ret); 664 return ret; 665 } 666 667 ret = waitUntilIdleLocked(); 668 if (ret != ACAMERA_OK) { 669 ALOGE("Camera device %s wait until idle failed, ret %d", getId(), ret); 670 return ret; 671 } 672 673 // Send onReady to previous session 674 // CurrentSession will be updated after configureStreamLocked, so here 675 // mCurrentSession is the session to be replaced by a new session 676 if (!mIdle && mCurrentSession != nullptr) { 677 if (mBusySession != mCurrentSession) { 678 ALOGE("Current session != busy session"); 679 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 680 return ACAMERA_ERROR_CAMERA_DEVICE; 681 } 682 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, mHandler); 683 msg->setPointer(kContextKey, mBusySession->mUserSessionCallback.context); 684 msg->setObject(kSessionSpKey, mBusySession); 685 msg->setPointer(kCallbackFpKey, (void*) mBusySession->mUserSessionCallback.onReady); 686 mBusySession.clear(); 687 postSessionMsgAndCleanup(msg); 688 } 689 mIdle = true; 690 691 binder::Status remoteRet = mRemote->beginConfigure(); 692 if (!remoteRet.isOk()) { 693 ALOGE("Camera device %s begin configure failed: %s", getId(), remoteRet.toString8().string()); 694 return ACAMERA_ERROR_UNKNOWN; 695 } 696 697 // delete to-be-deleted streams 698 for (auto streamId : deleteList) { 699 remoteRet = mRemote->deleteStream(streamId); 700 if (!remoteRet.isOk()) { 701 ALOGE("Camera device %s failed to remove stream %d: %s", getId(), streamId, 702 remoteRet.toString8().string()); 703 return ACAMERA_ERROR_UNKNOWN; 704 } 705 mConfiguredOutputs.erase(streamId); 706 } 707 708 // add new streams 709 for (auto outputPair : addSet) { 710 int streamId; 711 remoteRet = mRemote->createStream(outputPair.second, &streamId); 712 if (!remoteRet.isOk()) { 713 ALOGE("Camera device %s failed to create stream: %s", getId(), 714 remoteRet.toString8().string()); 715 return ACAMERA_ERROR_UNKNOWN; 716 } 717 mConfiguredOutputs.insert(std::make_pair(streamId, outputPair)); 718 } 719 720 CameraMetadata params; 721 if ((sessionParameters != nullptr) && (sessionParameters->settings != nullptr)) { 722 params.append(sessionParameters->settings->getInternalData()); 723 } 724 remoteRet = mRemote->endConfigure(/*isConstrainedHighSpeed*/ false, params); 725 if (remoteRet.serviceSpecificErrorCode() == hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT) { 726 ALOGE("Camera device %s cannnot support app output configuration: %s", getId(), 727 remoteRet.toString8().string()); 728 return ACAMERA_ERROR_STREAM_CONFIGURE_FAIL; 729 } else if (!remoteRet.isOk()) { 730 ALOGE("Camera device %s end configure failed: %s", getId(), remoteRet.toString8().string()); 731 return ACAMERA_ERROR_UNKNOWN; 732 } 733 734 return ACAMERA_OK; 735 } 736 737 void 738 CameraDevice::setRemoteDevice(sp<hardware::camera2::ICameraDeviceUser> remote) { 739 Mutex::Autolock _l(mDeviceLock); 740 mRemote = remote; 741 } 742 743 camera_status_t 744 CameraDevice::checkCameraClosedOrErrorLocked() const { 745 if (mRemote == nullptr) { 746 ALOGE("%s: camera device already closed", __FUNCTION__); 747 return ACAMERA_ERROR_CAMERA_DISCONNECTED; 748 } 749 if (mInError) {// triggered by onDeviceError 750 ALOGE("%s: camera device has encountered a serious error", __FUNCTION__); 751 return mError; 752 } 753 return ACAMERA_OK; 754 } 755 756 void 757 CameraDevice::setCameraDeviceErrorLocked(camera_status_t error) { 758 mInError = true; 759 mError = error; 760 return; 761 } 762 763 void 764 CameraDevice::FrameNumberTracker::updateTracker(int64_t frameNumber, bool isError) { 765 ALOGV("updateTracker frame %" PRId64 " isError %d", frameNumber, isError); 766 if (isError) { 767 mFutureErrorSet.insert(frameNumber); 768 } else if (frameNumber <= mCompletedFrameNumber) { 769 ALOGE("Frame number %" PRId64 " decreased! current fn %" PRId64, 770 frameNumber, mCompletedFrameNumber); 771 return; 772 } else { 773 if (frameNumber != mCompletedFrameNumber + 1) { 774 ALOGE("Frame number out of order. Expect %" PRId64 " but get %" PRId64, 775 mCompletedFrameNumber + 1, frameNumber); 776 // Do not assert as in java implementation 777 } 778 mCompletedFrameNumber = frameNumber; 779 } 780 update(); 781 } 782 783 void 784 CameraDevice::FrameNumberTracker::update() { 785 for (auto it = mFutureErrorSet.begin(); it != mFutureErrorSet.end();) { 786 int64_t errorFrameNumber = *it; 787 if (errorFrameNumber == mCompletedFrameNumber + 1) { 788 mCompletedFrameNumber++; 789 it = mFutureErrorSet.erase(it); 790 } else if (errorFrameNumber <= mCompletedFrameNumber) { 791 // This should not happen, but deal with it anyway 792 ALOGE("Completd frame number passed through current frame number!"); 793 // erase the old error since it's no longer useful 794 it = mFutureErrorSet.erase(it); 795 } else { 796 // Normal requests hasn't catched up error frames, just break 797 break; 798 } 799 } 800 ALOGV("Update complete frame %" PRId64, mCompletedFrameNumber); 801 } 802 803 void 804 CameraDevice::onCaptureErrorLocked( 805 int32_t errorCode, 806 const CaptureResultExtras& resultExtras) { 807 int sequenceId = resultExtras.requestId; 808 int64_t frameNumber = resultExtras.frameNumber; 809 int32_t burstId = resultExtras.burstId; 810 auto it = mSequenceCallbackMap.find(sequenceId); 811 if (it == mSequenceCallbackMap.end()) { 812 ALOGE("%s: Error: capture sequence index %d not found!", 813 __FUNCTION__, sequenceId); 814 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 815 return; 816 } 817 818 CallbackHolder cbh = (*it).second; 819 sp<ACameraCaptureSession> session = cbh.mSession; 820 if ((size_t) burstId >= cbh.mRequests.size()) { 821 ALOGE("%s: Error: request index %d out of bound (size %zu)", 822 __FUNCTION__, burstId, cbh.mRequests.size()); 823 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 824 return; 825 } 826 sp<CaptureRequest> request = cbh.mRequests[burstId]; 827 828 // Handle buffer error 829 if (errorCode == hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER) { 830 int32_t streamId = resultExtras.errorStreamId; 831 ACameraCaptureSession_captureCallback_bufferLost onBufferLost = 832 cbh.mCallbacks.onCaptureBufferLost; 833 auto outputPairIt = mConfiguredOutputs.find(streamId); 834 if (outputPairIt == mConfiguredOutputs.end()) { 835 ALOGE("%s: Error: stream id %d does not exist", __FUNCTION__, streamId); 836 setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 837 return; 838 } 839 840 const auto& gbps = outputPairIt->second.second.getGraphicBufferProducers(); 841 for (const auto& outGbp : gbps) { 842 for (auto surface : request->mSurfaceList) { 843 if (surface->getIGraphicBufferProducer() == outGbp) { 844 ANativeWindow* anw = static_cast<ANativeWindow*>(surface.get()); 845 ALOGV("Camera %s Lost output buffer for ANW %p frame %" PRId64, 846 getId(), anw, frameNumber); 847 848 sp<AMessage> msg = new AMessage(kWhatCaptureBufferLost, mHandler); 849 msg->setPointer(kContextKey, cbh.mCallbacks.context); 850 msg->setObject(kSessionSpKey, session); 851 msg->setPointer(kCallbackFpKey, (void*) onBufferLost); 852 msg->setObject(kCaptureRequestKey, request); 853 msg->setPointer(kAnwKey, (void*) anw); 854 msg->setInt64(kFrameNumberKey, frameNumber); 855 postSessionMsgAndCleanup(msg); 856 } 857 } 858 } 859 } else { // Handle other capture failures 860 // Fire capture failure callback if there is one registered 861 ACameraCaptureSession_captureCallback_failed onError = cbh.mCallbacks.onCaptureFailed; 862 sp<CameraCaptureFailure> failure(new CameraCaptureFailure()); 863 failure->frameNumber = frameNumber; 864 // TODO: refine this when implementing flush 865 failure->reason = CAPTURE_FAILURE_REASON_ERROR; 866 failure->sequenceId = sequenceId; 867 failure->wasImageCaptured = (errorCode == 868 hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT); 869 870 sp<AMessage> msg = new AMessage(kWhatCaptureFail, mHandler); 871 msg->setPointer(kContextKey, cbh.mCallbacks.context); 872 msg->setObject(kSessionSpKey, session); 873 msg->setPointer(kCallbackFpKey, (void*) onError); 874 msg->setObject(kCaptureRequestKey, request); 875 msg->setObject(kCaptureFailureKey, failure); 876 postSessionMsgAndCleanup(msg); 877 878 // Update tracker 879 mFrameNumberTracker.updateTracker(frameNumber, /*isError*/true); 880 checkAndFireSequenceCompleteLocked(); 881 } 882 return; 883 } 884 885 void CameraDevice::CallbackHandler::onMessageReceived( 886 const sp<AMessage> &msg) { 887 switch (msg->what()) { 888 case kWhatOnDisconnected: 889 case kWhatOnError: 890 case kWhatSessionStateCb: 891 case kWhatCaptureStart: 892 case kWhatCaptureResult: 893 case kWhatCaptureFail: 894 case kWhatCaptureSeqEnd: 895 case kWhatCaptureSeqAbort: 896 case kWhatCaptureBufferLost: 897 ALOGV("%s: Received msg %d", __FUNCTION__, msg->what()); 898 break; 899 case kWhatCleanUpSessions: 900 mCachedSessions.clear(); 901 return; 902 default: 903 ALOGE("%s:Error: unknown device callback %d", __FUNCTION__, msg->what()); 904 return; 905 } 906 // Check the common part of all message 907 void* context; 908 bool found = msg->findPointer(kContextKey, &context); 909 if (!found) { 910 ALOGE("%s: Cannot find callback context!", __FUNCTION__); 911 return; 912 } 913 switch (msg->what()) { 914 case kWhatOnDisconnected: 915 { 916 ACameraDevice* dev; 917 found = msg->findPointer(kDeviceKey, (void**) &dev); 918 if (!found || dev == nullptr) { 919 ALOGE("%s: Cannot find device pointer!", __FUNCTION__); 920 return; 921 } 922 ACameraDevice_StateCallback onDisconnected; 923 found = msg->findPointer(kCallbackFpKey, (void**) &onDisconnected); 924 if (!found) { 925 ALOGE("%s: Cannot find onDisconnected!", __FUNCTION__); 926 return; 927 } 928 if (onDisconnected == nullptr) { 929 return; 930 } 931 (*onDisconnected)(context, dev); 932 break; 933 } 934 case kWhatOnError: 935 { 936 ACameraDevice* dev; 937 found = msg->findPointer(kDeviceKey, (void**) &dev); 938 if (!found || dev == nullptr) { 939 ALOGE("%s: Cannot find device pointer!", __FUNCTION__); 940 return; 941 } 942 ACameraDevice_ErrorStateCallback onError; 943 found = msg->findPointer(kCallbackFpKey, (void**) &onError); 944 if (!found) { 945 ALOGE("%s: Cannot find onError!", __FUNCTION__); 946 return; 947 } 948 int errorCode; 949 found = msg->findInt32(kErrorCodeKey, &errorCode); 950 if (!found) { 951 ALOGE("%s: Cannot find error code!", __FUNCTION__); 952 return; 953 } 954 if (onError == nullptr) { 955 return; 956 } 957 (*onError)(context, dev, errorCode); 958 break; 959 } 960 case kWhatSessionStateCb: 961 case kWhatCaptureStart: 962 case kWhatCaptureResult: 963 case kWhatCaptureFail: 964 case kWhatCaptureSeqEnd: 965 case kWhatCaptureSeqAbort: 966 case kWhatCaptureBufferLost: 967 { 968 sp<RefBase> obj; 969 found = msg->findObject(kSessionSpKey, &obj); 970 if (!found || obj == nullptr) { 971 ALOGE("%s: Cannot find session pointer!", __FUNCTION__); 972 return; 973 } 974 sp<ACameraCaptureSession> session(static_cast<ACameraCaptureSession*>(obj.get())); 975 mCachedSessions.push(session); 976 sp<CaptureRequest> requestSp = nullptr; 977 switch (msg->what()) { 978 case kWhatCaptureStart: 979 case kWhatCaptureResult: 980 case kWhatCaptureFail: 981 case kWhatCaptureBufferLost: 982 found = msg->findObject(kCaptureRequestKey, &obj); 983 if (!found) { 984 ALOGE("%s: Cannot find capture request!", __FUNCTION__); 985 return; 986 } 987 requestSp = static_cast<CaptureRequest*>(obj.get()); 988 break; 989 } 990 991 switch (msg->what()) { 992 case kWhatSessionStateCb: 993 { 994 ACameraCaptureSession_stateCallback onState; 995 found = msg->findPointer(kCallbackFpKey, (void**) &onState); 996 if (!found) { 997 ALOGE("%s: Cannot find state callback!", __FUNCTION__); 998 return; 999 } 1000 if (onState == nullptr) { 1001 return; 1002 } 1003 (*onState)(context, session.get()); 1004 break; 1005 } 1006 case kWhatCaptureStart: 1007 { 1008 ACameraCaptureSession_captureCallback_start onStart; 1009 found = msg->findPointer(kCallbackFpKey, (void**) &onStart); 1010 if (!found) { 1011 ALOGE("%s: Cannot find capture start callback!", __FUNCTION__); 1012 return; 1013 } 1014 if (onStart == nullptr) { 1015 return; 1016 } 1017 int64_t timestamp; 1018 found = msg->findInt64(kTimeStampKey, ×tamp); 1019 if (!found) { 1020 ALOGE("%s: Cannot find timestamp!", __FUNCTION__); 1021 return; 1022 } 1023 ACaptureRequest* request = allocateACaptureRequest(requestSp); 1024 (*onStart)(context, session.get(), request, timestamp); 1025 freeACaptureRequest(request); 1026 break; 1027 } 1028 case kWhatCaptureResult: 1029 { 1030 ACameraCaptureSession_captureCallback_result onResult; 1031 found = msg->findPointer(kCallbackFpKey, (void**) &onResult); 1032 if (!found) { 1033 ALOGE("%s: Cannot find capture result callback!", __FUNCTION__); 1034 return; 1035 } 1036 if (onResult == nullptr) { 1037 return; 1038 } 1039 1040 found = msg->findObject(kCaptureResultKey, &obj); 1041 if (!found) { 1042 ALOGE("%s: Cannot find capture result!", __FUNCTION__); 1043 return; 1044 } 1045 sp<ACameraMetadata> result(static_cast<ACameraMetadata*>(obj.get())); 1046 ACaptureRequest* request = allocateACaptureRequest(requestSp); 1047 (*onResult)(context, session.get(), request, result.get()); 1048 freeACaptureRequest(request); 1049 break; 1050 } 1051 case kWhatCaptureFail: 1052 { 1053 ACameraCaptureSession_captureCallback_failed onFail; 1054 found = msg->findPointer(kCallbackFpKey, (void**) &onFail); 1055 if (!found) { 1056 ALOGE("%s: Cannot find capture fail callback!", __FUNCTION__); 1057 return; 1058 } 1059 if (onFail == nullptr) { 1060 return; 1061 } 1062 1063 found = msg->findObject(kCaptureFailureKey, &obj); 1064 if (!found) { 1065 ALOGE("%s: Cannot find capture failure!", __FUNCTION__); 1066 return; 1067 } 1068 sp<CameraCaptureFailure> failureSp( 1069 static_cast<CameraCaptureFailure*>(obj.get())); 1070 ACameraCaptureFailure* failure = 1071 static_cast<ACameraCaptureFailure*>(failureSp.get()); 1072 ACaptureRequest* request = allocateACaptureRequest(requestSp); 1073 (*onFail)(context, session.get(), request, failure); 1074 freeACaptureRequest(request); 1075 break; 1076 } 1077 case kWhatCaptureSeqEnd: 1078 { 1079 ACameraCaptureSession_captureCallback_sequenceEnd onSeqEnd; 1080 found = msg->findPointer(kCallbackFpKey, (void**) &onSeqEnd); 1081 if (!found) { 1082 ALOGE("%s: Cannot find sequence end callback!", __FUNCTION__); 1083 return; 1084 } 1085 if (onSeqEnd == nullptr) { 1086 return; 1087 } 1088 int seqId; 1089 found = msg->findInt32(kSequenceIdKey, &seqId); 1090 if (!found) { 1091 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 1092 return; 1093 } 1094 int64_t frameNumber; 1095 found = msg->findInt64(kFrameNumberKey, &frameNumber); 1096 if (!found) { 1097 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 1098 return; 1099 } 1100 (*onSeqEnd)(context, session.get(), seqId, frameNumber); 1101 break; 1102 } 1103 case kWhatCaptureSeqAbort: 1104 { 1105 ACameraCaptureSession_captureCallback_sequenceAbort onSeqAbort; 1106 found = msg->findPointer(kCallbackFpKey, (void**) &onSeqAbort); 1107 if (!found) { 1108 ALOGE("%s: Cannot find sequence end callback!", __FUNCTION__); 1109 return; 1110 } 1111 if (onSeqAbort == nullptr) { 1112 return; 1113 } 1114 int seqId; 1115 found = msg->findInt32(kSequenceIdKey, &seqId); 1116 if (!found) { 1117 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 1118 return; 1119 } 1120 (*onSeqAbort)(context, session.get(), seqId); 1121 break; 1122 } 1123 case kWhatCaptureBufferLost: 1124 { 1125 ACameraCaptureSession_captureCallback_bufferLost onBufferLost; 1126 found = msg->findPointer(kCallbackFpKey, (void**) &onBufferLost); 1127 if (!found) { 1128 ALOGE("%s: Cannot find buffer lost callback!", __FUNCTION__); 1129 return; 1130 } 1131 if (onBufferLost == nullptr) { 1132 return; 1133 } 1134 1135 ANativeWindow* anw; 1136 found = msg->findPointer(kAnwKey, (void**) &anw); 1137 if (!found) { 1138 ALOGE("%s: Cannot find ANativeWindow!", __FUNCTION__); 1139 return; 1140 } 1141 1142 int64_t frameNumber; 1143 found = msg->findInt64(kFrameNumberKey, &frameNumber); 1144 if (!found) { 1145 ALOGE("%s: Cannot find frame number!", __FUNCTION__); 1146 return; 1147 } 1148 1149 ACaptureRequest* request = allocateACaptureRequest(requestSp); 1150 (*onBufferLost)(context, session.get(), request, anw, frameNumber); 1151 freeACaptureRequest(request); 1152 break; 1153 } 1154 } 1155 break; 1156 } 1157 } 1158 } 1159 1160 CameraDevice::CallbackHolder::CallbackHolder( 1161 sp<ACameraCaptureSession> session, 1162 const Vector<sp<CaptureRequest> >& requests, 1163 bool isRepeating, 1164 ACameraCaptureSession_captureCallbacks* cbs) : 1165 mSession(session), mRequests(requests), 1166 mIsRepeating(isRepeating), mCallbacks(fillCb(cbs)) {} 1167 1168 void 1169 CameraDevice::checkRepeatingSequenceCompleteLocked( 1170 const int sequenceId, const int64_t lastFrameNumber) { 1171 ALOGV("Repeating seqId %d lastFrameNumer %" PRId64, sequenceId, lastFrameNumber); 1172 if (lastFrameNumber == NO_FRAMES_CAPTURED) { 1173 if (mSequenceCallbackMap.count(sequenceId) == 0) { 1174 ALOGW("No callback found for sequenceId %d", sequenceId); 1175 return; 1176 } 1177 // remove callback holder from callback map 1178 auto cbIt = mSequenceCallbackMap.find(sequenceId); 1179 CallbackHolder cbh = cbIt->second; 1180 mSequenceCallbackMap.erase(cbIt); 1181 // send seq aborted callback 1182 sp<AMessage> msg = new AMessage(kWhatCaptureSeqAbort, mHandler); 1183 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1184 msg->setObject(kSessionSpKey, cbh.mSession); 1185 msg->setPointer(kCallbackFpKey, (void*) cbh.mCallbacks.onCaptureSequenceAborted); 1186 msg->setInt32(kSequenceIdKey, sequenceId); 1187 postSessionMsgAndCleanup(msg); 1188 } else { 1189 // Use mSequenceLastFrameNumberMap to track 1190 mSequenceLastFrameNumberMap.insert(std::make_pair(sequenceId, lastFrameNumber)); 1191 1192 // Last frame might have arrived. Check now 1193 checkAndFireSequenceCompleteLocked(); 1194 } 1195 } 1196 1197 void 1198 CameraDevice::checkAndFireSequenceCompleteLocked() { 1199 int64_t completedFrameNumber = mFrameNumberTracker.getCompletedFrameNumber(); 1200 //std::map<int, int64_t> mSequenceLastFrameNumberMap; 1201 auto it = mSequenceLastFrameNumberMap.begin(); 1202 while (it != mSequenceLastFrameNumberMap.end()) { 1203 int sequenceId = it->first; 1204 int64_t lastFrameNumber = it->second; 1205 bool seqCompleted = false; 1206 bool hasCallback = true; 1207 1208 if (mRemote == nullptr) { 1209 ALOGW("Camera %s closed while checking sequence complete", getId()); 1210 return; 1211 } 1212 1213 // Check if there is callback for this sequence 1214 // This should not happen because we always register callback (with nullptr inside) 1215 if (mSequenceCallbackMap.count(sequenceId) == 0) { 1216 ALOGW("No callback found for sequenceId %d", sequenceId); 1217 hasCallback = false; 1218 } 1219 1220 if (lastFrameNumber <= completedFrameNumber) { 1221 ALOGV("seq %d reached last frame %" PRId64 ", completed %" PRId64, 1222 sequenceId, lastFrameNumber, completedFrameNumber); 1223 seqCompleted = true; 1224 } 1225 1226 if (seqCompleted && hasCallback) { 1227 // remove callback holder from callback map 1228 auto cbIt = mSequenceCallbackMap.find(sequenceId); 1229 CallbackHolder cbh = cbIt->second; 1230 mSequenceCallbackMap.erase(cbIt); 1231 // send seq complete callback 1232 sp<AMessage> msg = new AMessage(kWhatCaptureSeqEnd, mHandler); 1233 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1234 msg->setObject(kSessionSpKey, cbh.mSession); 1235 msg->setPointer(kCallbackFpKey, (void*) cbh.mCallbacks.onCaptureSequenceCompleted); 1236 msg->setInt32(kSequenceIdKey, sequenceId); 1237 msg->setInt64(kFrameNumberKey, lastFrameNumber); 1238 1239 // Clear the session sp before we send out the message 1240 // This will guarantee the rare case where the message is processed 1241 // before cbh goes out of scope and causing we call the session 1242 // destructor while holding device lock 1243 cbh.mSession.clear(); 1244 postSessionMsgAndCleanup(msg); 1245 } 1246 1247 // No need to track sequence complete if there is no callback registered 1248 if (seqCompleted || !hasCallback) { 1249 it = mSequenceLastFrameNumberMap.erase(it); 1250 } else { 1251 ++it; 1252 } 1253 } 1254 } 1255 1256 /** 1257 * Camera service callback implementation 1258 */ 1259 binder::Status 1260 CameraDevice::ServiceCallback::onDeviceError( 1261 int32_t errorCode, 1262 const CaptureResultExtras& resultExtras) { 1263 ALOGD("Device error received, code %d, frame number %" PRId64 ", request ID %d, subseq ID %d", 1264 errorCode, resultExtras.frameNumber, resultExtras.requestId, resultExtras.burstId); 1265 binder::Status ret = binder::Status::ok(); 1266 sp<CameraDevice> dev = mDevice.promote(); 1267 if (dev == nullptr) { 1268 return ret; // device has been closed 1269 } 1270 1271 sp<ACameraCaptureSession> session = dev->mCurrentSession.promote(); 1272 Mutex::Autolock _l(dev->mDeviceLock); 1273 if (dev->mRemote == nullptr) { 1274 return ret; // device has been closed 1275 } 1276 switch (errorCode) { 1277 case ERROR_CAMERA_DISCONNECTED: 1278 { 1279 // Camera is disconnected, close the session and expect no more callbacks 1280 if (session != nullptr) { 1281 session->closeByDevice(); 1282 } 1283 dev->mCurrentSession = nullptr; 1284 sp<AMessage> msg = new AMessage(kWhatOnDisconnected, dev->mHandler); 1285 msg->setPointer(kContextKey, dev->mAppCallbacks.context); 1286 msg->setPointer(kDeviceKey, (void*) dev->getWrapper()); 1287 msg->setPointer(kCallbackFpKey, (void*) dev->mAppCallbacks.onDisconnected); 1288 msg->post(); 1289 break; 1290 } 1291 default: 1292 ALOGE("Unknown error from camera device: %d", errorCode); 1293 // no break 1294 case ERROR_CAMERA_DEVICE: 1295 case ERROR_CAMERA_SERVICE: 1296 { 1297 switch (errorCode) { 1298 case ERROR_CAMERA_DEVICE: 1299 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 1300 break; 1301 case ERROR_CAMERA_SERVICE: 1302 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 1303 break; 1304 default: 1305 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_UNKNOWN); 1306 break; 1307 } 1308 sp<AMessage> msg = new AMessage(kWhatOnError, dev->mHandler); 1309 msg->setPointer(kContextKey, dev->mAppCallbacks.context); 1310 msg->setPointer(kDeviceKey, (void*) dev->getWrapper()); 1311 msg->setPointer(kCallbackFpKey, (void*) dev->mAppCallbacks.onError); 1312 msg->setInt32(kErrorCodeKey, errorCode); 1313 msg->post(); 1314 break; 1315 } 1316 case ERROR_CAMERA_REQUEST: 1317 case ERROR_CAMERA_RESULT: 1318 case ERROR_CAMERA_BUFFER: 1319 dev->onCaptureErrorLocked(errorCode, resultExtras); 1320 break; 1321 } 1322 return ret; 1323 } 1324 1325 binder::Status 1326 CameraDevice::ServiceCallback::onDeviceIdle() { 1327 ALOGV("Camera is now idle"); 1328 binder::Status ret = binder::Status::ok(); 1329 sp<CameraDevice> dev = mDevice.promote(); 1330 if (dev == nullptr) { 1331 return ret; // device has been closed 1332 } 1333 1334 Mutex::Autolock _l(dev->mDeviceLock); 1335 if (dev->isClosed() || dev->mRemote == nullptr) { 1336 return ret; 1337 } 1338 1339 if (dev->mIdle) { 1340 // Already in idle state. Possibly other thread did waitUntilIdle 1341 return ret; 1342 } 1343 1344 if (dev->mCurrentSession != nullptr) { 1345 ALOGE("onDeviceIdle sending state cb"); 1346 if (dev->mBusySession != dev->mCurrentSession) { 1347 ALOGE("Current session != busy session"); 1348 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_DEVICE); 1349 return ret; 1350 } 1351 1352 sp<AMessage> msg = new AMessage(kWhatSessionStateCb, dev->mHandler); 1353 msg->setPointer(kContextKey, dev->mBusySession->mUserSessionCallback.context); 1354 msg->setObject(kSessionSpKey, dev->mBusySession); 1355 msg->setPointer(kCallbackFpKey, (void*) dev->mBusySession->mUserSessionCallback.onReady); 1356 // Make sure we clear the sp first so the session destructor can 1357 // only happen on handler thread (where we don't hold device/session lock) 1358 dev->mBusySession.clear(); 1359 dev->postSessionMsgAndCleanup(msg); 1360 } 1361 dev->mIdle = true; 1362 dev->mFlushing = false; 1363 return ret; 1364 } 1365 1366 binder::Status 1367 CameraDevice::ServiceCallback::onCaptureStarted( 1368 const CaptureResultExtras& resultExtras, 1369 int64_t timestamp) { 1370 binder::Status ret = binder::Status::ok(); 1371 1372 sp<CameraDevice> dev = mDevice.promote(); 1373 if (dev == nullptr) { 1374 return ret; // device has been closed 1375 } 1376 Mutex::Autolock _l(dev->mDeviceLock); 1377 if (dev->isClosed() || dev->mRemote == nullptr) { 1378 return ret; 1379 } 1380 1381 int sequenceId = resultExtras.requestId; 1382 int32_t burstId = resultExtras.burstId; 1383 1384 auto it = dev->mSequenceCallbackMap.find(sequenceId); 1385 if (it != dev->mSequenceCallbackMap.end()) { 1386 CallbackHolder cbh = (*it).second; 1387 ACameraCaptureSession_captureCallback_start onStart = cbh.mCallbacks.onCaptureStarted; 1388 sp<ACameraCaptureSession> session = cbh.mSession; 1389 if ((size_t) burstId >= cbh.mRequests.size()) { 1390 ALOGE("%s: Error: request index %d out of bound (size %zu)", 1391 __FUNCTION__, burstId, cbh.mRequests.size()); 1392 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 1393 } 1394 sp<CaptureRequest> request = cbh.mRequests[burstId]; 1395 sp<AMessage> msg = new AMessage(kWhatCaptureStart, dev->mHandler); 1396 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1397 msg->setObject(kSessionSpKey, session); 1398 msg->setPointer(kCallbackFpKey, (void*) onStart); 1399 msg->setObject(kCaptureRequestKey, request); 1400 msg->setInt64(kTimeStampKey, timestamp); 1401 dev->postSessionMsgAndCleanup(msg); 1402 } 1403 return ret; 1404 } 1405 1406 binder::Status 1407 CameraDevice::ServiceCallback::onResultReceived( 1408 const CameraMetadata& metadata, 1409 const CaptureResultExtras& resultExtras, 1410 const std::vector<PhysicalCaptureResultInfo>& physicalResultInfos) { 1411 (void) physicalResultInfos; 1412 binder::Status ret = binder::Status::ok(); 1413 1414 sp<CameraDevice> dev = mDevice.promote(); 1415 if (dev == nullptr) { 1416 return ret; // device has been closed 1417 } 1418 int sequenceId = resultExtras.requestId; 1419 int64_t frameNumber = resultExtras.frameNumber; 1420 int32_t burstId = resultExtras.burstId; 1421 bool isPartialResult = (resultExtras.partialResultCount < dev->mPartialResultCount); 1422 1423 if (!isPartialResult) { 1424 ALOGV("SeqId %d frame %" PRId64 " result arrive.", sequenceId, frameNumber); 1425 } 1426 1427 Mutex::Autolock _l(dev->mDeviceLock); 1428 if (dev->mRemote == nullptr) { 1429 return ret; // device has been disconnected 1430 } 1431 1432 if (dev->isClosed()) { 1433 if (!isPartialResult) { 1434 dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false); 1435 } 1436 // early return to avoid callback sent to closed devices 1437 return ret; 1438 } 1439 1440 CameraMetadata metadataCopy = metadata; 1441 metadataCopy.update(ANDROID_LENS_INFO_SHADING_MAP_SIZE, dev->mShadingMapSize, /*data_count*/2); 1442 metadataCopy.update(ANDROID_SYNC_FRAME_NUMBER, &frameNumber, /*data_count*/1); 1443 1444 auto it = dev->mSequenceCallbackMap.find(sequenceId); 1445 if (it != dev->mSequenceCallbackMap.end()) { 1446 CallbackHolder cbh = (*it).second; 1447 ACameraCaptureSession_captureCallback_result onResult = isPartialResult ? 1448 cbh.mCallbacks.onCaptureProgressed : 1449 cbh.mCallbacks.onCaptureCompleted; 1450 sp<ACameraCaptureSession> session = cbh.mSession; 1451 if ((size_t) burstId >= cbh.mRequests.size()) { 1452 ALOGE("%s: Error: request index %d out of bound (size %zu)", 1453 __FUNCTION__, burstId, cbh.mRequests.size()); 1454 dev->setCameraDeviceErrorLocked(ACAMERA_ERROR_CAMERA_SERVICE); 1455 } 1456 sp<CaptureRequest> request = cbh.mRequests[burstId]; 1457 sp<ACameraMetadata> result(new ACameraMetadata( 1458 metadataCopy.release(), ACameraMetadata::ACM_RESULT)); 1459 1460 sp<AMessage> msg = new AMessage(kWhatCaptureResult, dev->mHandler); 1461 msg->setPointer(kContextKey, cbh.mCallbacks.context); 1462 msg->setObject(kSessionSpKey, session); 1463 msg->setPointer(kCallbackFpKey, (void*) onResult); 1464 msg->setObject(kCaptureRequestKey, request); 1465 msg->setObject(kCaptureResultKey, result); 1466 dev->postSessionMsgAndCleanup(msg); 1467 } 1468 1469 if (!isPartialResult) { 1470 dev->mFrameNumberTracker.updateTracker(frameNumber, /*isError*/false); 1471 dev->checkAndFireSequenceCompleteLocked(); 1472 } 1473 1474 return ret; 1475 } 1476 1477 binder::Status 1478 CameraDevice::ServiceCallback::onPrepared(int) { 1479 // Prepare not yet implemented in NDK 1480 return binder::Status::ok(); 1481 } 1482 1483 binder::Status 1484 CameraDevice::ServiceCallback::onRequestQueueEmpty() { 1485 // onRequestQueueEmpty not yet implemented in NDK 1486 return binder::Status::ok(); 1487 } 1488 1489 binder::Status 1490 CameraDevice::ServiceCallback::onRepeatingRequestError( 1491 int64_t lastFrameNumber, int32_t stoppedSequenceId) { 1492 binder::Status ret = binder::Status::ok(); 1493 1494 sp<CameraDevice> dev = mDevice.promote(); 1495 if (dev == nullptr) { 1496 return ret; // device has been closed 1497 } 1498 1499 Mutex::Autolock _l(dev->mDeviceLock); 1500 1501 int repeatingSequenceId = dev->mRepeatingSequenceId; 1502 if (stoppedSequenceId == repeatingSequenceId) { 1503 dev->mRepeatingSequenceId = REQUEST_ID_NONE; 1504 } 1505 1506 dev->checkRepeatingSequenceCompleteLocked(repeatingSequenceId, lastFrameNumber); 1507 1508 return ret; 1509 } 1510 1511 1512 } // namespace android 1513
