services/camera/libcameraservice/device3/Camera3SharedOutputStream.cpp

/*
 * Copyright (C) 2016-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 "Camera3-SharedOuStrm"
#define ATRACE_TAG ATRACE_TAG_CAMERA
//#define LOG_NDEBUG 0

#include <utils/Trace.h>

#include "Flags.h"

#include "Camera3SharedOutputStream.h"

namespace android {

namespace camera3 {

const size_t Camera3SharedOutputStream::kMaxOutputs;

Camera3SharedOutputStream::Camera3SharedOutputStream(int id,
        const std::vector<SurfaceHolder>& surfaces,
        uint32_t width, uint32_t height, int format,
        uint64_t consumerUsage, android_dataspace dataSpace,
        camera_stream_rotation_t rotation,
        nsecs_t timestampOffset, const std::string& physicalCameraId,
        const std::unordered_set<int32_t> &sensorPixelModesUsed, IPCTransport transport,
        int setId, bool useHalBufManager, int64_t dynamicProfile,
        int64_t streamUseCase, bool deviceTimeBaseIsRealtime, int timestampBase,
        int32_t colorSpace, bool useReadoutTimestamp) :
        Camera3OutputStream(id, CAMERA_STREAM_OUTPUT, width, height,
                            format, dataSpace, rotation, physicalCameraId, sensorPixelModesUsed,
                            transport, consumerUsage, timestampOffset, setId,
                            /*isMultiResolution*/false, dynamicProfile, streamUseCase,
                            deviceTimeBaseIsRealtime, timestampBase, colorSpace,
                            useReadoutTimestamp),
        mUseHalBufManager(useHalBufManager) {
    size_t consumerCount = std::min(surfaces.size(), kMaxOutputs);
    if (surfaces.size() > consumerCount) {
        ALOGE("%s: Trying to add more consumers than the maximum ", __func__);
    }
    for (size_t i = 0; i < consumerCount; i++) {
        mSurfaceUniqueIds[i] = SurfaceHolderUniqueId{surfaces[i], mNextUniqueSurfaceId++};
    }
}

Camera3SharedOutputStream::~Camera3SharedOutputStream() {
    disconnectLocked();
}

status_t Camera3SharedOutputStream::connectStreamSplitterLocked() {
    status_t res = OK;

#if USE_NEW_STREAM_SPLITTER
    mStreamSplitter = sp<Camera3StreamSplitter>::make(mUseHalBufManager);
#else
    mStreamSplitter = sp<DeprecatedCamera3StreamSplitter>::make(mUseHalBufManager);
#endif  // USE_NEW_STREAM_SPLITTER

    uint64_t usage = 0;
    getEndpointUsage(&usage);

    std::unordered_map<size_t, sp<Surface>> initialSurfaces;
    for (size_t i = 0; i < kMaxOutputs; i++) {
        if (mSurfaceUniqueIds[i].mSurfaceHolder.mSurface != nullptr) {
            initialSurfaces.emplace(i, mSurfaceUniqueIds[i].mSurfaceHolder.mSurface);
        }
    }

    res = mStreamSplitter->connect(initialSurfaces, usage, mUsage, camera_stream::max_buffers,
            getWidth(), getHeight(), getFormat(), &mConsumer, camera_stream::dynamic_range_profile);
    if (res != OK) {
        ALOGE("%s: Failed to connect to stream splitter: %s(%d)",
                __FUNCTION__, strerror(-res), res);
        return res;
    }

    return res;
}

status_t Camera3SharedOutputStream::attachBufferToSplitterLocked(
        ANativeWindowBuffer* anb,
        const std::vector<size_t>& surface_ids) {
    status_t res = OK;

    // Attach the buffer to the splitter output queues. This could block if
    // the output queue doesn't have any empty slot. So unlock during the course
    // of attachBufferToOutputs.
#if USE_NEW_STREAM_SPLITTER
    sp<Camera3StreamSplitter> splitter = mStreamSplitter;
#else
    sp<DeprecatedCamera3StreamSplitter> splitter = mStreamSplitter;
#endif  // USE_NEW_STREAM_SPLITTER
    mLock.unlock();
    res = splitter->attachBufferToOutputs(anb, surface_ids);
    mLock.lock();
    if (res != OK) {
        ALOGE("%s: Stream %d: Cannot attach stream splitter buffer to outputs: %s (%d)",
                __FUNCTION__, mId, strerror(-res), res);
        // Only transition to STATE_ABANDONED from STATE_CONFIGURED. (If it is STATE_PREPARING,
        // let prepareNextBuffer handle the error.)
        if (res == NO_INIT && mState == STATE_CONFIGURED) {
            mState = STATE_ABANDONED;
        }
    }
    return res;
}

void Camera3SharedOutputStream::setHalBufferManager(bool enabled) {
    Mutex::Autolock l(mLock);
    mUseHalBufManager = enabled;
    if (mStreamSplitter != nullptr) {
        mStreamSplitter->setHalBufferManager(enabled);
    }
}

status_t Camera3SharedOutputStream::notifyBufferReleased(ANativeWindowBuffer *anwBuffer) {
    Mutex::Autolock l(mLock);
    status_t res = OK;
    const sp<GraphicBuffer> buffer(static_cast<GraphicBuffer*>(anwBuffer));

    if (mStreamSplitter != nullptr) {
        res = mStreamSplitter->notifyBufferReleased(buffer);
    }

    return res;
}

bool Camera3SharedOutputStream::isConsumerConfigurationDeferred(size_t surface_id) const {
    Mutex::Autolock l(mLock);
    if (surface_id >= kMaxOutputs) {
        return true;
    }

    return (mSurfaceUniqueIds[surface_id].mSurfaceHolder.mSurface == nullptr);
}

status_t Camera3SharedOutputStream::setConsumers(const std::vector<SurfaceHolder>& surfaceHolders) {
    Mutex::Autolock l(mLock);
    if (surfaceHolders.size() == 0) {
        ALOGE("%s: it's illegal to set zero consumer surfaces!", __FUNCTION__);
        return INVALID_OPERATION;
    }

    status_t ret = OK;
    for (auto& surfaceHolder : surfaceHolders) {
        if (surfaceHolder.mSurface == nullptr) {
            ALOGE("%s: it's illegal to set a null consumer surface!", __FUNCTION__);
            return INVALID_OPERATION;
        }

        ssize_t id = getNextSurfaceIdLocked();
        if (id < 0) {
            ALOGE("%s: No surface ids available!", __func__);
            return NO_MEMORY;
        }

        mSurfaceUniqueIds[id] = SurfaceHolderUniqueId{surfaceHolder, mNextUniqueSurfaceId++};

        // Only call addOutput if the splitter has been connected.
        if (mStreamSplitter != nullptr) {
            ret = mStreamSplitter->addOutput(id, surfaceHolder.mSurface);
            if (ret != OK) {
                ALOGE("%s: addOutput failed with error code %d", __FUNCTION__, ret);
                return ret;

            }
        }
    }
    return ret;
}

status_t Camera3SharedOutputStream::getBufferLocked(camera_stream_buffer *buffer,
        const std::vector<size_t>& surfaceIds) {
    ANativeWindowBuffer* anb;
    int fenceFd = -1;

    status_t res;
    res = getBufferLockedCommon(&anb, &fenceFd);
    if (res != OK) {
        return res;
    }

    if (!mUseHalBufManager) {
        res = attachBufferToSplitterLocked(anb, surfaceIds);
        if (res != OK) {
            return res;
        }
    }

    /**
     * FenceFD now owned by HAL except in case of error,
     * in which case we reassign it to acquire_fence
     */
    handoutBufferLocked(*buffer, &(anb->handle), /*acquireFence*/fenceFd,
                        /*releaseFence*/-1, CAMERA_BUFFER_STATUS_OK, /*output*/true);

    return OK;
}

status_t Camera3SharedOutputStream::queueBufferToConsumer(sp<ANativeWindow>& consumer,
            ANativeWindowBuffer* buffer, int anwReleaseFence,
            const std::vector<size_t>& uniqueSurfaceIds) {
    status_t res = OK;
    if (mUseHalBufManager) {
        if (uniqueSurfaceIds.size() == 0) {
            ALOGE("%s: uniqueSurfaceIds must not be empty!", __FUNCTION__);
            return BAD_VALUE;
        }
        Mutex::Autolock l(mLock);
        std::vector<size_t> surfaceIds;
        for (const auto& uniqueId : uniqueSurfaceIds) {
            bool uniqueIdFound = false;
            for (size_t i = 0; i < kMaxOutputs; i++) {
                if (mSurfaceUniqueIds[i].mId == uniqueId) {
                    surfaceIds.push_back(i);
                    uniqueIdFound = true;
                    break;
                }
            }
            if (!uniqueIdFound) {
                ALOGV("%s: unknown unique surface ID %zu for stream %d: "
                        "output might have been removed.",
                        __FUNCTION__, uniqueId, mId);
            }
        }
        res = attachBufferToSplitterLocked(buffer, surfaceIds);
        if (res != OK) {
            return res;
        }
    }

    res = consumer->queueBuffer(consumer.get(), buffer, anwReleaseFence);

    // After queuing buffer to the internal consumer queue, check whether the buffer is
    // successfully queued to the output queues.
    if (res == OK) {
        res = mStreamSplitter->getOnFrameAvailableResult();
        if (res != OK) {
            ALOGE("%s: getOnFrameAvailable returns %d", __FUNCTION__, res);
        }
    } else {
        ALOGE("%s: queueBufer failed %d", __FUNCTION__, res);
    }

    return res;
}

status_t Camera3SharedOutputStream::configureQueueLocked() {
    status_t res;

    if ((res = Camera3IOStreamBase::configureQueueLocked()) != OK) {
        return res;
    }

    res = connectStreamSplitterLocked();
    if (res != OK) {
        ALOGE("Cannot connect to stream splitter: %s(%d)", strerror(-res), res);
        return res;
    }

    res = configureConsumerQueueLocked(false/*allowPreviewRespace*/);
    if (res != OK) {
        ALOGE("Failed to configureConsumerQueueLocked: %s(%d)", strerror(-res), res);
        return res;
    }

    // Set buffer transform for all configured surfaces
    for (const auto& surfaceUniqueId : mSurfaceUniqueIds) {
        const sp<Surface>& surface = surfaceUniqueId.mSurfaceHolder.mSurface;
        int surfaceId = surfaceUniqueId.mId;
        int32_t transform = surfaceUniqueId.mTransform;
        if (transform == -1 || surface == nullptr) {
            continue;
        }

        res = mStreamSplitter->setTransform(surfaceId, transform);
        if (res != OK) {
            ALOGE("%s: StreamSplitter failed to setTransform: %s(%d)",
                    __FUNCTION__, strerror(-res), res);
            return res;
        }
    }

    return OK;
}

status_t Camera3SharedOutputStream::disconnectLocked() {
    status_t res;
    res = Camera3OutputStream::disconnectLocked();

    if (mStreamSplitter != nullptr) {
        mStreamSplitter->disconnect();
    }

    return res;
}

status_t Camera3SharedOutputStream::getEndpointUsage(uint64_t *usage) {

    status_t res = OK;
    uint64_t u = 0;

    if (mConsumer == nullptr) {
        // Called before shared buffer queue is constructed.
        *usage = getPresetConsumerUsage();

        for (size_t id = 0; id < kMaxOutputs; id++) {
            const auto& surface = mSurfaceUniqueIds[id].mSurfaceHolder.mSurface;
            if (surface != nullptr) {
                res = getEndpointUsageForSurface(&u, surface);
                *usage |= u;
            }
        }
    } else {
        // Called after shared buffer queue is constructed.
        res = getEndpointUsageForSurface(&u, mConsumer);
        *usage |= u;
    }

    return res;
}

ssize_t Camera3SharedOutputStream::getNextSurfaceIdLocked() {
    ssize_t id = -1;
    for (size_t i = 0; i < kMaxOutputs; i++) {
        if (mSurfaceUniqueIds[i].mSurfaceHolder.mSurface == nullptr) {
            id = i;
            break;
        }
    }

    return id;
}

ssize_t Camera3SharedOutputStream::getSurfaceId(const sp<Surface> &surface) {
    Mutex::Autolock l(mLock);
    ssize_t id = -1;
    for (size_t i = 0; i < kMaxOutputs; i++) {
        if (mSurfaceUniqueIds[i].mSurfaceHolder.mSurface == surface) {
            id = i;
            break;
        }
    }

    return id;
}

status_t Camera3SharedOutputStream::getUniqueSurfaceIds(
        const std::vector<size_t>& surfaceIds,
        /*out*/std::vector<size_t>* outUniqueIds) {
    Mutex::Autolock l(mLock);
    if (outUniqueIds == nullptr || surfaceIds.size() > kMaxOutputs) {
        return BAD_VALUE;
    }

    outUniqueIds->clear();
    outUniqueIds->reserve(surfaceIds.size());

    for (const auto& surfaceId : surfaceIds) {
        if (surfaceId >= kMaxOutputs) {
            return BAD_VALUE;
        }
        outUniqueIds->push_back(mSurfaceUniqueIds[surfaceId].mId);
    }
    return OK;
}

status_t Camera3SharedOutputStream::revertPartialUpdateLocked(
        const KeyedVector<size_t, SurfaceHolder> &removedSurfaces,
        const KeyedVector<sp<Surface>, size_t> &attachedSurfaces) {
    status_t ret = OK;

    for (size_t i = 0; i < attachedSurfaces.size(); i++) {
        size_t index = attachedSurfaces.valueAt(i);
        if (mStreamSplitter != nullptr) {
            ret = mStreamSplitter->removeOutput(index);
            if (ret != OK) {
                return UNKNOWN_ERROR;
            }
        }
        mSurfaceUniqueIds[index] = SurfaceHolderUniqueId{mNextUniqueSurfaceId++};
    }

    for (size_t i = 0; i < removedSurfaces.size(); i++) {
        size_t index = removedSurfaces.keyAt(i);
        if (mStreamSplitter != nullptr) {
            ret = mStreamSplitter->addOutput(index, removedSurfaces.valueAt(i).mSurface);
            if (ret != OK) {
                return UNKNOWN_ERROR;
            }
        }
        mSurfaceUniqueIds[index] = SurfaceHolderUniqueId{removedSurfaces.valueAt(i),
                mNextUniqueSurfaceId++};
    }

    return ret;
}

status_t Camera3SharedOutputStream::updateStream(const std::vector<SurfaceHolder> &outputSurfaces,
        const std::vector<OutputStreamInfo> &outputInfo,
        const std::vector<size_t> &removedSurfaceIds,
        KeyedVector<sp<Surface>, size_t> *outputMap) {
    status_t ret = OK;
    Mutex::Autolock l(mLock);

    if ((outputMap == nullptr) || (outputInfo.size() != outputSurfaces.size()) ||
            (outputSurfaces.size() > kMaxOutputs)) {
        return BAD_VALUE;
    }

    uint64_t usage;
    getEndpointUsage(&usage);
    KeyedVector<size_t, SurfaceHolder> removedSurfaces;
    //Check whether the new surfaces are compatible.
    for (const auto &infoIt : outputInfo) {
        bool imgReaderUsage = (infoIt.consumerUsage & GRALLOC_USAGE_SW_READ_OFTEN) ? true : false;
        bool sizeMismatch = ((static_cast<uint32_t>(infoIt.width) != getWidth()) ||
                                (static_cast<uint32_t> (infoIt.height) != getHeight())) ?
                                true : false;
        bool dynamicRangeMismatch = dynamic_range_profile != infoIt.dynamicRangeProfile;
        if ((imgReaderUsage && sizeMismatch) || dynamicRangeMismatch ||
                (infoIt.format != getOriginalFormat() && infoIt.format != getFormat()) ||
                (infoIt.dataSpace != getDataSpace() &&
                 infoIt.dataSpace != getOriginalDataSpace())) {
            ALOGE("%s: Shared surface parameters format: 0x%x dataSpace: 0x%x dynamic range 0x%"
                    PRIx64 " don't match source stream format: 0x%x  dataSpace: 0x%x dynamic"
                    " range 0x%" PRIx64 , __FUNCTION__, infoIt.format, infoIt.dataSpace,
                    infoIt.dynamicRangeProfile, getFormat(), getDataSpace(), dynamic_range_profile);
            return BAD_VALUE;
        }
    }

    //First remove all absent outputs
    for (const auto &it : removedSurfaceIds) {
        if (mStreamSplitter != nullptr) {
            ret = mStreamSplitter->removeOutput(it);
            if (ret != OK) {
                ALOGE("%s: failed with error code %d", __FUNCTION__, ret);
                status_t res = revertPartialUpdateLocked(removedSurfaces, *outputMap);
                if (res != OK) {
                    return res;
                }
                return ret;

            }
        }
        removedSurfaces.add(it, mSurfaceUniqueIds[it].mSurfaceHolder);
        mSurfaceUniqueIds[it] = SurfaceHolderUniqueId{mNextUniqueSurfaceId++};
    }

    //Next add the new outputs
    for (const auto &it : outputSurfaces) {
        ssize_t surfaceId = getNextSurfaceIdLocked();
        if (surfaceId < 0) {
            ALOGE("%s: No more available output slots!", __FUNCTION__);
            status_t res = revertPartialUpdateLocked(removedSurfaces, *outputMap);
            if (res != OK) {
                return res;
            }
            return NO_MEMORY;
        }
        if (mStreamSplitter != nullptr) {
            ret = mStreamSplitter->addOutput(surfaceId, it.mSurface);
            if (ret != OK) {
                ALOGE("%s: failed with error code %d", __FUNCTION__, ret);
                status_t res = revertPartialUpdateLocked(removedSurfaces, *outputMap);
                if (res != OK) {
                    return res;
                }
                return ret;
            }
        }
        mSurfaceUniqueIds[surfaceId] = SurfaceHolderUniqueId{it, mNextUniqueSurfaceId++};
        outputMap->add(it.mSurface, surfaceId);
    }

    return ret;
}

status_t Camera3SharedOutputStream::setTransform(
        int transform, bool mayChangeMirror, int surfaceId) {
    ATRACE_CALL();
    Mutex::Autolock l(mLock);

    status_t res = OK;

    if (surfaceId < 0 || (size_t)surfaceId >= mSurfaceUniqueIds.size()) {
        ALOGE("%s: Invalid surfaceId %d", __FUNCTION__, surfaceId);
        return BAD_VALUE;
    }
    if (transform == -1) return res;

    if (mState == STATE_ERROR) {
        ALOGE("%s: Stream in error state", __FUNCTION__);
        return INVALID_OPERATION;
    }

    auto& surfaceHolderForId = mSurfaceUniqueIds[surfaceId];
    if (surfaceHolderForId.mSurfaceHolder.mMirrorMode != OutputConfiguration::MIRROR_MODE_AUTO &&
            mayChangeMirror) {
        // If the mirroring mode is not AUTO, do not allow transform update
        // which may change mirror.
        return OK;
    }

    surfaceHolderForId.mTransform = transform;
    if (mState == STATE_CONFIGURED) {
        sp<Surface> surface = surfaceHolderForId.mSurfaceHolder.mSurface;
        if (surface != nullptr) {
            res = mStreamSplitter->setTransform(surfaceId, transform);
            if (res != OK) {
                ALOGE("%s: StreamSplitter fails to setTransform: %s(%d)",
                        __FUNCTION__, strerror(-res), res);
                return res;
            }
        }
    }
    return res;
}

} // namespace camera3

} // namespace android