1 /* 2 * Copyright (C) 2013 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 "CameraDeviceClient" 18 #define ATRACE_TAG ATRACE_TAG_CAMERA 19 //#define LOG_NDEBUG 0 20 21 #include <cutils/properties.h> 22 #include <utils/Log.h> 23 #include <utils/Trace.h> 24 #include <gui/Surface.h> 25 #include <camera/camera2/CaptureRequest.h> 26 #include <camera/CameraUtils.h> 27 28 #include "common/CameraDeviceBase.h" 29 #include "api2/CameraDeviceClient.h" 30 31 // Convenience methods for constructing binder::Status objects for error returns 32 33 #define STATUS_ERROR(errorCode, errorString) \ 34 binder::Status::fromServiceSpecificError(errorCode, \ 35 String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString)) 36 37 #define STATUS_ERROR_FMT(errorCode, errorString, ...) \ 38 binder::Status::fromServiceSpecificError(errorCode, \ 39 String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, \ 40 __VA_ARGS__)) 41 42 namespace android { 43 using namespace camera2; 44 45 CameraDeviceClientBase::CameraDeviceClientBase( 46 const sp<CameraService>& cameraService, 47 const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback, 48 const String16& clientPackageName, 49 const String8& cameraId, 50 int cameraFacing, 51 int clientPid, 52 uid_t clientUid, 53 int servicePid) : 54 BasicClient(cameraService, 55 IInterface::asBinder(remoteCallback), 56 clientPackageName, 57 cameraId, 58 cameraFacing, 59 clientPid, 60 clientUid, 61 servicePid), 62 mRemoteCallback(remoteCallback) { 63 } 64 65 // Interface used by CameraService 66 67 CameraDeviceClient::CameraDeviceClient(const sp<CameraService>& cameraService, 68 const sp<hardware::camera2::ICameraDeviceCallbacks>& remoteCallback, 69 const String16& clientPackageName, 70 const String8& cameraId, 71 int cameraFacing, 72 int clientPid, 73 uid_t clientUid, 74 int servicePid) : 75 Camera2ClientBase(cameraService, remoteCallback, clientPackageName, 76 cameraId, cameraFacing, clientPid, clientUid, servicePid), 77 mInputStream(), 78 mStreamingRequestId(REQUEST_ID_NONE), 79 mRequestIdCounter(0) { 80 81 ATRACE_CALL(); 82 ALOGI("CameraDeviceClient %s: Opened", cameraId.string()); 83 } 84 85 status_t CameraDeviceClient::initialize(sp<CameraProviderManager> manager) { 86 return initializeImpl(manager); 87 } 88 89 template<typename TProviderPtr> 90 status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr) { 91 ATRACE_CALL(); 92 status_t res; 93 94 res = Camera2ClientBase::initialize(providerPtr); 95 if (res != OK) { 96 return res; 97 } 98 99 String8 threadName; 100 mFrameProcessor = new FrameProcessorBase(mDevice); 101 threadName = String8::format("CDU-%s-FrameProc", mCameraIdStr.string()); 102 mFrameProcessor->run(threadName.string()); 103 104 mFrameProcessor->registerListener(FRAME_PROCESSOR_LISTENER_MIN_ID, 105 FRAME_PROCESSOR_LISTENER_MAX_ID, 106 /*listener*/this, 107 /*sendPartials*/true); 108 109 return OK; 110 } 111 112 CameraDeviceClient::~CameraDeviceClient() { 113 } 114 115 binder::Status CameraDeviceClient::submitRequest( 116 const hardware::camera2::CaptureRequest& request, 117 bool streaming, 118 /*out*/ 119 hardware::camera2::utils::SubmitInfo *submitInfo) { 120 std::vector<hardware::camera2::CaptureRequest> requestList = { request }; 121 return submitRequestList(requestList, streaming, submitInfo); 122 } 123 124 binder::Status CameraDeviceClient::submitRequestList( 125 const std::vector<hardware::camera2::CaptureRequest>& requests, 126 bool streaming, 127 /*out*/ 128 hardware::camera2::utils::SubmitInfo *submitInfo) { 129 ATRACE_CALL(); 130 ALOGV("%s-start of function. Request list size %zu", __FUNCTION__, requests.size()); 131 132 binder::Status res = binder::Status::ok(); 133 status_t err; 134 if ( !(res = checkPidStatus(__FUNCTION__) ).isOk()) { 135 return res; 136 } 137 138 Mutex::Autolock icl(mBinderSerializationLock); 139 140 if (!mDevice.get()) { 141 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 142 } 143 144 if (requests.empty()) { 145 ALOGE("%s: Camera %s: Sent null request. Rejecting request.", 146 __FUNCTION__, mCameraIdStr.string()); 147 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Empty request list"); 148 } 149 150 List<const CameraMetadata> metadataRequestList; 151 std::list<const SurfaceMap> surfaceMapList; 152 submitInfo->mRequestId = mRequestIdCounter; 153 uint32_t loopCounter = 0; 154 155 for (auto&& request: requests) { 156 if (request.mIsReprocess) { 157 if (!mInputStream.configured) { 158 ALOGE("%s: Camera %s: no input stream is configured.", __FUNCTION__, 159 mCameraIdStr.string()); 160 return STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT, 161 "No input configured for camera %s but request is for reprocessing", 162 mCameraIdStr.string()); 163 } else if (streaming) { 164 ALOGE("%s: Camera %s: streaming reprocess requests not supported.", __FUNCTION__, 165 mCameraIdStr.string()); 166 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, 167 "Repeating reprocess requests not supported"); 168 } 169 } 170 171 CameraMetadata metadata(request.mMetadata); 172 if (metadata.isEmpty()) { 173 ALOGE("%s: Camera %s: Sent empty metadata packet. Rejecting request.", 174 __FUNCTION__, mCameraIdStr.string()); 175 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, 176 "Request settings are empty"); 177 } else if (request.mSurfaceList.isEmpty()) { 178 ALOGE("%s: Camera %s: Requests must have at least one surface target. " 179 "Rejecting request.", __FUNCTION__, mCameraIdStr.string()); 180 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, 181 "Request has no output targets"); 182 } 183 184 if (!enforceRequestPermissions(metadata)) { 185 // Callee logs 186 return STATUS_ERROR(CameraService::ERROR_PERMISSION_DENIED, 187 "Caller does not have permission to change restricted controls"); 188 } 189 190 /** 191 * Write in the output stream IDs and map from stream ID to surface ID 192 * which we calculate from the capture request's list of surface target 193 */ 194 SurfaceMap surfaceMap; 195 Vector<int32_t> outputStreamIds; 196 for (sp<Surface> surface : request.mSurfaceList) { 197 if (surface == 0) continue; 198 199 sp<IGraphicBufferProducer> gbp = surface->getIGraphicBufferProducer(); 200 int idx = mStreamMap.indexOfKey(IInterface::asBinder(gbp)); 201 202 // Trying to submit request with surface that wasn't created 203 if (idx == NAME_NOT_FOUND) { 204 ALOGE("%s: Camera %s: Tried to submit a request with a surface that" 205 " we have not called createStream on", 206 __FUNCTION__, mCameraIdStr.string()); 207 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, 208 "Request targets Surface that is not part of current capture session"); 209 } 210 211 const StreamSurfaceId& streamSurfaceId = mStreamMap.valueAt(idx); 212 if (surfaceMap.find(streamSurfaceId.streamId()) == surfaceMap.end()) { 213 surfaceMap[streamSurfaceId.streamId()] = std::vector<size_t>(); 214 outputStreamIds.push_back(streamSurfaceId.streamId()); 215 } 216 surfaceMap[streamSurfaceId.streamId()].push_back(streamSurfaceId.surfaceId()); 217 218 ALOGV("%s: Camera %s: Appending output stream %d surface %d to request", 219 __FUNCTION__, mCameraIdStr.string(), streamSurfaceId.streamId(), 220 streamSurfaceId.surfaceId()); 221 } 222 223 metadata.update(ANDROID_REQUEST_OUTPUT_STREAMS, &outputStreamIds[0], 224 outputStreamIds.size()); 225 226 if (request.mIsReprocess) { 227 metadata.update(ANDROID_REQUEST_INPUT_STREAMS, &mInputStream.id, 1); 228 } 229 230 metadata.update(ANDROID_REQUEST_ID, &(submitInfo->mRequestId), /*size*/1); 231 loopCounter++; // loopCounter starts from 1 232 ALOGV("%s: Camera %s: Creating request with ID %d (%d of %zu)", 233 __FUNCTION__, mCameraIdStr.string(), submitInfo->mRequestId, 234 loopCounter, requests.size()); 235 236 metadataRequestList.push_back(metadata); 237 surfaceMapList.push_back(surfaceMap); 238 } 239 mRequestIdCounter++; 240 241 if (streaming) { 242 err = mDevice->setStreamingRequestList(metadataRequestList, surfaceMapList, 243 &(submitInfo->mLastFrameNumber)); 244 if (err != OK) { 245 String8 msg = String8::format( 246 "Camera %s: Got error %s (%d) after trying to set streaming request", 247 mCameraIdStr.string(), strerror(-err), err); 248 ALOGE("%s: %s", __FUNCTION__, msg.string()); 249 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, 250 msg.string()); 251 } else { 252 Mutex::Autolock idLock(mStreamingRequestIdLock); 253 mStreamingRequestId = submitInfo->mRequestId; 254 } 255 } else { 256 err = mDevice->captureList(metadataRequestList, surfaceMapList, 257 &(submitInfo->mLastFrameNumber)); 258 if (err != OK) { 259 String8 msg = String8::format( 260 "Camera %s: Got error %s (%d) after trying to submit capture request", 261 mCameraIdStr.string(), strerror(-err), err); 262 ALOGE("%s: %s", __FUNCTION__, msg.string()); 263 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, 264 msg.string()); 265 } 266 ALOGV("%s: requestId = %d ", __FUNCTION__, submitInfo->mRequestId); 267 } 268 269 ALOGV("%s: Camera %s: End of function", __FUNCTION__, mCameraIdStr.string()); 270 return res; 271 } 272 273 binder::Status CameraDeviceClient::cancelRequest( 274 int requestId, 275 /*out*/ 276 int64_t* lastFrameNumber) { 277 ATRACE_CALL(); 278 ALOGV("%s, requestId = %d", __FUNCTION__, requestId); 279 280 status_t err; 281 binder::Status res; 282 283 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 284 285 Mutex::Autolock icl(mBinderSerializationLock); 286 287 if (!mDevice.get()) { 288 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 289 } 290 291 Mutex::Autolock idLock(mStreamingRequestIdLock); 292 if (mStreamingRequestId != requestId) { 293 String8 msg = String8::format("Camera %s: Canceling request ID %d doesn't match " 294 "current request ID %d", mCameraIdStr.string(), requestId, mStreamingRequestId); 295 ALOGE("%s: %s", __FUNCTION__, msg.string()); 296 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 297 } 298 299 err = mDevice->clearStreamingRequest(lastFrameNumber); 300 301 if (err == OK) { 302 ALOGV("%s: Camera %s: Successfully cleared streaming request", 303 __FUNCTION__, mCameraIdStr.string()); 304 mStreamingRequestId = REQUEST_ID_NONE; 305 } else { 306 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 307 "Camera %s: Error clearing streaming request: %s (%d)", 308 mCameraIdStr.string(), strerror(-err), err); 309 } 310 311 return res; 312 } 313 314 binder::Status CameraDeviceClient::beginConfigure() { 315 // TODO: Implement this. 316 ATRACE_CALL(); 317 ALOGV("%s: Not implemented yet.", __FUNCTION__); 318 return binder::Status::ok(); 319 } 320 321 binder::Status CameraDeviceClient::endConfigure(int operatingMode) { 322 ATRACE_CALL(); 323 ALOGV("%s: ending configure (%d input stream, %zu output surfaces)", 324 __FUNCTION__, mInputStream.configured ? 1 : 0, 325 mStreamMap.size()); 326 327 binder::Status res; 328 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 329 330 Mutex::Autolock icl(mBinderSerializationLock); 331 332 if (!mDevice.get()) { 333 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 334 } 335 336 if (operatingMode < 0) { 337 String8 msg = String8::format( 338 "Camera %s: Invalid operating mode %d requested", mCameraIdStr.string(), operatingMode); 339 ALOGE("%s: %s", __FUNCTION__, msg.string()); 340 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, 341 msg.string()); 342 } 343 344 // Sanitize the high speed session against necessary capability bit. 345 bool isConstrainedHighSpeed = (operatingMode == ICameraDeviceUser::CONSTRAINED_HIGH_SPEED_MODE); 346 if (isConstrainedHighSpeed) { 347 CameraMetadata staticInfo = mDevice->info(); 348 camera_metadata_entry_t entry = staticInfo.find(ANDROID_REQUEST_AVAILABLE_CAPABILITIES); 349 bool isConstrainedHighSpeedSupported = false; 350 for(size_t i = 0; i < entry.count; ++i) { 351 uint8_t capability = entry.data.u8[i]; 352 if (capability == ANDROID_REQUEST_AVAILABLE_CAPABILITIES_CONSTRAINED_HIGH_SPEED_VIDEO) { 353 isConstrainedHighSpeedSupported = true; 354 break; 355 } 356 } 357 if (!isConstrainedHighSpeedSupported) { 358 String8 msg = String8::format( 359 "Camera %s: Try to create a constrained high speed configuration on a device" 360 " that doesn't support it.", mCameraIdStr.string()); 361 ALOGE("%s: %s", __FUNCTION__, msg.string()); 362 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, 363 msg.string()); 364 } 365 } 366 367 status_t err = mDevice->configureStreams(operatingMode); 368 if (err == BAD_VALUE) { 369 String8 msg = String8::format("Camera %s: Unsupported set of inputs/outputs provided", 370 mCameraIdStr.string()); 371 ALOGE("%s: %s", __FUNCTION__, msg.string()); 372 res = STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 373 } else if (err != OK) { 374 String8 msg = String8::format("Camera %s: Error configuring streams: %s (%d)", 375 mCameraIdStr.string(), strerror(-err), err); 376 ALOGE("%s: %s", __FUNCTION__, msg.string()); 377 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 378 } 379 380 return res; 381 } 382 383 binder::Status CameraDeviceClient::deleteStream(int streamId) { 384 ATRACE_CALL(); 385 ALOGV("%s (streamId = 0x%x)", __FUNCTION__, streamId); 386 387 binder::Status res; 388 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 389 390 Mutex::Autolock icl(mBinderSerializationLock); 391 392 if (!mDevice.get()) { 393 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 394 } 395 396 bool isInput = false; 397 std::vector<sp<IBinder>> surfaces; 398 ssize_t dIndex = NAME_NOT_FOUND; 399 400 if (mInputStream.configured && mInputStream.id == streamId) { 401 isInput = true; 402 } else { 403 // Guard against trying to delete non-created streams 404 for (size_t i = 0; i < mStreamMap.size(); ++i) { 405 if (streamId == mStreamMap.valueAt(i).streamId()) { 406 surfaces.push_back(mStreamMap.keyAt(i)); 407 } 408 } 409 410 // See if this stream is one of the deferred streams. 411 for (size_t i = 0; i < mDeferredStreams.size(); ++i) { 412 if (streamId == mDeferredStreams[i]) { 413 dIndex = i; 414 break; 415 } 416 } 417 418 if (surfaces.empty() && dIndex == NAME_NOT_FOUND) { 419 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no such" 420 " stream created yet", mCameraIdStr.string(), streamId); 421 ALOGW("%s: %s", __FUNCTION__, msg.string()); 422 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 423 } 424 } 425 426 // Also returns BAD_VALUE if stream ID was not valid 427 status_t err = mDevice->deleteStream(streamId); 428 429 if (err != OK) { 430 String8 msg = String8::format("Camera %s: Unexpected error %s (%d) when deleting stream %d", 431 mCameraIdStr.string(), strerror(-err), err, streamId); 432 ALOGE("%s: %s", __FUNCTION__, msg.string()); 433 res = STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 434 } else { 435 if (isInput) { 436 mInputStream.configured = false; 437 } else { 438 for (auto& surface : surfaces) { 439 mStreamMap.removeItem(surface); 440 } 441 442 if (dIndex != NAME_NOT_FOUND) { 443 mDeferredStreams.removeItemsAt(dIndex); 444 } 445 } 446 } 447 448 return res; 449 } 450 451 binder::Status CameraDeviceClient::createStream( 452 const hardware::camera2::params::OutputConfiguration &outputConfiguration, 453 /*out*/ 454 int32_t* newStreamId) { 455 ATRACE_CALL(); 456 457 binder::Status res; 458 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 459 460 Mutex::Autolock icl(mBinderSerializationLock); 461 462 const std::vector<sp<IGraphicBufferProducer>>& bufferProducers = 463 outputConfiguration.getGraphicBufferProducers(); 464 size_t numBufferProducers = bufferProducers.size(); 465 bool deferredConsumer = outputConfiguration.isDeferred(); 466 bool isShared = outputConfiguration.isShared(); 467 468 if (numBufferProducers > MAX_SURFACES_PER_STREAM) { 469 ALOGE("%s: GraphicBufferProducer count %zu for stream exceeds limit of %d", 470 __FUNCTION__, bufferProducers.size(), MAX_SURFACES_PER_STREAM); 471 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Surface count is too high"); 472 } 473 bool deferredConsumerOnly = deferredConsumer && numBufferProducers == 0; 474 int surfaceType = outputConfiguration.getSurfaceType(); 475 bool validSurfaceType = ((surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) || 476 (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_TEXTURE)); 477 478 if (deferredConsumer && !validSurfaceType) { 479 ALOGE("%s: Target surface is invalid: bufferProducer = %p, surfaceType = %d.", 480 __FUNCTION__, bufferProducers[0].get(), surfaceType); 481 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Target Surface is invalid"); 482 } 483 484 if (!mDevice.get()) { 485 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 486 } 487 488 std::vector<sp<Surface>> surfaces; 489 std::vector<sp<IBinder>> binders; 490 status_t err; 491 492 // Create stream for deferred surface case. 493 if (deferredConsumerOnly) { 494 return createDeferredSurfaceStreamLocked(outputConfiguration, isShared, newStreamId); 495 } 496 497 OutputStreamInfo streamInfo; 498 bool isStreamInfoValid = false; 499 for (auto& bufferProducer : bufferProducers) { 500 // Don't create multiple streams for the same target surface 501 sp<IBinder> binder = IInterface::asBinder(bufferProducer); 502 ssize_t index = mStreamMap.indexOfKey(binder); 503 if (index != NAME_NOT_FOUND) { 504 String8 msg = String8::format("Camera %s: Surface already has a stream created for it " 505 "(ID %zd)", mCameraIdStr.string(), index); 506 ALOGW("%s: %s", __FUNCTION__, msg.string()); 507 return STATUS_ERROR(CameraService::ERROR_ALREADY_EXISTS, msg.string()); 508 } 509 510 sp<Surface> surface; 511 res = createSurfaceFromGbp(streamInfo, isStreamInfoValid, surface, bufferProducer); 512 513 if (!res.isOk()) 514 return res; 515 516 if (!isStreamInfoValid) { 517 // Streaming sharing is only supported for IMPLEMENTATION_DEFINED 518 // formats. 519 if (isShared && streamInfo.format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 520 String8 msg = String8::format("Camera %s: Stream sharing is only supported for " 521 "IMPLEMENTATION_DEFINED format", mCameraIdStr.string()); 522 ALOGW("%s: %s", __FUNCTION__, msg.string()); 523 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 524 } 525 isStreamInfoValid = true; 526 } 527 528 binders.push_back(IInterface::asBinder(bufferProducer)); 529 surfaces.push_back(surface); 530 } 531 532 int streamId = camera3::CAMERA3_STREAM_ID_INVALID; 533 err = mDevice->createStream(surfaces, deferredConsumer, streamInfo.width, 534 streamInfo.height, streamInfo.format, streamInfo.dataSpace, 535 static_cast<camera3_stream_rotation_t>(outputConfiguration.getRotation()), 536 &streamId, outputConfiguration.getSurfaceSetID(), isShared); 537 538 if (err != OK) { 539 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 540 "Camera %s: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)", 541 mCameraIdStr.string(), streamInfo.width, streamInfo.height, streamInfo.format, 542 streamInfo.dataSpace, strerror(-err), err); 543 } else { 544 int i = 0; 545 for (auto& binder : binders) { 546 ALOGV("%s: mStreamMap add binder %p streamId %d, surfaceId %d", 547 __FUNCTION__, binder.get(), streamId, i); 548 mStreamMap.add(binder, StreamSurfaceId(streamId, i++)); 549 } 550 551 mStreamInfoMap[streamId] = streamInfo; 552 553 ALOGV("%s: Camera %s: Successfully created a new stream ID %d for output surface" 554 " (%d x %d) with format 0x%x.", 555 __FUNCTION__, mCameraIdStr.string(), streamId, streamInfo.width, 556 streamInfo.height, streamInfo.format); 557 558 // Set transform flags to ensure preview to be rotated correctly. 559 res = setStreamTransformLocked(streamId); 560 561 *newStreamId = streamId; 562 } 563 564 return res; 565 } 566 567 binder::Status CameraDeviceClient::createDeferredSurfaceStreamLocked( 568 const hardware::camera2::params::OutputConfiguration &outputConfiguration, 569 bool isShared, 570 /*out*/ 571 int* newStreamId) { 572 int width, height, format, surfaceType; 573 uint64_t consumerUsage; 574 android_dataspace dataSpace; 575 status_t err; 576 binder::Status res; 577 578 if (!mDevice.get()) { 579 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 580 } 581 582 // Infer the surface info for deferred surface stream creation. 583 width = outputConfiguration.getWidth(); 584 height = outputConfiguration.getHeight(); 585 surfaceType = outputConfiguration.getSurfaceType(); 586 format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; 587 dataSpace = android_dataspace_t::HAL_DATASPACE_UNKNOWN; 588 // Hardcode consumer usage flags: SurfaceView--0x900, SurfaceTexture--0x100. 589 consumerUsage = GraphicBuffer::USAGE_HW_TEXTURE; 590 if (surfaceType == OutputConfiguration::SURFACE_TYPE_SURFACE_VIEW) { 591 consumerUsage |= GraphicBuffer::USAGE_HW_COMPOSER; 592 } 593 int streamId = camera3::CAMERA3_STREAM_ID_INVALID; 594 std::vector<sp<Surface>> noSurface; 595 err = mDevice->createStream(noSurface, /*hasDeferredConsumer*/true, width, 596 height, format, dataSpace, 597 static_cast<camera3_stream_rotation_t>(outputConfiguration.getRotation()), 598 &streamId, outputConfiguration.getSurfaceSetID(), isShared, consumerUsage); 599 600 if (err != OK) { 601 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 602 "Camera %s: Error creating output stream (%d x %d, fmt %x, dataSpace %x): %s (%d)", 603 mCameraIdStr.string(), width, height, format, dataSpace, strerror(-err), err); 604 } else { 605 // Can not add streamId to mStreamMap here, as the surface is deferred. Add it to 606 // a separate list to track. Once the deferred surface is set, this id will be 607 // relocated to mStreamMap. 608 mDeferredStreams.push_back(streamId); 609 610 mStreamInfoMap.emplace(std::piecewise_construct, std::forward_as_tuple(streamId), 611 std::forward_as_tuple(width, height, format, dataSpace, consumerUsage)); 612 613 ALOGV("%s: Camera %s: Successfully created a new stream ID %d for a deferred surface" 614 " (%d x %d) stream with format 0x%x.", 615 __FUNCTION__, mCameraIdStr.string(), streamId, width, height, format); 616 617 // Set transform flags to ensure preview to be rotated correctly. 618 res = setStreamTransformLocked(streamId); 619 620 *newStreamId = streamId; 621 } 622 return res; 623 } 624 625 binder::Status CameraDeviceClient::setStreamTransformLocked(int streamId) { 626 int32_t transform = 0; 627 status_t err; 628 binder::Status res; 629 630 if (!mDevice.get()) { 631 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 632 } 633 634 err = getRotationTransformLocked(&transform); 635 if (err != OK) { 636 // Error logged by getRotationTransformLocked. 637 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, 638 "Unable to calculate rotation transform for new stream"); 639 } 640 641 err = mDevice->setStreamTransform(streamId, transform); 642 if (err != OK) { 643 String8 msg = String8::format("Failed to set stream transform (stream id %d)", 644 streamId); 645 ALOGE("%s: %s", __FUNCTION__, msg.string()); 646 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 647 } 648 649 return res; 650 } 651 652 binder::Status CameraDeviceClient::createInputStream( 653 int width, int height, int format, 654 /*out*/ 655 int32_t* newStreamId) { 656 657 ATRACE_CALL(); 658 ALOGV("%s (w = %d, h = %d, f = 0x%x)", __FUNCTION__, width, height, format); 659 660 binder::Status res; 661 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 662 663 Mutex::Autolock icl(mBinderSerializationLock); 664 665 if (!mDevice.get()) { 666 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 667 } 668 669 if (mInputStream.configured) { 670 String8 msg = String8::format("Camera %s: Already has an input stream " 671 "configured (ID %zd)", mCameraIdStr.string(), mInputStream.id); 672 ALOGE("%s: %s", __FUNCTION__, msg.string() ); 673 return STATUS_ERROR(CameraService::ERROR_ALREADY_EXISTS, msg.string()); 674 } 675 676 int streamId = -1; 677 status_t err = mDevice->createInputStream(width, height, format, &streamId); 678 if (err == OK) { 679 mInputStream.configured = true; 680 mInputStream.width = width; 681 mInputStream.height = height; 682 mInputStream.format = format; 683 mInputStream.id = streamId; 684 685 ALOGV("%s: Camera %s: Successfully created a new input stream ID %d", 686 __FUNCTION__, mCameraIdStr.string(), streamId); 687 688 *newStreamId = streamId; 689 } else { 690 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 691 "Camera %s: Error creating new input stream: %s (%d)", mCameraIdStr.string(), 692 strerror(-err), err); 693 } 694 695 return res; 696 } 697 698 binder::Status CameraDeviceClient::getInputSurface(/*out*/ view::Surface *inputSurface) { 699 700 binder::Status res; 701 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 702 703 if (inputSurface == NULL) { 704 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Null input surface"); 705 } 706 707 Mutex::Autolock icl(mBinderSerializationLock); 708 if (!mDevice.get()) { 709 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 710 } 711 sp<IGraphicBufferProducer> producer; 712 status_t err = mDevice->getInputBufferProducer(&producer); 713 if (err != OK) { 714 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 715 "Camera %s: Error getting input Surface: %s (%d)", 716 mCameraIdStr.string(), strerror(-err), err); 717 } else { 718 inputSurface->name = String16("CameraInput"); 719 inputSurface->graphicBufferProducer = producer; 720 } 721 return res; 722 } 723 724 bool CameraDeviceClient::isPublicFormat(int32_t format) 725 { 726 switch(format) { 727 case HAL_PIXEL_FORMAT_RGBA_8888: 728 case HAL_PIXEL_FORMAT_RGBX_8888: 729 case HAL_PIXEL_FORMAT_RGB_888: 730 case HAL_PIXEL_FORMAT_RGB_565: 731 case HAL_PIXEL_FORMAT_BGRA_8888: 732 case HAL_PIXEL_FORMAT_YV12: 733 case HAL_PIXEL_FORMAT_Y8: 734 case HAL_PIXEL_FORMAT_Y16: 735 case HAL_PIXEL_FORMAT_RAW16: 736 case HAL_PIXEL_FORMAT_RAW10: 737 case HAL_PIXEL_FORMAT_RAW12: 738 case HAL_PIXEL_FORMAT_RAW_OPAQUE: 739 case HAL_PIXEL_FORMAT_BLOB: 740 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 741 case HAL_PIXEL_FORMAT_YCbCr_420_888: 742 case HAL_PIXEL_FORMAT_YCbCr_422_888: 743 case HAL_PIXEL_FORMAT_YCbCr_444_888: 744 case HAL_PIXEL_FORMAT_FLEX_RGB_888: 745 case HAL_PIXEL_FORMAT_FLEX_RGBA_8888: 746 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 747 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 748 case HAL_PIXEL_FORMAT_YCbCr_422_I: 749 return true; 750 default: 751 return false; 752 } 753 } 754 755 binder::Status CameraDeviceClient::createSurfaceFromGbp( 756 OutputStreamInfo& streamInfo, bool isStreamInfoValid, 757 sp<Surface>& surface, const sp<IGraphicBufferProducer>& gbp) { 758 759 // bufferProducer must be non-null 760 if (gbp == nullptr) { 761 String8 msg = String8::format("Camera %s: Surface is NULL", mCameraIdStr.string()); 762 ALOGW("%s: %s", __FUNCTION__, msg.string()); 763 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 764 } 765 // HACK b/10949105 766 // Query consumer usage bits to set async operation mode for 767 // GLConsumer using controlledByApp parameter. 768 bool useAsync = false; 769 uint64_t consumerUsage = 0; 770 status_t err; 771 if ((err = gbp->getConsumerUsage(&consumerUsage)) != OK) { 772 String8 msg = String8::format("Camera %s: Failed to query Surface consumer usage: %s (%d)", 773 mCameraIdStr.string(), strerror(-err), err); 774 ALOGE("%s: %s", __FUNCTION__, msg.string()); 775 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 776 } 777 if (consumerUsage & GraphicBuffer::USAGE_HW_TEXTURE) { 778 ALOGW("%s: Camera %s with consumer usage flag: %" PRIu64 ": Forcing asynchronous mode for stream", 779 __FUNCTION__, mCameraIdStr.string(), consumerUsage); 780 useAsync = true; 781 } 782 783 uint64_t disallowedFlags = GraphicBuffer::USAGE_HW_VIDEO_ENCODER | 784 GRALLOC_USAGE_RENDERSCRIPT; 785 uint64_t allowedFlags = GraphicBuffer::USAGE_SW_READ_MASK | 786 GraphicBuffer::USAGE_HW_TEXTURE | 787 GraphicBuffer::USAGE_HW_COMPOSER; 788 bool flexibleConsumer = (consumerUsage & disallowedFlags) == 0 && 789 (consumerUsage & allowedFlags) != 0; 790 791 surface = new Surface(gbp, useAsync); 792 ANativeWindow *anw = surface.get(); 793 794 int width, height, format; 795 android_dataspace dataSpace; 796 if ((err = anw->query(anw, NATIVE_WINDOW_WIDTH, &width)) != OK) { 797 String8 msg = String8::format("Camera %s: Failed to query Surface width: %s (%d)", 798 mCameraIdStr.string(), strerror(-err), err); 799 ALOGE("%s: %s", __FUNCTION__, msg.string()); 800 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 801 } 802 if ((err = anw->query(anw, NATIVE_WINDOW_HEIGHT, &height)) != OK) { 803 String8 msg = String8::format("Camera %s: Failed to query Surface height: %s (%d)", 804 mCameraIdStr.string(), strerror(-err), err); 805 ALOGE("%s: %s", __FUNCTION__, msg.string()); 806 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 807 } 808 if ((err = anw->query(anw, NATIVE_WINDOW_FORMAT, &format)) != OK) { 809 String8 msg = String8::format("Camera %s: Failed to query Surface format: %s (%d)", 810 mCameraIdStr.string(), strerror(-err), err); 811 ALOGE("%s: %s", __FUNCTION__, msg.string()); 812 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 813 } 814 if ((err = anw->query(anw, NATIVE_WINDOW_DEFAULT_DATASPACE, 815 reinterpret_cast<int*>(&dataSpace))) != OK) { 816 String8 msg = String8::format("Camera %s: Failed to query Surface dataspace: %s (%d)", 817 mCameraIdStr.string(), strerror(-err), err); 818 ALOGE("%s: %s", __FUNCTION__, msg.string()); 819 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 820 } 821 822 // FIXME: remove this override since the default format should be 823 // IMPLEMENTATION_DEFINED. b/9487482 824 if (format >= HAL_PIXEL_FORMAT_RGBA_8888 && 825 format <= HAL_PIXEL_FORMAT_BGRA_8888) { 826 ALOGW("%s: Camera %s: Overriding format %#x to IMPLEMENTATION_DEFINED", 827 __FUNCTION__, mCameraIdStr.string(), format); 828 format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED; 829 } 830 // Round dimensions to the nearest dimensions available for this format 831 if (flexibleConsumer && isPublicFormat(format) && 832 !CameraDeviceClient::roundBufferDimensionNearest(width, height, 833 format, dataSpace, mDevice->info(), /*out*/&width, /*out*/&height)) { 834 String8 msg = String8::format("Camera %s: No supported stream configurations with " 835 "format %#x defined, failed to create output stream", 836 mCameraIdStr.string(), format); 837 ALOGE("%s: %s", __FUNCTION__, msg.string()); 838 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 839 } 840 841 if (!isStreamInfoValid) { 842 streamInfo.width = width; 843 streamInfo.height = height; 844 streamInfo.format = format; 845 streamInfo.dataSpace = dataSpace; 846 streamInfo.consumerUsage = consumerUsage; 847 return binder::Status::ok(); 848 } 849 if (width != streamInfo.width) { 850 String8 msg = String8::format("Camera %s:Surface width doesn't match: %d vs %d", 851 mCameraIdStr.string(), width, streamInfo.width); 852 ALOGE("%s: %s", __FUNCTION__, msg.string()); 853 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 854 } 855 if (height != streamInfo.height) { 856 String8 msg = String8::format("Camera %s:Surface height doesn't match: %d vs %d", 857 mCameraIdStr.string(), height, streamInfo.height); 858 ALOGE("%s: %s", __FUNCTION__, msg.string()); 859 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 860 } 861 if (format != streamInfo.format) { 862 String8 msg = String8::format("Camera %s:Surface format doesn't match: %d vs %d", 863 mCameraIdStr.string(), format, streamInfo.format); 864 ALOGE("%s: %s", __FUNCTION__, msg.string()); 865 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 866 } 867 if (format != HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED) { 868 if (dataSpace != streamInfo.dataSpace) { 869 String8 msg = String8::format("Camera %s:Surface dataSpace doesn't match: %d vs %d", 870 mCameraIdStr.string(), dataSpace, streamInfo.dataSpace); 871 ALOGE("%s: %s", __FUNCTION__, msg.string()); 872 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 873 } 874 //At the native side, there isn't a way to check whether 2 surfaces come from the same 875 //surface class type. Use usage flag to approximate the comparison. 876 if (consumerUsage != streamInfo.consumerUsage) { 877 String8 msg = String8::format( 878 "Camera %s:Surface usage flag doesn't match %" PRIu64 " vs %" PRIu64 "", 879 mCameraIdStr.string(), consumerUsage, streamInfo.consumerUsage); 880 ALOGE("%s: %s", __FUNCTION__, msg.string()); 881 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 882 } 883 } 884 return binder::Status::ok(); 885 } 886 887 bool CameraDeviceClient::roundBufferDimensionNearest(int32_t width, int32_t height, 888 int32_t format, android_dataspace dataSpace, const CameraMetadata& info, 889 /*out*/int32_t* outWidth, /*out*/int32_t* outHeight) { 890 891 camera_metadata_ro_entry streamConfigs = 892 (dataSpace == HAL_DATASPACE_DEPTH) ? 893 info.find(ANDROID_DEPTH_AVAILABLE_DEPTH_STREAM_CONFIGURATIONS) : 894 info.find(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS); 895 896 int32_t bestWidth = -1; 897 int32_t bestHeight = -1; 898 899 // Iterate through listed stream configurations and find the one with the smallest euclidean 900 // distance from the given dimensions for the given format. 901 for (size_t i = 0; i < streamConfigs.count; i += 4) { 902 int32_t fmt = streamConfigs.data.i32[i]; 903 int32_t w = streamConfigs.data.i32[i + 1]; 904 int32_t h = streamConfigs.data.i32[i + 2]; 905 906 // Ignore input/output type for now 907 if (fmt == format) { 908 if (w == width && h == height) { 909 bestWidth = width; 910 bestHeight = height; 911 break; 912 } else if (w <= ROUNDING_WIDTH_CAP && (bestWidth == -1 || 913 CameraDeviceClient::euclidDistSquare(w, h, width, height) < 914 CameraDeviceClient::euclidDistSquare(bestWidth, bestHeight, width, height))) { 915 bestWidth = w; 916 bestHeight = h; 917 } 918 } 919 } 920 921 if (bestWidth == -1) { 922 // Return false if no configurations for this format were listed 923 return false; 924 } 925 926 // Set the outputs to the closet width/height 927 if (outWidth != NULL) { 928 *outWidth = bestWidth; 929 } 930 if (outHeight != NULL) { 931 *outHeight = bestHeight; 932 } 933 934 // Return true if at least one configuration for this format was listed 935 return true; 936 } 937 938 int64_t CameraDeviceClient::euclidDistSquare(int32_t x0, int32_t y0, int32_t x1, int32_t y1) { 939 int64_t d0 = x0 - x1; 940 int64_t d1 = y0 - y1; 941 return d0 * d0 + d1 * d1; 942 } 943 944 // Create a request object from a template. 945 binder::Status CameraDeviceClient::createDefaultRequest(int templateId, 946 /*out*/ 947 hardware::camera2::impl::CameraMetadataNative* request) 948 { 949 ATRACE_CALL(); 950 ALOGV("%s (templateId = 0x%x)", __FUNCTION__, templateId); 951 952 binder::Status res; 953 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 954 955 Mutex::Autolock icl(mBinderSerializationLock); 956 957 if (!mDevice.get()) { 958 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 959 } 960 961 CameraMetadata metadata; 962 status_t err; 963 if ( (err = mDevice->createDefaultRequest(templateId, &metadata) ) == OK && 964 request != NULL) { 965 966 request->swap(metadata); 967 } else if (err == BAD_VALUE) { 968 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT, 969 "Camera %s: Template ID %d is invalid or not supported: %s (%d)", 970 mCameraIdStr.string(), templateId, strerror(-err), err); 971 972 } else { 973 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 974 "Camera %s: Error creating default request for template %d: %s (%d)", 975 mCameraIdStr.string(), templateId, strerror(-err), err); 976 } 977 return res; 978 } 979 980 binder::Status CameraDeviceClient::getCameraInfo( 981 /*out*/ 982 hardware::camera2::impl::CameraMetadataNative* info) 983 { 984 ATRACE_CALL(); 985 ALOGV("%s", __FUNCTION__); 986 987 binder::Status res; 988 989 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 990 991 Mutex::Autolock icl(mBinderSerializationLock); 992 993 if (!mDevice.get()) { 994 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 995 } 996 997 if (info != NULL) { 998 *info = mDevice->info(); // static camera metadata 999 // TODO: merge with device-specific camera metadata 1000 } 1001 1002 return res; 1003 } 1004 1005 binder::Status CameraDeviceClient::waitUntilIdle() 1006 { 1007 ATRACE_CALL(); 1008 ALOGV("%s", __FUNCTION__); 1009 1010 binder::Status res; 1011 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 1012 1013 Mutex::Autolock icl(mBinderSerializationLock); 1014 1015 if (!mDevice.get()) { 1016 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 1017 } 1018 1019 // FIXME: Also need check repeating burst. 1020 Mutex::Autolock idLock(mStreamingRequestIdLock); 1021 if (mStreamingRequestId != REQUEST_ID_NONE) { 1022 String8 msg = String8::format( 1023 "Camera %s: Try to waitUntilIdle when there are active streaming requests", 1024 mCameraIdStr.string()); 1025 ALOGE("%s: %s", __FUNCTION__, msg.string()); 1026 return STATUS_ERROR(CameraService::ERROR_INVALID_OPERATION, msg.string()); 1027 } 1028 status_t err = mDevice->waitUntilDrained(); 1029 if (err != OK) { 1030 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 1031 "Camera %s: Error waiting to drain: %s (%d)", 1032 mCameraIdStr.string(), strerror(-err), err); 1033 } 1034 ALOGV("%s Done", __FUNCTION__); 1035 return res; 1036 } 1037 1038 binder::Status CameraDeviceClient::flush( 1039 /*out*/ 1040 int64_t* lastFrameNumber) { 1041 ATRACE_CALL(); 1042 ALOGV("%s", __FUNCTION__); 1043 1044 binder::Status res; 1045 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 1046 1047 Mutex::Autolock icl(mBinderSerializationLock); 1048 1049 if (!mDevice.get()) { 1050 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 1051 } 1052 1053 Mutex::Autolock idLock(mStreamingRequestIdLock); 1054 mStreamingRequestId = REQUEST_ID_NONE; 1055 status_t err = mDevice->flush(lastFrameNumber); 1056 if (err != OK) { 1057 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 1058 "Camera %s: Error flushing device: %s (%d)", mCameraIdStr.string(), strerror(-err), err); 1059 } 1060 return res; 1061 } 1062 1063 binder::Status CameraDeviceClient::prepare(int streamId) { 1064 ATRACE_CALL(); 1065 ALOGV("%s", __FUNCTION__); 1066 1067 binder::Status res; 1068 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 1069 1070 Mutex::Autolock icl(mBinderSerializationLock); 1071 1072 // Guard against trying to prepare non-created streams 1073 ssize_t index = NAME_NOT_FOUND; 1074 for (size_t i = 0; i < mStreamMap.size(); ++i) { 1075 if (streamId == mStreamMap.valueAt(i).streamId()) { 1076 index = i; 1077 break; 1078 } 1079 } 1080 1081 if (index == NAME_NOT_FOUND) { 1082 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream " 1083 "with that ID exists", mCameraIdStr.string(), streamId); 1084 ALOGW("%s: %s", __FUNCTION__, msg.string()); 1085 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 1086 } 1087 1088 // Also returns BAD_VALUE if stream ID was not valid, or stream already 1089 // has been used 1090 status_t err = mDevice->prepare(streamId); 1091 if (err == BAD_VALUE) { 1092 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT, 1093 "Camera %s: Stream %d has already been used, and cannot be prepared", 1094 mCameraIdStr.string(), streamId); 1095 } else if (err != OK) { 1096 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 1097 "Camera %s: Error preparing stream %d: %s (%d)", mCameraIdStr.string(), streamId, 1098 strerror(-err), err); 1099 } 1100 return res; 1101 } 1102 1103 binder::Status CameraDeviceClient::prepare2(int maxCount, int streamId) { 1104 ATRACE_CALL(); 1105 ALOGV("%s", __FUNCTION__); 1106 1107 binder::Status res; 1108 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 1109 1110 Mutex::Autolock icl(mBinderSerializationLock); 1111 1112 // Guard against trying to prepare non-created streams 1113 ssize_t index = NAME_NOT_FOUND; 1114 for (size_t i = 0; i < mStreamMap.size(); ++i) { 1115 if (streamId == mStreamMap.valueAt(i).streamId()) { 1116 index = i; 1117 break; 1118 } 1119 } 1120 1121 if (index == NAME_NOT_FOUND) { 1122 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream " 1123 "with that ID exists", mCameraIdStr.string(), streamId); 1124 ALOGW("%s: %s", __FUNCTION__, msg.string()); 1125 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 1126 } 1127 1128 if (maxCount <= 0) { 1129 String8 msg = String8::format("Camera %s: maxCount (%d) must be greater than 0", 1130 mCameraIdStr.string(), maxCount); 1131 ALOGE("%s: %s", __FUNCTION__, msg.string()); 1132 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 1133 } 1134 1135 // Also returns BAD_VALUE if stream ID was not valid, or stream already 1136 // has been used 1137 status_t err = mDevice->prepare(maxCount, streamId); 1138 if (err == BAD_VALUE) { 1139 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT, 1140 "Camera %s: Stream %d has already been used, and cannot be prepared", 1141 mCameraIdStr.string(), streamId); 1142 } else if (err != OK) { 1143 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 1144 "Camera %s: Error preparing stream %d: %s (%d)", mCameraIdStr.string(), streamId, 1145 strerror(-err), err); 1146 } 1147 1148 return res; 1149 } 1150 1151 binder::Status CameraDeviceClient::tearDown(int streamId) { 1152 ATRACE_CALL(); 1153 ALOGV("%s", __FUNCTION__); 1154 1155 binder::Status res; 1156 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 1157 1158 Mutex::Autolock icl(mBinderSerializationLock); 1159 1160 // Guard against trying to prepare non-created streams 1161 ssize_t index = NAME_NOT_FOUND; 1162 for (size_t i = 0; i < mStreamMap.size(); ++i) { 1163 if (streamId == mStreamMap.valueAt(i).streamId()) { 1164 index = i; 1165 break; 1166 } 1167 } 1168 1169 if (index == NAME_NOT_FOUND) { 1170 String8 msg = String8::format("Camera %s: Invalid stream ID (%d) specified, no stream " 1171 "with that ID exists", mCameraIdStr.string(), streamId); 1172 ALOGW("%s: %s", __FUNCTION__, msg.string()); 1173 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 1174 } 1175 1176 // Also returns BAD_VALUE if stream ID was not valid or if the stream is in 1177 // use 1178 status_t err = mDevice->tearDown(streamId); 1179 if (err == BAD_VALUE) { 1180 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT, 1181 "Camera %s: Stream %d is still in use, cannot be torn down", 1182 mCameraIdStr.string(), streamId); 1183 } else if (err != OK) { 1184 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 1185 "Camera %s: Error tearing down stream %d: %s (%d)", mCameraIdStr.string(), streamId, 1186 strerror(-err), err); 1187 } 1188 1189 return res; 1190 } 1191 1192 binder::Status CameraDeviceClient::finalizeOutputConfigurations(int32_t streamId, 1193 const hardware::camera2::params::OutputConfiguration &outputConfiguration) { 1194 ATRACE_CALL(); 1195 1196 binder::Status res; 1197 if (!(res = checkPidStatus(__FUNCTION__)).isOk()) return res; 1198 1199 Mutex::Autolock icl(mBinderSerializationLock); 1200 1201 const std::vector<sp<IGraphicBufferProducer> >& bufferProducers = 1202 outputConfiguration.getGraphicBufferProducers(); 1203 1204 if (bufferProducers.size() == 0) { 1205 ALOGE("%s: bufferProducers must not be empty", __FUNCTION__); 1206 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, "Target Surface is invalid"); 1207 } 1208 1209 // streamId should be in mStreamMap if this stream already has a surface attached 1210 // to it. Otherwise, it should be in mDeferredStreams. 1211 bool streamIdConfigured = false; 1212 ssize_t deferredStreamIndex = NAME_NOT_FOUND; 1213 for (size_t i = 0; i < mStreamMap.size(); i++) { 1214 if (mStreamMap.valueAt(i).streamId() == streamId) { 1215 streamIdConfigured = true; 1216 break; 1217 } 1218 } 1219 for (size_t i = 0; i < mDeferredStreams.size(); i++) { 1220 if (streamId == mDeferredStreams[i]) { 1221 deferredStreamIndex = i; 1222 break; 1223 } 1224 1225 } 1226 if (deferredStreamIndex == NAME_NOT_FOUND && !streamIdConfigured) { 1227 String8 msg = String8::format("Camera %s: deferred surface is set to a unknown stream" 1228 "(ID %d)", mCameraIdStr.string(), streamId); 1229 ALOGW("%s: %s", __FUNCTION__, msg.string()); 1230 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 1231 } 1232 1233 if (mStreamInfoMap[streamId].finalized) { 1234 String8 msg = String8::format("Camera %s: finalizeOutputConfigurations has been called" 1235 " on stream ID %d", mCameraIdStr.string(), streamId); 1236 ALOGW("%s: %s", __FUNCTION__, msg.string()); 1237 return STATUS_ERROR(CameraService::ERROR_ILLEGAL_ARGUMENT, msg.string()); 1238 } 1239 1240 if (!mDevice.get()) { 1241 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, "Camera device no longer alive"); 1242 } 1243 1244 std::vector<sp<Surface>> consumerSurfaces; 1245 std::vector<size_t> consumerSurfaceIds; 1246 size_t surfaceId = 0; 1247 for (auto& bufferProducer : bufferProducers) { 1248 // Don't create multiple streams for the same target surface 1249 ssize_t index = mStreamMap.indexOfKey(IInterface::asBinder(bufferProducer)); 1250 if (index != NAME_NOT_FOUND) { 1251 ALOGV("Camera %s: Surface already has a stream created " 1252 " for it (ID %zd)", mCameraIdStr.string(), index); 1253 surfaceId++; 1254 continue; 1255 } 1256 1257 sp<Surface> surface; 1258 res = createSurfaceFromGbp(mStreamInfoMap[streamId], true /*isStreamInfoValid*/, 1259 surface, bufferProducer); 1260 1261 if (!res.isOk()) 1262 return res; 1263 1264 consumerSurfaces.push_back(surface); 1265 consumerSurfaceIds.push_back(surfaceId); 1266 surfaceId++; 1267 } 1268 1269 // Gracefully handle case where finalizeOutputConfigurations is called 1270 // without any new surface. 1271 if (consumerSurfaces.size() == 0) { 1272 mStreamInfoMap[streamId].finalized = true; 1273 return res; 1274 } 1275 1276 // Finish the deferred stream configuration with the surface. 1277 status_t err; 1278 err = mDevice->setConsumerSurfaces(streamId, consumerSurfaces); 1279 if (err == OK) { 1280 for (size_t i = 0; i < consumerSurfaces.size(); i++) { 1281 sp<IBinder> binder = IInterface::asBinder( 1282 consumerSurfaces[i]->getIGraphicBufferProducer()); 1283 ALOGV("%s: mStreamMap add binder %p streamId %d, surfaceId %zu", __FUNCTION__, 1284 binder.get(), streamId, consumerSurfaceIds[i]); 1285 mStreamMap.add(binder, StreamSurfaceId(streamId, consumerSurfaceIds[i])); 1286 } 1287 if (deferredStreamIndex != NAME_NOT_FOUND) { 1288 mDeferredStreams.removeItemsAt(deferredStreamIndex); 1289 } 1290 mStreamInfoMap[streamId].finalized = true; 1291 } else if (err == NO_INIT) { 1292 res = STATUS_ERROR_FMT(CameraService::ERROR_ILLEGAL_ARGUMENT, 1293 "Camera %s: Deferred surface is invalid: %s (%d)", 1294 mCameraIdStr.string(), strerror(-err), err); 1295 } else { 1296 res = STATUS_ERROR_FMT(CameraService::ERROR_INVALID_OPERATION, 1297 "Camera %s: Error setting output stream deferred surface: %s (%d)", 1298 mCameraIdStr.string(), strerror(-err), err); 1299 } 1300 1301 return res; 1302 } 1303 1304 status_t CameraDeviceClient::dump(int fd, const Vector<String16>& args) { 1305 return BasicClient::dump(fd, args); 1306 } 1307 1308 status_t CameraDeviceClient::dumpClient(int fd, const Vector<String16>& args) { 1309 dprintf(fd, " CameraDeviceClient[%s] (%p) dump:\n", 1310 mCameraIdStr.string(), 1311 (getRemoteCallback() != NULL ? 1312 IInterface::asBinder(getRemoteCallback()).get() : NULL) ); 1313 dprintf(fd, " Current client UID %u\n", mClientUid); 1314 1315 dprintf(fd, " State:\n"); 1316 dprintf(fd, " Request ID counter: %d\n", mRequestIdCounter); 1317 if (mInputStream.configured) { 1318 dprintf(fd, " Current input stream ID: %d\n", mInputStream.id); 1319 } else { 1320 dprintf(fd, " No input stream configured.\n"); 1321 } 1322 if (!mStreamMap.isEmpty()) { 1323 dprintf(fd, " Current output stream/surface IDs:\n"); 1324 for (size_t i = 0; i < mStreamMap.size(); i++) { 1325 dprintf(fd, " Stream %d Surface %d\n", 1326 mStreamMap.valueAt(i).streamId(), 1327 mStreamMap.valueAt(i).surfaceId()); 1328 } 1329 } else if (!mDeferredStreams.isEmpty()) { 1330 dprintf(fd, " Current deferred surface output stream IDs:\n"); 1331 for (auto& streamId : mDeferredStreams) { 1332 dprintf(fd, " Stream %d\n", streamId); 1333 } 1334 } else { 1335 dprintf(fd, " No output streams configured.\n"); 1336 } 1337 // TODO: print dynamic/request section from most recent requests 1338 mFrameProcessor->dump(fd, args); 1339 1340 return dumpDevice(fd, args); 1341 } 1342 1343 void CameraDeviceClient::notifyError(int32_t errorCode, 1344 const CaptureResultExtras& resultExtras) { 1345 // Thread safe. Don't bother locking. 1346 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback(); 1347 1348 if (remoteCb != 0) { 1349 remoteCb->onDeviceError(errorCode, resultExtras); 1350 } 1351 } 1352 1353 void CameraDeviceClient::notifyRepeatingRequestError(long lastFrameNumber) { 1354 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback(); 1355 1356 if (remoteCb != 0) { 1357 remoteCb->onRepeatingRequestError(lastFrameNumber, mStreamingRequestId); 1358 } 1359 1360 Mutex::Autolock idLock(mStreamingRequestIdLock); 1361 mStreamingRequestId = REQUEST_ID_NONE; 1362 } 1363 1364 void CameraDeviceClient::notifyIdle() { 1365 // Thread safe. Don't bother locking. 1366 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback(); 1367 1368 if (remoteCb != 0) { 1369 remoteCb->onDeviceIdle(); 1370 } 1371 Camera2ClientBase::notifyIdle(); 1372 } 1373 1374 void CameraDeviceClient::notifyShutter(const CaptureResultExtras& resultExtras, 1375 nsecs_t timestamp) { 1376 // Thread safe. Don't bother locking. 1377 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback(); 1378 if (remoteCb != 0) { 1379 remoteCb->onCaptureStarted(resultExtras, timestamp); 1380 } 1381 Camera2ClientBase::notifyShutter(resultExtras, timestamp); 1382 } 1383 1384 void CameraDeviceClient::notifyPrepared(int streamId) { 1385 // Thread safe. Don't bother locking. 1386 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback(); 1387 if (remoteCb != 0) { 1388 remoteCb->onPrepared(streamId); 1389 } 1390 } 1391 1392 void CameraDeviceClient::notifyRequestQueueEmpty() { 1393 // Thread safe. Don't bother locking. 1394 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback(); 1395 if (remoteCb != 0) { 1396 remoteCb->onRequestQueueEmpty(); 1397 } 1398 } 1399 1400 void CameraDeviceClient::detachDevice() { 1401 if (mDevice == 0) return; 1402 1403 ALOGV("Camera %s: Stopping processors", mCameraIdStr.string()); 1404 1405 mFrameProcessor->removeListener(FRAME_PROCESSOR_LISTENER_MIN_ID, 1406 FRAME_PROCESSOR_LISTENER_MAX_ID, 1407 /*listener*/this); 1408 mFrameProcessor->requestExit(); 1409 ALOGV("Camera %s: Waiting for threads", mCameraIdStr.string()); 1410 mFrameProcessor->join(); 1411 ALOGV("Camera %s: Disconnecting device", mCameraIdStr.string()); 1412 1413 // WORKAROUND: HAL refuses to disconnect while there's streams in flight 1414 { 1415 mDevice->clearStreamingRequest(); 1416 1417 status_t code; 1418 if ((code = mDevice->waitUntilDrained()) != OK) { 1419 ALOGE("%s: waitUntilDrained failed with code 0x%x", __FUNCTION__, 1420 code); 1421 } 1422 } 1423 1424 Camera2ClientBase::detachDevice(); 1425 } 1426 1427 /** Device-related methods */ 1428 void CameraDeviceClient::onResultAvailable(const CaptureResult& result) { 1429 ATRACE_CALL(); 1430 ALOGV("%s", __FUNCTION__); 1431 1432 // Thread-safe. No lock necessary. 1433 sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = mRemoteCallback; 1434 if (remoteCb != NULL) { 1435 remoteCb->onResultReceived(result.mMetadata, result.mResultExtras); 1436 } 1437 } 1438 1439 binder::Status CameraDeviceClient::checkPidStatus(const char* checkLocation) { 1440 if (mDisconnected) { 1441 return STATUS_ERROR(CameraService::ERROR_DISCONNECTED, 1442 "The camera device has been disconnected"); 1443 } 1444 status_t res = checkPid(checkLocation); 1445 return (res == OK) ? binder::Status::ok() : 1446 STATUS_ERROR(CameraService::ERROR_PERMISSION_DENIED, 1447 "Attempt to use camera from a different process than original client"); 1448 } 1449 1450 // TODO: move to Camera2ClientBase 1451 bool CameraDeviceClient::enforceRequestPermissions(CameraMetadata& metadata) { 1452 1453 const int pid = IPCThreadState::self()->getCallingPid(); 1454 const int selfPid = getpid(); 1455 camera_metadata_entry_t entry; 1456 1457 /** 1458 * Mixin default important security values 1459 * - android.led.transmit = defaulted ON 1460 */ 1461 CameraMetadata staticInfo = mDevice->info(); 1462 entry = staticInfo.find(ANDROID_LED_AVAILABLE_LEDS); 1463 for(size_t i = 0; i < entry.count; ++i) { 1464 uint8_t led = entry.data.u8[i]; 1465 1466 switch(led) { 1467 case ANDROID_LED_AVAILABLE_LEDS_TRANSMIT: { 1468 uint8_t transmitDefault = ANDROID_LED_TRANSMIT_ON; 1469 if (!metadata.exists(ANDROID_LED_TRANSMIT)) { 1470 metadata.update(ANDROID_LED_TRANSMIT, 1471 &transmitDefault, 1); 1472 } 1473 break; 1474 } 1475 } 1476 } 1477 1478 // We can do anything! 1479 if (pid == selfPid) { 1480 return true; 1481 } 1482 1483 /** 1484 * Permission check special fields in the request 1485 * - android.led.transmit = android.permission.CAMERA_DISABLE_TRANSMIT 1486 */ 1487 entry = metadata.find(ANDROID_LED_TRANSMIT); 1488 if (entry.count > 0 && entry.data.u8[0] != ANDROID_LED_TRANSMIT_ON) { 1489 String16 permissionString = 1490 String16("android.permission.CAMERA_DISABLE_TRANSMIT_LED"); 1491 if (!checkCallingPermission(permissionString)) { 1492 const int uid = IPCThreadState::self()->getCallingUid(); 1493 ALOGE("Permission Denial: " 1494 "can't disable transmit LED pid=%d, uid=%d", pid, uid); 1495 return false; 1496 } 1497 } 1498 1499 return true; 1500 } 1501 1502 status_t CameraDeviceClient::getRotationTransformLocked(int32_t* transform) { 1503 ALOGV("%s: begin", __FUNCTION__); 1504 1505 const CameraMetadata& staticInfo = mDevice->info(); 1506 return CameraUtils::getRotationTransform(staticInfo, transform); 1507 } 1508 1509 } // namespace android 1510
