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