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