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

Commit 70a46f3c authored by Vishnu Nair's avatar Vishnu Nair Committed by Automerger Merge Worker
Browse files

Merge "Fix crop scaling with BSL" into sc-dev am: 3cf10956 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/14236190

Change-Id: I58bfe8a0664d44f07d8bd3d8a71d9966297d3b22
parents 8c674d46 3cf10956

libs/gui/BLASTBufferQueue.cpp

+11 −7
Original line number Diff line number Diff line
@@ -186,6 +186,7 @@ BLASTBufferQueue::~BLASTBufferQueue() { 
void BLASTBufferQueue::update(const sp<SurfaceControl>& surface, uint32_t width, uint32_t height,

                              int32_t format) {

    std::unique_lock _lock{mMutex};

    BQA_LOGV("update width=%d height=%d format=%d", width, height, format);

    if (mFormat != format) {

        mFormat = format;

        mBufferItemConsumer->setDefaultBufferFormat(convertBufferFormat(format));
@@ -397,10 +398,11 @@ void BLASTBufferQueue::processNextBufferLocked(bool useNextTransaction) { 
    // Ensure BLASTBufferQueue stays alive until we receive the transaction complete callback.

    incStrong((void*)transactionCallbackThunk);



    Rect crop = computeCrop(bufferItem);

    mLastAcquiredFrameNumber = bufferItem.mFrameNumber;

    mLastBufferInfo.update(true /* hasBuffer */, bufferItem.mGraphicBuffer->getWidth(),

                           bufferItem.mGraphicBuffer->getHeight(), bufferItem.mTransform,

                           bufferItem.mScalingMode);

                           bufferItem.mScalingMode, crop);



    auto releaseBufferCallback =

            std::bind(releaseBufferCallbackThunk, wp<BLASTBufferQueue>(this) /* callbackContext */,
@@ -415,7 +417,7 @@ void BLASTBufferQueue::processNextBufferLocked(bool useNextTransaction) { 
    mSurfaceControlsWithPendingCallback.push(mSurfaceControl);



    setMatrix(t, mLastBufferInfo);

    t->setCrop(mSurfaceControl, computeCrop(bufferItem));

    t->setCrop(mSurfaceControl, crop);

    t->setTransform(mSurfaceControl, bufferItem.mTransform);

    t->setTransformToDisplayInverse(mSurfaceControl, bufferItem.mTransformToDisplayInverse);

    if (!bufferItem.mIsAutoTimestamp) {
@@ -543,13 +545,15 @@ bool BLASTBufferQueue::rejectBuffer(const BufferItem& item) { 


void BLASTBufferQueue::setMatrix(SurfaceComposerClient::Transaction* t,

                                 const BufferInfo& bufferInfo) {

    uint32_t bufWidth = bufferInfo.width;

    uint32_t bufHeight = bufferInfo.height;

    uint32_t bufWidth = bufferInfo.crop.getWidth();

    uint32_t bufHeight = bufferInfo.crop.getHeight();



    float dsdx = mSize.width / static_cast<float>(bufWidth);

    float dsdy = mSize.height / static_cast<float>(bufHeight);

    float sx = mSize.width / static_cast<float>(bufWidth);

    float sy = mSize.height / static_cast<float>(bufHeight);



    t->setMatrix(mSurfaceControl, dsdx, 0, 0, dsdy);

    t->setMatrix(mSurfaceControl, sx, 0, 0, sy);

    // Update position based on crop.

    t->setPosition(mSurfaceControl, bufferInfo.crop.left * sx * -1, bufferInfo.crop.top * sy * -1);

}



void BLASTBufferQueue::setTransactionCompleteCallback(

libs/gui/include/gui/BLASTBufferQueue.h

+7 −1
Original line number Diff line number Diff line
@@ -151,14 +151,20 @@ private: 
        // we get the next buffer. This will support scenarios where the layer can change sizes

        // and the buffer will scale to fit the new size.

        uint32_t scalingMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;

        Rect crop;



        void update(bool hasBuffer, uint32_t width, uint32_t height, uint32_t transform,

                    uint32_t scalingMode) {

                    uint32_t scalingMode, const Rect& crop) {

            this->hasBuffer = hasBuffer;

            this->width = width;

            this->height = height;

            this->transform = transform;

            this->scalingMode = scalingMode;

            if (!crop.isEmpty()) {

                this->crop = crop;

            } else {

                this->crop = Rect(width, height);

            }

        }

    };

libs/gui/tests/BLASTBufferQueue_test.cpp

+138 −8
Original line number Diff line number Diff line
@@ -522,16 +522,146 @@ TEST_F(BLASTBufferQueueTest, SetCrop_ScalingModeScaleCrop) { 
    adapter.waitForCallbacks();

    // capture screen and verify that it is red

    ASSERT_EQ(NO_ERROR, captureDisplay(mCaptureArgs, mCaptureResults));

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(r, g, b,

                                               {10, 10, (int32_t)bufferSideLength - 10,

                                                (int32_t)bufferSideLength - 10}));

    ASSERT_NO_FATAL_FAILURE(

            checkScreenCapture(0, 0, 0,

                               {0, 0, (int32_t)bufferSideLength, (int32_t)bufferSideLength},

                               /*border*/ 0, /*outsideRegion*/ true));

}



    Rect bounds;

    bounds.left = finalCropSideLength / 2;

    bounds.top = 0;

    bounds.right = bounds.left + finalCropSideLength;

    bounds.bottom = finalCropSideLength;

TEST_F(BLASTBufferQueueTest, ScaleCroppedBufferToBufferSize) {

    // add black background

    auto bg = mClient->createSurface(String8("BGTest"), 0, 0, PIXEL_FORMAT_RGBA_8888,

                                     ISurfaceComposerClient::eFXSurfaceEffect);

    ASSERT_NE(nullptr, bg.get());

    Transaction t;

    t.setLayerStack(bg, 0)

            .setCrop(bg, Rect(0, 0, mDisplayWidth, mDisplayHeight))

            .setColor(bg, half3{0, 0, 0})

            .setLayer(bg, 0)

            .apply();



    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(r, g, b, bounds));

    ASSERT_NO_FATAL_FAILURE(

            checkScreenCapture(0, 0, 0, bounds, /*border*/ 0, /*outsideRegion*/ true));

    Rect windowSize(1000, 1000);

    Rect bufferSize(windowSize);

    Rect bufferCrop(200, 200, 700, 700);



    BLASTBufferQueueHelper adapter(mSurfaceControl, windowSize.getWidth(), windowSize.getHeight());

    sp<IGraphicBufferProducer> igbProducer;

    setUpProducer(adapter, igbProducer);

    int slot;

    sp<Fence> fence;

    sp<GraphicBuffer> buf;

    auto ret = igbProducer->dequeueBuffer(&slot, &fence, bufferSize.getWidth(),

                                          bufferSize.getHeight(), PIXEL_FORMAT_RGBA_8888,

                                          GRALLOC_USAGE_SW_WRITE_OFTEN, nullptr, nullptr);

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, ret);

    ASSERT_EQ(OK, igbProducer->requestBuffer(slot, &buf));



    uint32_t* bufData;

    buf->lock(static_cast<uint32_t>(GraphicBuffer::USAGE_SW_WRITE_OFTEN),

              reinterpret_cast<void**>(&bufData));

    // fill buffer with grey

    fillBuffer(bufData, bufferSize, buf->getStride(), 127, 127, 127);



    // fill crop area with different colors so we can verify the cropped region has been scaled

    // correctly.

    fillBuffer(bufData, Rect(200, 200, 450, 450), buf->getStride(), /* rgb */ 255, 0, 0);

    fillBuffer(bufData, Rect(200, 451, 450, 700), buf->getStride(), /* rgb */ 0, 255, 0);

    fillBuffer(bufData, Rect(451, 200, 700, 450), buf->getStride(), /* rgb */ 0, 0, 255);

    fillBuffer(bufData, Rect(451, 451, 700, 700), buf->getStride(), /* rgb */ 255, 0, 0);

    buf->unlock();



    IGraphicBufferProducer::QueueBufferOutput qbOutput;

    IGraphicBufferProducer::QueueBufferInput input(systemTime(), true /* autotimestamp */,

                                                   HAL_DATASPACE_UNKNOWN,

                                                   bufferCrop /* Rect::INVALID_RECT */,

                                                   NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW, 0,

                                                   Fence::NO_FENCE);

    igbProducer->queueBuffer(slot, input, &qbOutput);

    ASSERT_NE(ui::Transform::ROT_INVALID, qbOutput.transformHint);



    adapter.waitForCallbacks();



    ASSERT_EQ(NO_ERROR, captureDisplay(mCaptureArgs, mCaptureResults));



    // Verify cropped region is scaled correctly.

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(255, 0, 0, {10, 10, 490, 490}));

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(0, 255, 0, {10, 510, 490, 990}));

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(0, 0, 255, {510, 10, 990, 490}));

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(255, 0, 0, {510, 510, 990, 990}));

    // Verify outside region is black.

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(0, 0, 0,

                                               {0, 0, (int32_t)windowSize.getWidth(),

                                                (int32_t)windowSize.getHeight()},

                                               /*border*/ 0, /*outsideRegion*/ true));

}



TEST_F(BLASTBufferQueueTest, ScaleCroppedBufferToWindowSize) {

    // add black background

    auto bg = mClient->createSurface(String8("BGTest"), 0, 0, PIXEL_FORMAT_RGBA_8888,

                                     ISurfaceComposerClient::eFXSurfaceEffect);

    ASSERT_NE(nullptr, bg.get());

    Transaction t;

    t.setLayerStack(bg, 0)

            .setCrop(bg, Rect(0, 0, mDisplayWidth, mDisplayHeight))

            .setColor(bg, half3{0, 0, 0})

            .setLayer(bg, 0)

            .apply();



    Rect windowSize(1000, 1000);

    Rect bufferSize(500, 500);

    Rect bufferCrop(100, 100, 350, 350);



    BLASTBufferQueueHelper adapter(mSurfaceControl, windowSize.getWidth(), windowSize.getHeight());

    sp<IGraphicBufferProducer> igbProducer;

    setUpProducer(adapter, igbProducer);

    int slot;

    sp<Fence> fence;

    sp<GraphicBuffer> buf;

    auto ret = igbProducer->dequeueBuffer(&slot, &fence, bufferSize.getWidth(),

                                          bufferSize.getHeight(), PIXEL_FORMAT_RGBA_8888,

                                          GRALLOC_USAGE_SW_WRITE_OFTEN, nullptr, nullptr);

    ASSERT_EQ(IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION, ret);

    ASSERT_EQ(OK, igbProducer->requestBuffer(slot, &buf));



    uint32_t* bufData;

    buf->lock(static_cast<uint32_t>(GraphicBuffer::USAGE_SW_WRITE_OFTEN),

              reinterpret_cast<void**>(&bufData));

    // fill buffer with grey

    fillBuffer(bufData, bufferSize, buf->getStride(), 127, 127, 127);



    // fill crop area with different colors so we can verify the cropped region has been scaled

    // correctly.

    fillBuffer(bufData, Rect(100, 100, 225, 225), buf->getStride(), /* rgb */ 255, 0, 0);

    fillBuffer(bufData, Rect(100, 226, 225, 350), buf->getStride(), /* rgb */ 0, 255, 0);

    fillBuffer(bufData, Rect(226, 100, 350, 225), buf->getStride(), /* rgb */ 0, 0, 255);

    fillBuffer(bufData, Rect(226, 226, 350, 350), buf->getStride(), /* rgb */ 255, 0, 0);

    buf->unlock();



    IGraphicBufferProducer::QueueBufferOutput qbOutput;

    IGraphicBufferProducer::QueueBufferInput input(systemTime(), true /* autotimestamp */,

                                                   HAL_DATASPACE_UNKNOWN,

                                                   bufferCrop /* Rect::INVALID_RECT */,

                                                   NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW, 0,

                                                   Fence::NO_FENCE);

    igbProducer->queueBuffer(slot, input, &qbOutput);

    ASSERT_NE(ui::Transform::ROT_INVALID, qbOutput.transformHint);



    adapter.waitForCallbacks();



    ASSERT_EQ(NO_ERROR, captureDisplay(mCaptureArgs, mCaptureResults));

    // Verify cropped region is scaled correctly.

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(255, 0, 0, {10, 10, 490, 490}));

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(0, 255, 0, {10, 510, 490, 990}));

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(0, 0, 255, {510, 10, 990, 490}));

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(255, 0, 0, {510, 510, 990, 990}));

    // Verify outside region is black.

    ASSERT_NO_FATAL_FAILURE(checkScreenCapture(0, 0, 0,

                                               {0, 0, (int32_t)windowSize.getWidth(),

                                                (int32_t)windowSize.getHeight()},

                                               /*border*/ 0, /*outsideRegion*/ true));

}



class TestProducerListener : public BnProducerListener {

services/surfaceflinger/BufferStateLayer.cpp

+4 −20
Original line number Diff line number Diff line
@@ -790,7 +790,7 @@ void BufferStateLayer::gatherBufferInfo() { 
    mBufferInfo.mFence = s.acquireFence;

    mBufferInfo.mTransform = s.bufferTransform;

    mBufferInfo.mDataspace = translateDataspace(s.dataspace);

    mBufferInfo.mCrop = computeCrop(s);

    mBufferInfo.mCrop = computeBufferCrop(s);

    mBufferInfo.mScaleMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;

    mBufferInfo.mSurfaceDamage = s.surfaceDamageRegion;

    mBufferInfo.mHdrMetadata = s.hdrMetadata;
@@ -803,27 +803,11 @@ uint32_t BufferStateLayer::getEffectiveScalingMode() const { 
   return NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;

}



Rect BufferStateLayer::computeCrop(const State& s) {

    if (s.crop.isEmpty() && s.buffer) {

Rect BufferStateLayer::computeBufferCrop(const State& s) {

    if (s.buffer) {

        return s.buffer->getBuffer()->getBounds();

    } else if (s.buffer) {

        Rect crop = s.crop;

        crop.left = std::max(crop.left, 0);

        crop.top = std::max(crop.top, 0);

        uint32_t bufferWidth = s.buffer->getBuffer()->getWidth();

        uint32_t bufferHeight = s.buffer->getBuffer()->getHeight();

        if (bufferHeight <= std::numeric_limits<int32_t>::max() &&

            bufferWidth <= std::numeric_limits<int32_t>::max()) {

            crop.right = std::min(crop.right, static_cast<int32_t>(bufferWidth));

            crop.bottom = std::min(crop.bottom, static_cast<int32_t>(bufferHeight));

        }

        if (!crop.isValid()) {

            // Crop rect is out of bounds, return whole buffer

            return s.buffer->getBuffer()->getBounds();

        }

        return crop;

    }

    return s.crop;

    return Rect::INVALID_RECT;

}



sp<Layer> BufferStateLayer::createClone() {

services/surfaceflinger/BufferStateLayer.h

+1 −1
Original line number Diff line number Diff line
@@ -140,7 +140,7 @@ private: 
    sp<Layer> createClone() override;



    // Crop that applies to the buffer

    Rect computeCrop(const State& s);

    Rect computeBufferCrop(const State& s);



    bool willPresentCurrentTransaction() const;