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

Commit 40482ff6 authored by Chavi Weingarten's avatar Chavi Weingarten
Browse files

Revert "Revert "Use GraphicBuffer instead of GBP for screenshots."" 

This reverts commit 707b8f35.

Reason for revert: Ready to test out changes with SystemUI update

Change-Id: I9fd0cb7ad9cc68d2366fc5ec4ab087fbe4c21f3b
parent 707b8f35

libs/gui/ISurfaceComposer.cpp

+47 −24
Original line number Diff line number Diff line
@@ -100,17 +100,13 @@ public: 
        remote()->transact(BnSurfaceComposer::BOOT_FINISHED, data, &reply);

    }



    virtual status_t captureScreen(const sp<IBinder>& display,

            const sp<IGraphicBufferProducer>& producer,

    virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,

                                   Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,

            int32_t minLayerZ, int32_t maxLayerZ,

            bool useIdentityTransform,

            ISurfaceComposer::Rotation rotation)

    {

                                   int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,

                                   ISurfaceComposer::Rotation rotation) {

        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        data.writeStrongBinder(display);

        data.writeStrongBinder(IInterface::asBinder(producer));

        data.write(sourceCrop);

        data.writeUint32(reqWidth);

        data.writeUint32(reqHeight);
@@ -118,21 +114,45 @@ public: 
        data.writeInt32(maxLayerZ);

        data.writeInt32(static_cast<int32_t>(useIdentityTransform));

        data.writeInt32(static_cast<int32_t>(rotation));

        remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply);

        return reply.readInt32();

        status_t err = remote()->transact(BnSurfaceComposer::CAPTURE_SCREEN, data, &reply);



        if (err != NO_ERROR) {

            return err;

        }



        err = reply.readInt32();

        if (err != NO_ERROR) {

            return err;

        }



        *outBuffer = new GraphicBuffer();

        reply.read(**outBuffer);

        return err;

    }



    virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder,

                                   const sp<IGraphicBufferProducer>& producer,

                                   const Rect& sourceCrop, float frameScale) {

                                   sp<GraphicBuffer>* outBuffer, const Rect& sourceCrop,

                                   float frameScale) {

        Parcel data, reply;

        data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());

        data.writeStrongBinder(layerHandleBinder);

        data.writeStrongBinder(IInterface::asBinder(producer));

        data.write(sourceCrop);

        data.writeFloat(frameScale);

        remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply);

        return reply.readInt32();

        status_t err = remote()->transact(BnSurfaceComposer::CAPTURE_LAYERS, data, &reply);



        if (err != NO_ERROR) {

            return err;

        }



        err = reply.readInt32();

        if (err != NO_ERROR) {

            return err;

        }



        *outBuffer = new GraphicBuffer();

        reply.read(**outBuffer);



        return err;

    }



    virtual bool authenticateSurfaceTexture(
@@ -583,8 +603,7 @@ status_t BnSurfaceComposer::onTransact( 
        case CAPTURE_SCREEN: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> display = data.readStrongBinder();

            sp<IGraphicBufferProducer> producer =

                    interface_cast<IGraphicBufferProducer>(data.readStrongBinder());

            sp<GraphicBuffer> outBuffer;

            Rect sourceCrop(Rect::EMPTY_RECT);

            data.read(sourceCrop);

            uint32_t reqWidth = data.readUint32();
@@ -594,24 +613,28 @@ status_t BnSurfaceComposer::onTransact( 
            bool useIdentityTransform = static_cast<bool>(data.readInt32());

            int32_t rotation = data.readInt32();



            status_t res = captureScreen(display, producer,

                    sourceCrop, reqWidth, reqHeight, minLayerZ, maxLayerZ,

                    useIdentityTransform,

            status_t res = captureScreen(display, &outBuffer, sourceCrop, reqWidth, reqHeight,

                                         minLayerZ, maxLayerZ, useIdentityTransform,

                                         static_cast<ISurfaceComposer::Rotation>(rotation));

            reply->writeInt32(res);

            if (res == NO_ERROR) {

                reply->write(*outBuffer);

            }

            return NO_ERROR;

        }

        case CAPTURE_LAYERS: {

            CHECK_INTERFACE(ISurfaceComposer, data, reply);

            sp<IBinder> layerHandleBinder = data.readStrongBinder();

            sp<IGraphicBufferProducer> producer =

                    interface_cast<IGraphicBufferProducer>(data.readStrongBinder());

            sp<GraphicBuffer> outBuffer;

            Rect sourceCrop(Rect::EMPTY_RECT);

            data.read(sourceCrop);

            float frameScale = data.readFloat();



            status_t res = captureLayers(layerHandleBinder, producer, sourceCrop, frameScale);

            status_t res = captureLayers(layerHandleBinder, &outBuffer, sourceCrop, frameScale);

            reply->writeInt32(res);

            if (res == NO_ERROR) {

                reply->write(*outBuffer);

            }

            return NO_ERROR;

        }

        case AUTHENTICATE_SURFACE: {

libs/gui/Surface.cpp

+21 −0
Original line number Diff line number Diff line
@@ -1760,4 +1760,25 @@ status_t Surface::getAndFlushRemovedBuffers(std::vector<sp<GraphicBuffer>>* out) 
    return OK;

}



status_t Surface::attachAndQueueBuffer(Surface* surface, sp<GraphicBuffer> buffer) {

    if (buffer == nullptr) {

        return BAD_VALUE;

    }

    int err = static_cast<ANativeWindow*>(surface)->perform(surface, NATIVE_WINDOW_API_CONNECT,

                                                            NATIVE_WINDOW_API_CPU);

    if (err != OK) {

        return err;

    }

    err = surface->attachBuffer(buffer->getNativeBuffer());

    if (err != OK) {

        return err;

    }

    err = static_cast<ANativeWindow*>(surface)->queueBuffer(surface, buffer->getNativeBuffer(), -1);

    if (err != OK) {

        return err;

    }

    err = surface->disconnect(NATIVE_WINDOW_API_CPU);

    return err;

}



}; // namespace android

libs/gui/SurfaceComposerClient.cpp

+10 −164
Original line number Diff line number Diff line
@@ -717,181 +717,27 @@ status_t SurfaceComposerClient::getHdrCapabilities(const sp<IBinder>& display, 


// ----------------------------------------------------------------------------



status_t ScreenshotClient::capture(

        const sp<IBinder>& display,

        const sp<IGraphicBufferProducer>& producer,

        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,

        int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform) {

    sp<ISurfaceComposer> s(ComposerService::getComposerService());

    if (s == NULL) return NO_INIT;

    return s->captureScreen(display, producer, sourceCrop,

            reqWidth, reqHeight, minLayerZ, maxLayerZ, useIdentityTransform);

}



status_t ScreenshotClient::captureToBuffer(const sp<IBinder>& display,

        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,

        int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,

        uint32_t rotation,

status_t ScreenshotClient::capture(const sp<IBinder>& display, Rect sourceCrop, uint32_t reqWidth,

                                   uint32_t reqHeight, int32_t minLayerZ, int32_t maxLayerZ,

                                   bool useIdentityTransform, uint32_t rotation,

                                   sp<GraphicBuffer>* outBuffer) {

    sp<ISurfaceComposer> s(ComposerService::getComposerService());

    if (s == NULL) return NO_INIT;



    sp<IGraphicBufferConsumer> gbpConsumer;

    sp<IGraphicBufferProducer> producer;

    BufferQueue::createBufferQueue(&producer, &gbpConsumer);

    sp<BufferItemConsumer> consumer(new BufferItemConsumer(gbpConsumer,

           GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_NEVER,

           1, true));



    status_t ret = s->captureScreen(display, producer, sourceCrop, reqWidth, reqHeight,

            minLayerZ, maxLayerZ, useIdentityTransform,

    status_t ret = s->captureScreen(display, outBuffer, sourceCrop, reqWidth, reqHeight, minLayerZ,

                                    maxLayerZ, useIdentityTransform,

                                    static_cast<ISurfaceComposer::Rotation>(rotation));

    if (ret != NO_ERROR) {

        return ret;

    }

    BufferItem b;

    consumer->acquireBuffer(&b, 0, true);

    *outBuffer = b.mGraphicBuffer;

    return ret;

}



status_t ScreenshotClient::captureLayers(const sp<IBinder>& layerHandle,

                                         const sp<IGraphicBufferProducer>& producer,

                                         Rect sourceCrop, float frameScale) {

    sp<ISurfaceComposer> s(ComposerService::getComposerService());

    if (s == NULL) return NO_INIT;

    return s->captureLayers(layerHandle, producer, sourceCrop, frameScale);

}



status_t ScreenshotClient::captureLayersToBuffer(const sp<IBinder>& layerHandle, Rect sourceCrop,

status_t ScreenshotClient::captureLayers(const sp<IBinder>& layerHandle, Rect sourceCrop,

                                         float frameScale, sp<GraphicBuffer>* outBuffer) {

    sp<ISurfaceComposer> s(ComposerService::getComposerService());

    if (s == NULL) return NO_INIT;



    sp<IGraphicBufferConsumer> gbpConsumer;

    sp<IGraphicBufferProducer> producer;

    BufferQueue::createBufferQueue(&producer, &gbpConsumer);

    sp<BufferItemConsumer> consumer(new BufferItemConsumer(gbpConsumer,

                                                           GRALLOC_USAGE_HW_TEXTURE |

                                                                   GRALLOC_USAGE_SW_READ_NEVER |

                                                                   GRALLOC_USAGE_SW_WRITE_NEVER,

                                                           1, true));



    status_t ret = s->captureLayers(layerHandle, producer, sourceCrop, frameScale);

    if (ret != NO_ERROR) {

        return ret;

    }

    BufferItem b;

    consumer->acquireBuffer(&b, 0, true);

    *outBuffer = b.mGraphicBuffer;

    status_t ret = s->captureLayers(layerHandle, outBuffer, sourceCrop, frameScale);

    return ret;

}



ScreenshotClient::ScreenshotClient()

    : mHaveBuffer(false) {

    memset(&mBuffer, 0, sizeof(mBuffer));

}



ScreenshotClient::~ScreenshotClient() {

    ScreenshotClient::release();

}



sp<CpuConsumer> ScreenshotClient::getCpuConsumer() const {

    if (mCpuConsumer == NULL) {

        sp<IGraphicBufferConsumer> consumer;

        BufferQueue::createBufferQueue(&mProducer, &consumer);

        mCpuConsumer = new CpuConsumer(consumer, 1);

        mCpuConsumer->setName(String8("ScreenshotClient"));

    }

    return mCpuConsumer;

}



status_t ScreenshotClient::update(const sp<IBinder>& display,

        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,

        int32_t minLayerZ, int32_t maxLayerZ,

        bool useIdentityTransform, uint32_t rotation) {

    sp<ISurfaceComposer> s(ComposerService::getComposerService());

    if (s == NULL) return NO_INIT;

    sp<CpuConsumer> cpuConsumer = getCpuConsumer();



    if (mHaveBuffer) {

        mCpuConsumer->unlockBuffer(mBuffer);

        memset(&mBuffer, 0, sizeof(mBuffer));

        mHaveBuffer = false;

    }



    status_t err = s->captureScreen(display, mProducer, sourceCrop,

            reqWidth, reqHeight, minLayerZ, maxLayerZ, useIdentityTransform,

            static_cast<ISurfaceComposer::Rotation>(rotation));



    if (err == NO_ERROR) {

        err = mCpuConsumer->lockNextBuffer(&mBuffer);

        if (err == NO_ERROR) {

            mHaveBuffer = true;

        }

    }

    return err;

}



status_t ScreenshotClient::update(const sp<IBinder>& display,

        Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,

        int32_t minLayerZ, int32_t maxLayerZ,

        bool useIdentityTransform) {



    return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,

            minLayerZ, maxLayerZ, useIdentityTransform, ISurfaceComposer::eRotateNone);

}



status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,

        bool useIdentityTransform) {

    return ScreenshotClient::update(display, sourceCrop, 0, 0,

            INT32_MIN, INT32_MAX,

            useIdentityTransform, ISurfaceComposer::eRotateNone);

}



status_t ScreenshotClient::update(const sp<IBinder>& display, Rect sourceCrop,

        uint32_t reqWidth, uint32_t reqHeight, bool useIdentityTransform) {

    return ScreenshotClient::update(display, sourceCrop, reqWidth, reqHeight,

            INT32_MIN, INT32_MAX,

            useIdentityTransform, ISurfaceComposer::eRotateNone);

}



void ScreenshotClient::release() {

    if (mHaveBuffer) {

        mCpuConsumer->unlockBuffer(mBuffer);

        memset(&mBuffer, 0, sizeof(mBuffer));

        mHaveBuffer = false;

    }

    mCpuConsumer.clear();

}



void const* ScreenshotClient::getPixels() const {

    return mBuffer.data;

}



uint32_t ScreenshotClient::getWidth() const {

    return mBuffer.width;

}



uint32_t ScreenshotClient::getHeight() const {

    return mBuffer.height;

}



PixelFormat ScreenshotClient::getFormat() const {

    return mBuffer.format;

}



uint32_t ScreenshotClient::getStride() const {

    return mBuffer.stride;

}



size_t ScreenshotClient::getSize() const {

    return mBuffer.stride * mBuffer.height * bytesPerPixel(mBuffer.format);

}



android_dataspace ScreenshotClient::getDataSpace() const {

    return mBuffer.dataSpace;

}



// ----------------------------------------------------------------------------

}; // namespace android

libs/gui/include/gui/ISurfaceComposer.h

+7 −8
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ 


#include <ui/FrameStats.h>

#include <ui/PixelFormat.h>

#include <ui/GraphicBuffer.h>



#include <vector>
@@ -167,16 +168,14 @@ public: 
    /* Capture the specified screen. requires READ_FRAME_BUFFER permission

     * This function will fail if there is a secure window on screen.

     */

    virtual status_t captureScreen(const sp<IBinder>& display,

            const sp<IGraphicBufferProducer>& producer,

    virtual status_t captureScreen(const sp<IBinder>& display, sp<GraphicBuffer>* outBuffer,

                                   Rect sourceCrop, uint32_t reqWidth, uint32_t reqHeight,

            int32_t minLayerZ, int32_t maxLayerZ,

            bool useIdentityTransform,

                                   int32_t minLayerZ, int32_t maxLayerZ, bool useIdentityTransform,

                                   Rotation rotation = eRotateNone) = 0;



    virtual status_t captureLayers(const sp<IBinder>& layerHandleBinder,

                                   const sp<IGraphicBufferProducer>& producer,

                                   const Rect& sourceCrop, float frameScale = 1.0) = 0;

                                   sp<GraphicBuffer>* outBuffer, const Rect& sourceCrop,

                                   float frameScale = 1.0) = 0;



    /* Clears the frame statistics for animations.

     *

libs/gui/include/gui/Surface.h

+2 −0
Original line number Diff line number Diff line
@@ -283,6 +283,8 @@ public: 


    android_dataspace_t getBuffersDataSpace();



    static status_t attachAndQueueBuffer(Surface* surface, sp<GraphicBuffer> buffer);



protected:

    enum { NUM_BUFFER_SLOTS = BufferQueueDefs::NUM_BUFFER_SLOTS };

    enum { DEFAULT_FORMAT = PIXEL_FORMAT_RGBA_8888 };