path: root/camera/device/3.5/default/CameraDeviceSession.cpp

/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#define LOG_TAG "CamDevSession@3.5-impl"
#define ATRACE_TAG ATRACE_TAG_CAMERA
#include <android/log.h>

#include <vector>
#include <utils/Trace.h>
#include "CameraDeviceSession.h"

namespace android {
namespace hardware {
namespace camera {
namespace device {
namespace V3_5 {
namespace implementation {

CameraDeviceSession::CameraDeviceSession(
    camera3_device_t* device,
    const camera_metadata_t* deviceInfo,
    const sp<V3_2::ICameraDeviceCallback>& callback) :
        V3_4::implementation::CameraDeviceSession(device, deviceInfo, callback) {

    mCallback_3_5 = nullptr;

    auto castResult = ICameraDeviceCallback::castFrom(callback);
    if (castResult.isOk()) {
        sp<ICameraDeviceCallback> callback3_5 = castResult;
        if (callback3_5 != nullptr) {
            mCallback_3_5 = callback3_5;
        }
    }

    if (mCallback_3_5 != nullptr) {
        camera_metadata_entry bufMgrVersion = mDeviceInfo.find(
                ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION);
        if (bufMgrVersion.count > 0) {
            mSupportBufMgr = (bufMgrVersion.data.u8[0] ==
                    ANDROID_INFO_SUPPORTED_BUFFER_MANAGEMENT_VERSION_HIDL_DEVICE_3_5);
            if (mSupportBufMgr) {
                request_stream_buffers = sRequestStreamBuffers;
                return_stream_buffers = sReturnStreamBuffers;
            }
        }
    }
}

CameraDeviceSession::~CameraDeviceSession() {
}

Return<void> CameraDeviceSession::configureStreams_3_5(
        const StreamConfiguration& requestedConfiguration,
        ICameraDeviceSession::configureStreams_3_5_cb _hidl_cb)  {
    configureStreams_3_4_Impl(requestedConfiguration.v3_4, _hidl_cb,
            requestedConfiguration.streamConfigCounter, false /*useOverriddenFields*/);
    return Void();
}

Return<void> CameraDeviceSession::signalStreamFlush(
        const hidl_vec<int32_t>& streamIds, uint32_t streamConfigCounter) {
    if (mDevice->ops->signal_stream_flush == nullptr) {
        return Void();
    }

    uint32_t currentCounter = 0;
    {
        Mutex::Autolock _l(mStreamConfigCounterLock);
        currentCounter = mStreamConfigCounter;
    }

    if (streamConfigCounter < currentCounter) {
        ALOGV("%s: streamConfigCounter %d is stale (current %d), skipping signal_stream_flush call",
                __FUNCTION__, streamConfigCounter, mStreamConfigCounter);
        return Void();
    }

    std::vector<camera3_stream_t*> streams(streamIds.size());
    {
        Mutex::Autolock _l(mInflightLock);
        for (size_t i = 0; i < streamIds.size(); i++) {
            int32_t id = streamIds[i];
            if (mStreamMap.count(id) == 0) {
                ALOGE("%s: unknown streamId %d", __FUNCTION__, id);
                return Void();
            }
            streams[i] = &mStreamMap[id];
        }
    }

    mDevice->ops->signal_stream_flush(mDevice, streams.size(), streams.data());
    return Void();
}

Status CameraDeviceSession::importRequest(
        const CaptureRequest& request,
        hidl_vec<buffer_handle_t*>& allBufPtrs,
        hidl_vec<int>& allFences) {
    if (mSupportBufMgr) {
        return importRequestImpl(request, allBufPtrs, allFences, /*allowEmptyBuf*/ true);
    }
    return importRequestImpl(request, allBufPtrs, allFences, /*allowEmptyBuf*/ false);
}

void CameraDeviceSession::pushBufferId(
        const buffer_handle_t& buf, uint64_t bufferId, int streamId) {
    std::lock_guard<std::mutex> lock(mBufferIdMapLock);

    // emplace will return existing entry if there is one.
    auto pair = mBufferIdMaps.emplace(streamId, BufferIdMap{});
    BufferIdMap& bIdMap = pair.first->second;
    bIdMap[buf] = bufferId;
}

uint64_t CameraDeviceSession::popBufferId(
        const buffer_handle_t& buf, int streamId) {
    std::lock_guard<std::mutex> lock(mBufferIdMapLock);

    auto streamIt = mBufferIdMaps.find(streamId);
    if (streamIt == mBufferIdMaps.end()) {
        return BUFFER_ID_NO_BUFFER;
    }
    BufferIdMap& bIdMap = streamIt->second;
    auto it = bIdMap.find(buf);
    if (it == bIdMap.end()) {
        return BUFFER_ID_NO_BUFFER;
    }
    uint64_t bufId = it->second;
    bIdMap.erase(it);
    if (bIdMap.empty()) {
        mBufferIdMaps.erase(streamIt);
    }
    return bufId;
}

uint64_t CameraDeviceSession::getCapResultBufferId(const buffer_handle_t& buf, int streamId) {
    if (mSupportBufMgr) {
        return popBufferId(buf, streamId);
    }
    return BUFFER_ID_NO_BUFFER;
}

Camera3Stream* CameraDeviceSession::getStreamPointer(int32_t streamId) {
    Mutex::Autolock _l(mInflightLock);
    if (mStreamMap.count(streamId) == 0) {
        ALOGE("%s: unknown streamId %d", __FUNCTION__, streamId);
        return nullptr;
    }
    return &mStreamMap[streamId];
}

void CameraDeviceSession::cleanupInflightBufferFences(
        std::vector<int>& fences, std::vector<std::pair<buffer_handle_t, int>>& bufs) {
    hidl_vec<int> hFences = fences;
    cleanupInflightFences(hFences, fences.size());
    for (auto& p : bufs) {
        popBufferId(p.first, p.second);
    }
}

camera3_buffer_request_status_t CameraDeviceSession::requestStreamBuffers(
        uint32_t num_buffer_reqs,
        const camera3_buffer_request_t *buffer_reqs,
        /*out*/uint32_t *num_returned_buf_reqs,
        /*out*/camera3_stream_buffer_ret_t *returned_buf_reqs) {
    ATRACE_CALL();
    *num_returned_buf_reqs = 0;
    hidl_vec<BufferRequest> hBufReqs(num_buffer_reqs);
    for (size_t i = 0; i < num_buffer_reqs; i++) {
        hBufReqs[i].streamId =
                static_cast<Camera3Stream*>(buffer_reqs[i].stream)->mId;
        hBufReqs[i].numBuffersRequested = buffer_reqs[i].num_buffers_requested;
    }

    ATRACE_BEGIN("HIDL requestStreamBuffers");
    BufferRequestStatus status;
    hidl_vec<StreamBufferRet> bufRets;
    auto err = mCallback_3_5->requestStreamBuffers(hBufReqs,
            [&status, &bufRets]
            (BufferRequestStatus s, const hidl_vec<StreamBufferRet>& rets) {
                status = s;
                bufRets = std::move(rets);
            });
    if (!err.isOk()) {
        ALOGE("%s: Transaction error: %s", __FUNCTION__, err.description().c_str());
        return CAMERA3_BUF_REQ_FAILED_UNKNOWN;
    }
    ATRACE_END();

    switch (status) {
        case BufferRequestStatus::FAILED_CONFIGURING:
            return CAMERA3_BUF_REQ_FAILED_CONFIGURING;
        case BufferRequestStatus::FAILED_ILLEGAL_ARGUMENTS:
            return CAMERA3_BUF_REQ_FAILED_ILLEGAL_ARGUMENTS;
        default:
            break; // Other status Handled by following code
    }

    if (status != BufferRequestStatus::OK && status != BufferRequestStatus::FAILED_PARTIAL &&
            status != BufferRequestStatus::FAILED_UNKNOWN) {
        ALOGE("%s: unknown buffer request error code %d", __FUNCTION__, status);
        return CAMERA3_BUF_REQ_FAILED_UNKNOWN;
    }

    // Only OK, FAILED_PARTIAL and FAILED_UNKNOWN reaches here
    if (bufRets.size() != num_buffer_reqs) {
        ALOGE("%s: expect %d buffer requests returned, only got %zu",
                __FUNCTION__, num_buffer_reqs, bufRets.size());
        return CAMERA3_BUF_REQ_FAILED_UNKNOWN;
    }

    *num_returned_buf_reqs = num_buffer_reqs;
    for (size_t i = 0; i < num_buffer_reqs; i++) {
        // maybe we can query all streams in one call to avoid frequent locking device here?
        Camera3Stream* stream = getStreamPointer(bufRets[i].streamId);
        if (stream == nullptr) {
            ALOGE("%s: unknown streamId %d", __FUNCTION__, bufRets[i].streamId);
            return CAMERA3_BUF_REQ_FAILED_UNKNOWN;
        }
        returned_buf_reqs[i].stream = stream;
    }

    // Handle failed streams
    for (size_t i = 0; i < num_buffer_reqs; i++) {
        if (bufRets[i].val.getDiscriminator() == StreamBuffersVal::hidl_discriminator::error) {
            returned_buf_reqs[i].num_output_buffers = 0;
            switch (bufRets[i].val.error()) {
                case StreamBufferRequestError::NO_BUFFER_AVAILABLE:
                    returned_buf_reqs[i].status = CAMERA3_PS_BUF_REQ_NO_BUFFER_AVAILABLE;
                    break;
                case StreamBufferRequestError::MAX_BUFFER_EXCEEDED:
                    returned_buf_reqs[i].status = CAMERA3_PS_BUF_REQ_MAX_BUFFER_EXCEEDED;
                    break;
                case StreamBufferRequestError::STREAM_DISCONNECTED:
                    returned_buf_reqs[i].status = CAMERA3_PS_BUF_REQ_STREAM_DISCONNECTED;
                    break;
                case StreamBufferRequestError::UNKNOWN_ERROR:
                    returned_buf_reqs[i].status = CAMERA3_PS_BUF_REQ_UNKNOWN_ERROR;
                    break;
                default:
                    ALOGE("%s: Unknown StreamBufferRequestError %d",
                            __FUNCTION__, bufRets[i].val.error());
                    return CAMERA3_BUF_REQ_FAILED_UNKNOWN;
            }
        }
    }

    if (status == BufferRequestStatus::FAILED_UNKNOWN) {
        return CAMERA3_BUF_REQ_FAILED_UNKNOWN;
    }

    // Only BufferRequestStatus::OK and BufferRequestStatus::FAILED_PARTIAL reaches here
    std::vector<int> importedFences;
    std::vector<std::pair<buffer_handle_t, int>> importedBuffers;
    for (size_t i = 0; i < num_buffer_reqs; i++) {
        if (bufRets[i].val.getDiscriminator() !=
                StreamBuffersVal::hidl_discriminator::buffers) {
            continue;
        }
        int streamId = bufRets[i].streamId;
        const hidl_vec<StreamBuffer>& hBufs = bufRets[i].val.buffers();
        camera3_stream_buffer_t* outBufs = returned_buf_reqs[i].output_buffers;
        returned_buf_reqs[i].num_output_buffers = hBufs.size();
        for (size_t b = 0; b < hBufs.size(); b++) {
            const StreamBuffer& hBuf = hBufs[b];
            camera3_stream_buffer_t& outBuf = outBufs[b];
            // maybe add importBuffers API to avoid frequent locking device?
            Status s = importBuffer(streamId,
                    hBuf.bufferId, hBuf.buffer.getNativeHandle(),
                    /*out*/&(outBuf.buffer),
                    /*allowEmptyBuf*/false);
            // Buffer import should never fail - restart HAL since something is very wrong.
            LOG_ALWAYS_FATAL_IF(s != Status::OK,
                    "%s: import stream %d bufferId %" PRIu64 " failed!",
                    __FUNCTION__, streamId, hBuf.bufferId);

            pushBufferId(*(outBuf.buffer), hBuf.bufferId, streamId);
            importedBuffers.push_back(std::make_pair(*(outBuf.buffer), streamId));

            bool succ = sHandleImporter.importFence(hBuf.acquireFence, outBuf.acquire_fence);
            // Fence import should never fail - restart HAL since something is very wrong.
            LOG_ALWAYS_FATAL_IF(!succ,
                        "%s: stream %d bufferId %" PRIu64 "acquire fence is invalid",
                        __FUNCTION__, streamId, hBuf.bufferId);
            importedFences.push_back(outBuf.acquire_fence);
            outBuf.stream = returned_buf_reqs[i].stream;
            outBuf.status = CAMERA3_BUFFER_STATUS_OK;
            outBuf.release_fence = -1;
        }
        returned_buf_reqs[i].status = CAMERA3_PS_BUF_REQ_OK;
    }

    return (status == BufferRequestStatus::OK) ?
            CAMERA3_BUF_REQ_OK : CAMERA3_BUF_REQ_FAILED_PARTIAL;
}

void CameraDeviceSession::returnStreamBuffers(
        uint32_t num_buffers,
        const camera3_stream_buffer_t* const* buffers) {
    ATRACE_CALL();
    hidl_vec<StreamBuffer> hBufs(num_buffers);

    for (size_t i = 0; i < num_buffers; i++) {
        hBufs[i].streamId =
                static_cast<Camera3Stream*>(buffers[i]->stream)->mId;
        hBufs[i].buffer = nullptr; // use bufferId
        hBufs[i].bufferId = popBufferId(*(buffers[i]->buffer), hBufs[i].streamId);
        if (hBufs[i].bufferId == BUFFER_ID_NO_BUFFER) {
            ALOGE("%s: unknown buffer is returned to stream %d",
                    __FUNCTION__, hBufs[i].streamId);
        }
        // ERROR since the buffer is not for application to consume
        hBufs[i].status = BufferStatus::ERROR;
        // skip acquire fence since it's of no use to camera service
        if (buffers[i]->release_fence != -1) {
            native_handle_t* handle = native_handle_create(/*numFds*/1, /*numInts*/0);
            handle->data[0] = buffers[i]->release_fence;
            hBufs[i].releaseFence.setTo(handle, /*shouldOwn*/true);
        }
    }

    mCallback_3_5->returnStreamBuffers(hBufs);
    return;
}

/**
 * Static callback forwarding methods from HAL to instance
 */
camera3_buffer_request_status_t CameraDeviceSession::sRequestStreamBuffers(
        const struct camera3_callback_ops *cb,
        uint32_t num_buffer_reqs,
        const camera3_buffer_request_t *buffer_reqs,
        /*out*/uint32_t *num_returned_buf_reqs,
        /*out*/camera3_stream_buffer_ret_t *returned_buf_reqs) {
    CameraDeviceSession *d =
            const_cast<CameraDeviceSession*>(static_cast<const CameraDeviceSession*>(cb));

    if (num_buffer_reqs == 0 || buffer_reqs == nullptr || num_returned_buf_reqs == nullptr ||
            returned_buf_reqs == nullptr) {
        ALOGE("%s: bad argument: numBufReq %d, bufReqs %p, numRetBufReq %p, retBufReqs %p",
                __FUNCTION__, num_buffer_reqs, buffer_reqs,
                num_returned_buf_reqs, returned_buf_reqs);
        return CAMERA3_BUF_REQ_FAILED_ILLEGAL_ARGUMENTS;
    }

    return d->requestStreamBuffers(num_buffer_reqs, buffer_reqs,
            num_returned_buf_reqs, returned_buf_reqs);
}

void CameraDeviceSession::sReturnStreamBuffers(
        const struct camera3_callback_ops *cb,
        uint32_t num_buffers,
        const camera3_stream_buffer_t* const* buffers) {
    CameraDeviceSession *d =
            const_cast<CameraDeviceSession*>(static_cast<const CameraDeviceSession*>(cb));

    d->returnStreamBuffers(num_buffers, buffers);
}

Return<void> CameraDeviceSession::isReconfigurationRequired(
        const V3_2::CameraMetadata& oldSessionParams, const V3_2::CameraMetadata& newSessionParams,
        ICameraDeviceSession::isReconfigurationRequired_cb _hidl_cb) {
    if (mDevice->ops->is_reconfiguration_required != nullptr) {
        const camera_metadata_t *oldParams, *newParams;
        V3_2::implementation::convertFromHidl(oldSessionParams, &oldParams);
        V3_2::implementation::convertFromHidl(newSessionParams, &newParams);
        auto ret = mDevice->ops->is_reconfiguration_required(mDevice, oldParams, newParams);
        switch (ret) {
            case 0:
                _hidl_cb(Status::OK, true);
                break;
            case -EINVAL:
                _hidl_cb(Status::OK, false);
                break;
            case -ENOSYS:
                _hidl_cb(Status::METHOD_NOT_SUPPORTED, true);
                break;
            default:
                _hidl_cb(Status::INTERNAL_ERROR, true);
                break;
        };
    } else {
        _hidl_cb(Status::METHOD_NOT_SUPPORTED, true);
    }

    return Void();
}

} // namespace implementation
}  // namespace V3_5
}  // namespace device
}  // namespace camera
}  // namespace hardware
}  // namespace android