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

Commit c45bc939 authored by Carlos Martinez Romero's avatar Carlos Martinez Romero
Browse files

Use view::Surface instead of IGBPs in OutputConfiguration 

We are currently limiting the use of IGBPs outside of libgui to allow for
further development of bufferqueues without external breakages. More
information at go/warren-buffers.

BYPASS_IGBP_IGBC_API_REASON: this CL is part of the migration.
Bug: 342197849
Test: atest android.hardware.cts.CameraTest
Flag: com.android.graphics.libgui.flags.wb_libcameraservice

Change-Id: I308eac2a11aceff7d598f3b14cfc87dfe4a1a767
parent 91ece572

camera/camera2/CaptureRequest.cpp

+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);

camera/camera2/OutputConfiguration.cpp

+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];

        }

    }

camera/include/camera/android/hardware/ICamera.h

+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

     */

camera/include/camera/camera2/OutputConfiguration.h

+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;

camera/ndk/impl/ACameraDevice.cpp

+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);