Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e710c2ef authored by Android Build Coastguard Worker's avatar Android Build Coastguard Worker
Browse files

Snap for 12702769 from 2ebc7558 to 25Q1-release

Change-Id: Ic714271cb74ee697ee4ec86d6ad7994897f692c7
parents 00ec9018 2ebc7558
Loading
Loading
Loading
Loading
+9 −1
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@
#include <camera/StringUtils.h>

#include <binder/Parcel.h>
#include <gui/Flags.h>  // remove with WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
#include <gui/Surface.h>
#include <gui/view/Surface.h>

@@ -112,11 +113,14 @@ status_t CaptureRequest::readFromParcel(const android::Parcel* parcel) {
            return err;
        }

#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
        sp<Surface> surface = surfaceShim.toSurface();
#else
        sp<Surface> surface;
        if (surfaceShim.graphicBufferProducer != NULL) {
            surface = new Surface(surfaceShim.graphicBufferProducer);
        }

#endif
        mSurfaceList.push_back(surface);
    }

@@ -206,9 +210,13 @@ status_t CaptureRequest::writeToParcel(android::Parcel* parcel) const {
            parcel->writeString16(String16("android.view.Surface"));

            // Surface.writeToParcel
#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
            view::Surface surfaceShim = view::Surface::fromSurface(mSurfaceList[i]);
#else
            view::Surface surfaceShim;
            surfaceShim.name = String16("unknown_name");
            surfaceShim.graphicBufferProducer = mSurfaceList[i]->getIGraphicBufferProducer();
#endif
            if ((err = surfaceShim.writeToParcel(parcel)) != OK) {
                ALOGE("%s: Failed to write output target Surface %d to parcel: %s (%d)",
                        __FUNCTION__, i, strerror(-err), err);
+34 −35
Original line number Diff line number Diff line
@@ -37,9 +37,8 @@ const int OutputConfiguration::INVALID_ROTATION = -1;
const int OutputConfiguration::ROTATION_0 = 0;
const int OutputConfiguration::INVALID_SET_ID = -1;

const std::vector<sp<IGraphicBufferProducer>>&
        OutputConfiguration::getGraphicBufferProducers() const {
    return mGbps;
const std::vector<ParcelableSurfaceType>& OutputConfiguration::getSurfaces() const {
    return mSurfaces;
}

int OutputConfiguration::getRotation() const {
@@ -102,24 +101,23 @@ int OutputConfiguration::getMirrorMode() const {
    return mMirrorMode;
}

int OutputConfiguration::getMirrorMode(sp<IGraphicBufferProducer> surface) const {
int OutputConfiguration::getMirrorMode(ParcelableSurfaceType surface) const {
    if (!flags::mirror_mode_shared_surfaces()) {
        return mMirrorMode;
    }

    if (mGbps.size() != mMirrorModeForProducers.size()) {
        ALOGE("%s: mGbps size doesn't match mMirrorModeForProducers: %zu vs %zu",
                __FUNCTION__, mGbps.size(), mMirrorModeForProducers.size());
    if (mSurfaces.size() != mMirrorModeForProducers.size()) {
        ALOGE("%s: mSurfaces size doesn't match mMirrorModeForProducers: %zu vs %zu",
                __FUNCTION__, mSurfaces.size(), mMirrorModeForProducers.size());
        return mMirrorMode;
    }

    // Use per-producer mirror mode if available.
    for (size_t i = 0; i < mGbps.size(); i++) {
        if (mGbps[i] == surface) {
    for (size_t i = 0; i < mSurfaces.size(); i++) {
        if (mSurfaces[i] == surface) {
            return mMirrorModeForProducers[i];
        }
    }

    // For surface that doesn't belong to this output configuration, use
    // mMirrorMode as default.
    ALOGW("%s: Surface doesn't belong to this OutputConfiguration!", __FUNCTION__);
@@ -146,7 +144,7 @@ bool OutputConfiguration::isComplete() const {
    return !((mSurfaceType == SURFACE_TYPE_MEDIA_RECORDER ||
              mSurfaceType == SURFACE_TYPE_MEDIA_CODEC ||
              mSurfaceType == SURFACE_TYPE_IMAGE_READER) &&
             mGbps.empty());
             mSurfaces.empty());
}

OutputConfiguration::OutputConfiguration() :
@@ -348,7 +346,7 @@ status_t OutputConfiguration::readFromParcel(const android::Parcel* parcel) {
        ALOGV("%s: OutputConfiguration: %p, name %s", __FUNCTION__,
                surface.graphicBufferProducer.get(),
                toString8(surface.name).c_str());
        mGbps.push_back(surface.graphicBufferProducer);
        mSurfaces.push_back(flagtools::toParcelableSurfaceType(surface));
    }

    mSensorPixelModesUsed = std::move(sensorPixelModesUsed);
@@ -369,10 +367,10 @@ status_t OutputConfiguration::readFromParcel(const android::Parcel* parcel) {
    return err;
}

OutputConfiguration::OutputConfiguration(sp<IGraphicBufferProducer>& gbp, int rotation,
OutputConfiguration::OutputConfiguration(ParcelableSurfaceType& surface, int rotation,
        const std::string& physicalId,
        int surfaceSetID, bool isShared) {
    mGbps.push_back(gbp);
    mSurfaces.push_back(surface);
    mRotation = rotation;
    mSurfaceSetID = surfaceSetID;
    mIsDeferred = false;
@@ -392,17 +390,17 @@ OutputConfiguration::OutputConfiguration(sp<IGraphicBufferProducer>& gbp, int ro
}

OutputConfiguration::OutputConfiguration(
        const std::vector<sp<IGraphicBufferProducer>>& gbps,
        const std::vector<ParcelableSurfaceType>& surfaces,
    int rotation, const std::string& physicalCameraId, int surfaceSetID,  int surfaceType,
    int width, int height, bool isShared)
  : mGbps(gbps), mRotation(rotation), mSurfaceSetID(surfaceSetID), mSurfaceType(surfaceType),
    mWidth(width), mHeight(height), mIsDeferred(false), mIsShared(isShared),
    mPhysicalCameraId(physicalCameraId), mIsMultiResolution(false),
  : mSurfaces(surfaces), mRotation(rotation), mSurfaceSetID(surfaceSetID),
    mSurfaceType(surfaceType), mWidth(width), mHeight(height), mIsDeferred(false),
    mIsShared(isShared), mPhysicalCameraId(physicalCameraId), mIsMultiResolution(false),
    mDynamicRangeProfile(ANDROID_REQUEST_AVAILABLE_DYNAMIC_RANGE_PROFILES_MAP_STANDARD),
    mColorSpace(ANDROID_REQUEST_AVAILABLE_COLOR_SPACE_PROFILES_MAP_UNSPECIFIED),
    mStreamUseCase(ANDROID_SCALER_AVAILABLE_STREAM_USE_CASES_DEFAULT),
    mTimestampBase(TIMESTAMP_BASE_DEFAULT),
    mMirrorMode(MIRROR_MODE_AUTO), mMirrorModeForProducers(gbps.size(), mMirrorMode),
    mMirrorMode(MIRROR_MODE_AUTO), mMirrorModeForProducers(surfaces.size(), mMirrorMode),
    mUseReadoutTimestamp(false), mFormat(HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED),
    mDataspace(0), mUsage(0) { }

@@ -432,14 +430,18 @@ status_t OutputConfiguration::writeToParcel(android::Parcel* parcel) const {
    err = parcel->writeInt32(mIsShared ? 1 : 0);
    if (err != OK) return err;

#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
    err = parcel->writeParcelableVector(mSurfaces);
#else
    std::vector<view::Surface> surfaceShims;
    for (auto& gbp : mGbps) {
    for (auto& gbp : mSurfaces) {
        view::Surface surfaceShim;
        surfaceShim.name = String16("unknown_name"); // name of surface
        surfaceShim.graphicBufferProducer = gbp;
        surfaceShims.push_back(surfaceShim);
    }
    err = parcel->writeParcelableVector(surfaceShims);
#endif
    if (err != OK) return err;

    String16 physicalCameraId = toString16(mPhysicalCameraId);
@@ -513,10 +515,9 @@ static bool simpleVectorsLessThan(T first, T second) {
    return false;
}

bool OutputConfiguration::gbpsEqual(const OutputConfiguration& other) const {
    const std::vector<sp<IGraphicBufferProducer> >& otherGbps =
            other.getGraphicBufferProducers();
    return simpleVectorsEqual(otherGbps, mGbps);
bool OutputConfiguration::surfacesEqual(const OutputConfiguration& other) const {
    const std::vector<ParcelableSurfaceType>& otherSurfaces = other.getSurfaces();
    return simpleVectorsEqual(otherSurfaces, mSurfaces);
}

bool OutputConfiguration::sensorPixelModesUsedEqual(const OutputConfiguration& other) const {
@@ -527,7 +528,6 @@ bool OutputConfiguration::sensorPixelModesUsedEqual(const OutputConfiguration& o
bool OutputConfiguration::mirrorModesEqual(const OutputConfiguration& other) const {
    const std::vector<int>& otherMirrorModes = other.getMirrorModes();
    return simpleVectorsEqual(otherMirrorModes, mMirrorModeForProducers);

}

bool OutputConfiguration::sensorPixelModesUsedLessThan(const OutputConfiguration& other) const {
@@ -540,17 +540,16 @@ bool OutputConfiguration::mirrorModesLessThan(const OutputConfiguration& other)
    return simpleVectorsLessThan(mMirrorModeForProducers, otherMirrorModes);
}

bool OutputConfiguration::gbpsLessThan(const OutputConfiguration& other) const {
    const std::vector<sp<IGraphicBufferProducer> >& otherGbps =
            other.getGraphicBufferProducers();
bool OutputConfiguration::surfacesLessThan(const OutputConfiguration& other) const {
    const std::vector<ParcelableSurfaceType>& otherSurfaces = other.getSurfaces();

    if (mGbps.size() !=  otherGbps.size()) {
        return mGbps.size() < otherGbps.size();
    if (mSurfaces.size() != otherSurfaces.size()) {
        return mSurfaces.size() < otherSurfaces.size();
    }

    for (size_t i = 0; i < mGbps.size(); i++) {
        if (mGbps[i] != otherGbps[i]) {
            return mGbps[i] < otherGbps[i];
    for (size_t i = 0; i < mSurfaces.size(); i++) {
        if (mSurfaces[i] != otherSurfaces[i]) {
            return mSurfaces[i] < otherSurfaces[i];
        }
    }

+7 −2
Original line number Diff line number Diff line
@@ -34,8 +34,13 @@ namespace hardware {

class ICameraClient;

class ICamera: public android::IInterface
{
#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
typedef Surface ProducerType;
#else
typedef IGraphicBufferProducer ProducerType;
#endif

class ICamera : public android::IInterface {
    /**
     * Keep up-to-date with ICamera.aidl in frameworks/base
     */
+18 −10
Original line number Diff line number Diff line
@@ -19,7 +19,12 @@

#include <string>

#include <gui/Flags.h>  // remove with WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
#if WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
#include <gui/view/Surface.h>
#else
#include <gui/IGraphicBufferProducer.h>
#endif
#include <binder/Parcelable.h>

namespace android {
@@ -59,7 +64,7 @@ public:
        MIRROR_MODE_V = 3,
    };

    const std::vector<sp<IGraphicBufferProducer>>& getGraphicBufferProducers() const;
    const std::vector<ParcelableSurfaceType>& getSurfaces() const;
    int                        getRotation() const;
    int                        getSurfaceSetID() const;
    int                        getSurfaceType() const;
@@ -73,7 +78,7 @@ public:
    bool                       isMultiResolution() const;
    int64_t                    getStreamUseCase() const;
    int                        getTimestampBase() const;
    int                        getMirrorMode(sp<IGraphicBufferProducer> surface) const;
    int                        getMirrorMode(ParcelableSurfaceType surface) const;
    int                        getMirrorMode() const;
    bool                       useReadoutTimestamp() const;
    int                        getFormat() const;
@@ -100,11 +105,11 @@ public:
    // getSurfaceSetID will be INVALID_SET_ID if error occurred
    OutputConfiguration(const android::Parcel& parcel);

    OutputConfiguration(sp<IGraphicBufferProducer>& gbp, int rotation,
    OutputConfiguration(ParcelableSurfaceType& surface, int rotation,
            const std::string& physicalCameraId,
            int surfaceSetID = INVALID_SET_ID, bool isShared = false);

    OutputConfiguration(const std::vector<sp<IGraphicBufferProducer>>& gbps,
    OutputConfiguration(const std::vector<ParcelableSurfaceType>& surfaces,
                        int rotation, const std::string& physicalCameraId,
                        int surfaceSetID = INVALID_SET_ID,
                        int surfaceType = SURFACE_TYPE_UNKNOWN, int width = 0,
@@ -121,7 +126,7 @@ public:
                mHeight == other.mHeight &&
                mIsDeferred == other.mIsDeferred &&
                mIsShared == other.mIsShared &&
                gbpsEqual(other) &&
                surfacesEqual(other) &&
                mPhysicalCameraId == other.mPhysicalCameraId &&
                mIsMultiResolution == other.mIsMultiResolution &&
                sensorPixelModesUsedEqual(other) &&
@@ -201,18 +206,21 @@ public:
        if (mUsage != other.mUsage) {
            return mUsage < other.mUsage;
        }
        return gbpsLessThan(other);
        return surfacesLessThan(other);
    }

    bool operator > (const OutputConfiguration& other) const {
        return (*this != other && !(*this < other));
    }

    bool gbpsEqual(const OutputConfiguration& other) const;
    bool surfacesEqual(const OutputConfiguration& other) const;
    bool sensorPixelModesUsedEqual(const OutputConfiguration& other) const;
    bool sensorPixelModesUsedLessThan(const OutputConfiguration& other) const;
    bool gbpsLessThan(const OutputConfiguration& other) const;
    void addGraphicProducer(sp<IGraphicBufferProducer> gbp) {mGbps.push_back(gbp);}
    bool surfacesLessThan(const OutputConfiguration& other) const;
    void addSurface(ParcelableSurfaceType surface) { mSurfaces.push_back(surface); }
#if not WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
    void addGraphicProducer(sp<IGraphicBufferProducer> gbp) {addSurface(gbp);}
#endif
    bool mirrorModesEqual(const OutputConfiguration& other) const;
    bool mirrorModesLessThan(const OutputConfiguration& other) const;
    const std::vector<int32_t>& getMirrorModes() const {return mMirrorModeForProducers;}
@@ -239,7 +247,7 @@ public:
    }

private:
    std::vector<sp<IGraphicBufferProducer>> mGbps;
    std::vector<ParcelableSurfaceType>  mSurfaces;
    int                        mRotation;
    int                        mSurfaceSetID;
    int                        mSurfaceType;
+33 −26
Original line number Diff line number Diff line
@@ -231,25 +231,27 @@ camera_status_t CameraDevice::isSessionConfigurationSupported(
    SessionConfiguration sessionConfiguration(0 /*inputWidth*/, 0 /*inputHeight*/,
            -1 /*inputFormat*/, CAMERA3_STREAM_CONFIGURATION_NORMAL_MODE);
    for (const auto& output : sessionOutputContainer->mOutputs) {
        sp<IGraphicBufferProducer> iGBP(nullptr);
        ret = getIGBPfromAnw(output.mWindow, iGBP);
        sp<SurfaceType> surface(nullptr);
        ret = getSurfacefromAnw(output.mWindow, surface);
        if (ret != ACAMERA_OK) {
            ALOGE("Camera device %s failed to extract graphic producer from native window",
                    getId());
            return ret;
        }

        OutputConfiguration outConfig(iGBP, output.mRotation, output.mPhysicalCameraId,
        ParcelableSurfaceType pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
        OutputConfiguration outConfig(pSurface, output.mRotation, output.mPhysicalCameraId,
                OutputConfiguration::INVALID_SET_ID, true);

        for (auto& anw : output.mSharedWindows) {
            ret = getIGBPfromAnw(anw, iGBP);
            ret = getSurfacefromAnw(anw, surface);
            if (ret != ACAMERA_OK) {
                ALOGE("Camera device %s failed to extract graphic producer from native window",
                        getId());
                return ret;
            }
            outConfig.addGraphicProducer(iGBP);
            pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
            outConfig.addSurface(pSurface);
        }

        sessionConfiguration.addOutputConfiguration(outConfig);
@@ -295,25 +297,27 @@ camera_status_t CameraDevice::updateOutputConfigurationLocked(ACaptureSessionOut
        return ACAMERA_ERROR_INVALID_PARAMETER;
    }

    sp<IGraphicBufferProducer> iGBP(nullptr);
    ret = getIGBPfromAnw(output->mWindow, iGBP);
    sp<SurfaceType> surface(nullptr);
    ret = getSurfacefromAnw(output->mWindow, surface);
    if (ret != ACAMERA_OK) {
        ALOGE("Camera device %s failed to extract graphic producer from native window",
                getId());
        return ret;
    }

    OutputConfiguration outConfig(iGBP, output->mRotation, output->mPhysicalCameraId,
    ParcelableSurfaceType pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
    OutputConfiguration outConfig(pSurface, output->mRotation, output->mPhysicalCameraId,
                                  OutputConfiguration::INVALID_SET_ID, true);

    for (auto& anw : output->mSharedWindows) {
        ret = getIGBPfromAnw(anw, iGBP);
        ret = getSurfacefromAnw(anw, surface);
        if (ret != ACAMERA_OK) {
            ALOGE("Camera device %s failed to extract graphic producer from native window",
                    getId());
            return ret;
        }
        outConfig.addGraphicProducer(iGBP);
        pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
        outConfig.addSurface(pSurface);
    }

    auto remoteRet = mRemote->updateOutputConfiguration(streamId, outConfig);
@@ -427,9 +431,9 @@ CameraDevice::allocateCaptureRequest(
        for (const auto& kvPair : mConfiguredOutputs) {
            int streamId = kvPair.first;
            const OutputConfiguration& outConfig = kvPair.second.second;
            const auto& gbps = outConfig.getGraphicBufferProducers();
            for (int surfaceId = 0; surfaceId < (int) gbps.size(); surfaceId++) {
                if (gbps[surfaceId] == surface->getIGraphicBufferProducer()) {
            const auto& surfaces = outConfig.getSurfaces();
            for (int surfaceId = 0; surfaceId < (int)surfaces.size(); surfaceId++) {
                if (surfaces[surfaceId] == flagtools::surfaceToSurfaceType(surface)) {
                    found = true;
                    req->mStreamIdxList.push_back(streamId);
                    req->mSurfaceIdxList.push_back(surfaceId);
@@ -634,16 +638,13 @@ CameraDevice::waitUntilIdleLocked() {
    return ACAMERA_OK;
}

camera_status_t
CameraDevice::getIGBPfromAnw(
        ANativeWindow* anw,
        sp<IGraphicBufferProducer>& out) {
camera_status_t CameraDevice::getSurfacefromAnw(ANativeWindow* anw, sp<SurfaceType>& out) {
    sp<Surface> surface;
    camera_status_t ret = getSurfaceFromANativeWindow(anw, surface);
    if (ret != ACAMERA_OK) {
        return ret;
    }
    out = surface->getIGraphicBufferProducer();
    out = flagtools::surfaceToSurfaceType(surface);
    return ACAMERA_OK;
}

@@ -681,13 +682,15 @@ CameraDevice::configureStreamsLocked(const ACaptureSessionOutputContainer* outpu
    std::set<std::pair<ANativeWindow*, OutputConfiguration>> outputSet;
    for (const auto& outConfig : outputs->mOutputs) {
        ANativeWindow* anw = outConfig.mWindow;
        sp<IGraphicBufferProducer> iGBP(nullptr);
        ret = getIGBPfromAnw(anw, iGBP);
        sp<SurfaceType> surface(nullptr);
        ret = getSurfacefromAnw(anw, surface);
        if (ret != ACAMERA_OK) {
            return ret;
        }
        ParcelableSurfaceType pSurface = flagtools::convertSurfaceTypeToParcelable(surface);
        outputSet.insert(std::make_pair(
                anw, OutputConfiguration(iGBP, outConfig.mRotation, outConfig.mPhysicalCameraId,
                anw,
                OutputConfiguration(pSurface, outConfig.mRotation, outConfig.mPhysicalCameraId,
                                    OutputConfiguration::INVALID_SET_ID, outConfig.mIsShared)));
    }
    auto addSet = outputSet;
@@ -885,10 +888,14 @@ CameraDevice::onCaptureErrorLocked(
            return;
        }

        const auto& gbps = outputPairIt->second.second.getGraphicBufferProducers();
        for (const auto& outGbp : gbps) {
        const auto& outSurfaces = outputPairIt->second.second.getSurfaces();
        for (const auto& outSurface : outSurfaces) {
            for (const auto& surface : request->mSurfaceList) {
                if (surface->getIGraphicBufferProducer() == outGbp) {
                if ( outSurface == surface
#if not WB_LIBCAMERASERVICE_WITH_DEPENDENCIES
                                ->getIGraphicBufferProducer()
#endif
                                            ) {
                    ANativeWindow* anw = static_cast<ANativeWindow*>(surface.get());
                    ALOGV("Camera %s Lost output buffer for ANW %p frame %" PRId64,
                            getId(), anw, frameNumber);
Loading