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