services/surfaceflinger/tests/hwc2/Hwc2TestBuffer.cpp - platform/frameworks/native - Git at Google

 /*
  * Copyright (C) 2016 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.
  */

 #include <mutex>
 #include <array>
 #include <sstream>
 #include <algorithm>

 #include <gui/Surface.h>
 #include <gui/BufferItemConsumer.h>

 #include <ui/GraphicBuffer.h>
 #include <android/hardware/graphics/common/1.0/types.h>
 #include <math/vec4.h>

 #include <GLES3/gl3.h>
 #include <SkImageEncoder.h>
 #include <SkStream.h>
 #include "Hwc2TestBuffer.h"
 #include "Hwc2TestLayers.h"

 using namespace android;
 using android::hardware::graphics::common::V1_0::BufferUsage;

 /* Returns a fence from egl */
 typedef void (*FenceCallback)(int32_t fence, void* callbackArgs);

 /* Returns fence to fence generator */
 static void setFence(int32_t fence, void* fenceGenerator);


 /* Used to receive the surfaces and fences from egl. The egl buffers are thrown
  * away. The fences are sent to the requester via a callback */
 class Hwc2TestSurfaceManager {
 public:
     /* Listens for a new frame, detaches the buffer and returns the fence
      * through saved callback. */
     class BufferListener : public ConsumerBase::FrameAvailableListener {
     public:
         BufferListener(sp<IGraphicBufferConsumer> consumer,
                 FenceCallback callback, void* callbackArgs)
             : mConsumer(consumer),
               mCallback(callback),
               mCallbackArgs(callbackArgs) { }

         void onFrameAvailable(const BufferItem& /*item*/)
         {
             BufferItem item;

             if (mConsumer->acquireBuffer(&item, 0))
                 return;
             if (mConsumer->detachBuffer(item.mSlot))
                 return;

             mCallback(item.mFence->dup(), mCallbackArgs);
         }

     private:
         sp<IGraphicBufferConsumer> mConsumer;
         FenceCallback mCallback;
         void* mCallbackArgs;
     };

     /* Creates a buffer listener that waits on a new frame from the buffer
      * queue. */
     void initialize(const Area& bufferArea, android_pixel_format_t format,
             FenceCallback callback, void* callbackArgs)
     {
         sp<IGraphicBufferProducer> producer;
         sp<IGraphicBufferConsumer> consumer;
         BufferQueue::createBufferQueue(&producer, &consumer);

         consumer->setDefaultBufferSize(bufferArea.width, bufferArea.height);
         consumer->setDefaultBufferFormat(format);

         mBufferItemConsumer = new BufferItemConsumer(consumer, 0);

         mListener = new BufferListener(consumer, callback, callbackArgs);
         mBufferItemConsumer->setFrameAvailableListener(mListener);

         mSurface = new Surface(producer, true);
     }

     /* Used by Egl manager. The surface is never displayed. */
     sp<Surface> getSurface() const
     {
         return mSurface;
     }

 private:
     sp<BufferItemConsumer> mBufferItemConsumer;
     sp<BufferListener> mListener;
     /* Used by Egl manager. The surface is never displayed */
     sp<Surface> mSurface;
 };


 /* Used to generate valid fences. It is not possible to create a dummy sync
  * fence for testing. Egl can generate buffers along with a valid fence.
  * The buffer cannot be guaranteed to be the same format across all devices so
  * a CPU filled buffer is used instead. The Egl fence is used along with the
  * CPU filled buffer. */
 class Hwc2TestEglManager {
 public:
     Hwc2TestEglManager()
         : mEglDisplay(EGL_NO_DISPLAY),
           mEglSurface(EGL_NO_SURFACE),
           mEglContext(EGL_NO_CONTEXT) { }

     ~Hwc2TestEglManager()
     {
         cleanup();
     }

     int initialize(sp<Surface> surface)
     {
         mSurface = surface;

         mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
         if (mEglDisplay == EGL_NO_DISPLAY) return false;

         EGLint major;
         EGLint minor;
         if (!eglInitialize(mEglDisplay, &major, &minor)) {
             ALOGW("Could not initialize EGL");
             return false;
         }

         /* We're going to use a 1x1 pbuffer surface later on
          * The configuration distance doesn't really matter for what we're
          * trying to do */
         EGLint configAttrs[] = {
                 EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
                 EGL_RED_SIZE, 8,
                 EGL_GREEN_SIZE, 8,
                 EGL_BLUE_SIZE, 8,
                 EGL_ALPHA_SIZE, 0,
                 EGL_DEPTH_SIZE, 24,
                 EGL_STENCIL_SIZE, 0,
                 EGL_NONE
         };

         EGLConfig configs[1];
         EGLint configCnt;
         if (!eglChooseConfig(mEglDisplay, configAttrs, configs, 1,
                 &configCnt)) {
             ALOGW("Could not select EGL configuration");
             eglReleaseThread();
             eglTerminate(mEglDisplay);
             return false;
         }

         if (configCnt <= 0) {
             ALOGW("Could not find EGL configuration");
             eglReleaseThread();
             eglTerminate(mEglDisplay);
             return false;
         }

         /* These objects are initialized below but the default "null" values are
          * used to cleanup properly at any point in the initialization sequence */
         EGLint attrs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
         mEglContext = eglCreateContext(mEglDisplay, configs[0], EGL_NO_CONTEXT,
                 attrs);
         if (mEglContext == EGL_NO_CONTEXT) {
             ALOGW("Could not create EGL context");
             cleanup();
             return false;
         }

         EGLint surfaceAttrs[] = { EGL_NONE };
         mEglSurface = eglCreateWindowSurface(mEglDisplay, configs[0],
                 mSurface.get(), surfaceAttrs);
         if (mEglSurface == EGL_NO_SURFACE) {
             ALOGW("Could not create EGL surface");
             cleanup();
             return false;
         }

         if (!eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
             ALOGW("Could not change current EGL context");
             cleanup();
             return false;
         }

         return true;
     }

     void makeCurrent() const
     {
         eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
     }

     void present() const
     {
         eglSwapBuffers(mEglDisplay, mEglSurface);
     }

 private:
     void cleanup()
     {
         if (mEglDisplay == EGL_NO_DISPLAY)
             return;
         if (mEglSurface != EGL_NO_SURFACE)
             eglDestroySurface(mEglDisplay, mEglSurface);
         if (mEglContext != EGL_NO_CONTEXT)
             eglDestroyContext(mEglDisplay, mEglContext);

         eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
                 EGL_NO_CONTEXT);
         eglReleaseThread();
         eglTerminate(mEglDisplay);
     }

     sp<Surface> mSurface;
     EGLDisplay mEglDisplay;
     EGLSurface mEglSurface;
     EGLContext mEglContext;
 };


 static const std::array<vec2, 4> triangles = {{
     {  1.0f,  1.0f },
     { -1.0f,  1.0f },
     {  1.0f, -1.0f },
     { -1.0f, -1.0f },
 }};

 class Hwc2TestFenceGenerator {
 public:

     Hwc2TestFenceGenerator()
     {
         mSurfaceManager.initialize({1, 1}, HAL_PIXEL_FORMAT_RGBA_8888,
                 setFence, this);

         if (!mEglManager.initialize(mSurfaceManager.getSurface()))
             return;

         mEglManager.makeCurrent();

         glClearColor(0.0, 0.0, 0.0, 1.0);
         glEnableVertexAttribArray(0);
     }

     ~Hwc2TestFenceGenerator()
     {
         if (mFence >= 0)
             close(mFence);
         mFence = -1;

         mEglManager.makeCurrent();
     }

     /* It is not possible to simply generate a fence. The easiest way is to
      * generate a buffer using egl and use the associated fence. The buffer
      * cannot be guaranteed to be a certain format across all devices using this
      * method. Instead the buffer is generated using the CPU */
     int32_t get()
     {
         if (mFence >= 0) {
             return dup(mFence);
         }

         std::unique_lock<std::mutex> lock(mMutex);

         /* If the pending is still set to false and times out, we cannot recover.
          * Set an error and return */
         while (mPending != false) {
             if (mCv.wait_for(lock, std::chrono::seconds(2)) == std::cv_status::timeout)
                 return -ETIME;
         }

         /* Generate a fence. The fence will be returned through the setFence
          * callback */
         mEglManager.makeCurrent();

         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, triangles.data());
         glClear(GL_COLOR_BUFFER_BIT);

         mEglManager.present();

         /* Wait for the setFence callback */
         while (mPending != true) {
             if (mCv.wait_for(lock, std::chrono::seconds(2)) == std::cv_status::timeout)
                 return -ETIME;
         }

         mPending = false;

         return dup(mFence);
     }

     /* Callback that sets the fence */
     void set(int32_t fence)
     {
         mFence = fence;
         mPending = true;

         mCv.notify_all();
     }

 private:

     Hwc2TestSurfaceManager mSurfaceManager;
     Hwc2TestEglManager mEglManager;

     std::mutex mMutex;
     std::condition_variable mCv;

     int32_t mFence = -1;
     bool mPending = false;
 };


 static void setFence(int32_t fence, void* fenceGenerator)
 {
     static_cast<Hwc2TestFenceGenerator*>(fenceGenerator)->set(fence);
 }


 /* Sets the pixel of a buffer given the location, format, stride and color.
  * Currently only supports RGBA_8888 */
 static void setColor(int32_t x, int32_t y,
         android_pixel_format_t format, uint32_t stride, uint8_t* img, uint8_t r,
         uint8_t g, uint8_t b, uint8_t a)
 {
        switch (format) {
        case HAL_PIXEL_FORMAT_RGBA_8888:
            img[(y * stride + x) * 4 + 0] = r;
            img[(y * stride + x) * 4 + 1] = g;
            img[(y * stride + x) * 4 + 2] = b;
            img[(y * stride + x) * 4 + 3] = a;
            break;
        default:
            break;
        }
 }

 Hwc2TestBuffer::Hwc2TestBuffer()
     : mFenceGenerator(new Hwc2TestFenceGenerator()) { }

 Hwc2TestBuffer::~Hwc2TestBuffer() = default;

 /* When the buffer changes sizes, save the new size and invalidate the current
  * buffer */
 void Hwc2TestBuffer::updateBufferArea(const Area& bufferArea)
 {
     if (mBufferArea.width == bufferArea.width
             && mBufferArea.height == bufferArea.height)
         return;

     mBufferArea.width = bufferArea.width;
     mBufferArea.height = bufferArea.height;

     mValidBuffer = false;
 }

 /* Returns a valid buffer handle and fence. The handle is filled using the CPU
  * to ensure the correct format across all devices. The fence is created using
  * egl. */
 int Hwc2TestBuffer::get(buffer_handle_t* outHandle, int32_t* outFence)
 {
     if (mBufferArea.width == -1 || mBufferArea.height == -1)
         return -EINVAL;

     /* If the current buffer is valid, the previous buffer can be reused.
      * Otherwise, create new buffer */
     if (!mValidBuffer) {
         int ret = generateBuffer();
         if (ret)
             return ret;
     }

     *outFence = mFenceGenerator->get();
     *outHandle = mHandle;

     mValidBuffer = true;

     return 0;
 }

 /* CPU fills a buffer to guarantee the correct buffer format across all
  * devices */
 int Hwc2TestBuffer::generateBuffer()
 {
     /* Create new graphic buffer with correct dimensions */
     mGraphicBuffer = new GraphicBuffer(mBufferArea.width, mBufferArea.height,
             mFormat, BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
             BufferUsage::COMPOSER_OVERLAY, "hwc2_test_buffer");

     int ret = mGraphicBuffer->initCheck();
     if (ret) {
         return ret;
     }
     if (!mGraphicBuffer->handle) {
         return -EINVAL;
     }

     /* Locks the buffer for writing */
     uint8_t* img;
     mGraphicBuffer->lock(static_cast<uint32_t>(BufferUsage::CPU_WRITE_OFTEN),
             (void**)(&img));

     uint32_t stride = mGraphicBuffer->getStride();

     /* Iterate from the top row of the buffer to the bottom row */
     for (int32_t y = 0; y < mBufferArea.height; y++) {

         /* Will be used as R, G and B values for pixel colors */
         uint8_t max = 255;
         uint8_t min = 0;

         /* Divide the rows into 3 sections. The first section will contain
          * the lighest colors. The last section will contain the darkest
          * colors. */
         if (y < mBufferArea.height * 1.0 / 3.0) {
             min = 255 / 2;
         } else if (y >= mBufferArea.height * 2.0 / 3.0) {
             max = 255 / 2;
         }

         /* Divide the columns into 3 sections. The first section is red,
          * the second is green and the third is blue */
         int32_t x = 0;
         for (; x < mBufferArea.width / 3; x++) {
             setColor(x, y, mFormat, stride, img, max, min, min, 255);
         }

         for (; x < mBufferArea.width * 2 / 3; x++) {
             setColor(x, y, mFormat, stride, img, min, max, min, 255);
         }

         for (; x < mBufferArea.width; x++) {
             setColor(x, y, mFormat, stride, img, min, min, max, 255);
         }
     }

     /* Unlock the buffer for reading */
     mGraphicBuffer->unlock();

     mHandle = mGraphicBuffer->handle;

     return 0;
 }


 Hwc2TestClientTargetBuffer::Hwc2TestClientTargetBuffer()
     : mFenceGenerator(new Hwc2TestFenceGenerator()) { }

 Hwc2TestClientTargetBuffer::~Hwc2TestClientTargetBuffer() { }

 /* Generates a buffer from layersToDraw.
  * Takes into account the individual layer properties such as
  * transform, blend mode, source crop, etc. */
 static void compositeBufferFromLayers(
         const android::sp<android::GraphicBuffer>& graphicBuffer,
         android_pixel_format_t format, const Area& bufferArea,
         const Hwc2TestLayers* testLayers,
         const std::set<hwc2_layer_t>* layersToDraw,
         const std::set<hwc2_layer_t>* clearLayers)
 {
     /* Locks the buffer for writing */
     uint8_t* img;
     graphicBuffer->lock(static_cast<uint32_t>(BufferUsage::CPU_WRITE_OFTEN),
             (void**)(&img));

     uint32_t stride = graphicBuffer->getStride();

     float bWDiv3 = bufferArea.width / 3;
     float bW2Div3 = bufferArea.width * 2 / 3;
     float bHDiv3 = bufferArea.height / 3;
     float bH2Div3 = bufferArea.height * 2 / 3;

     /* Cycle through every pixel in the buffer and determine what color it
      * should be. */
     for (int32_t y = 0; y < bufferArea.height; y++) {
         for (int32_t x = 0; x < bufferArea.width; x++) {

             uint8_t r = 0, g = 0, b = 0;
             float a = 0.0f;

             /* Cycle through each layer from back to front and
              * update the pixel color. */
             for (auto layer = layersToDraw->rbegin();
                     layer != layersToDraw->rend(); ++layer) {

                 const hwc_rect_t df = testLayers->getDisplayFrame(*layer);

                 float dfL = df.left;
                 float dfT = df.top;
                 float dfR = df.right;
                 float dfB = df.bottom;

                 /* If the pixel location falls outside of the layer display
                  * frame, skip the layer. */
                 if (x < dfL || x >= dfR || y < dfT || y >= dfB)
                     continue;

                 /* If the device has requested the layer be clear, clear
                  * the pixel and continue. */
                 if (clearLayers->count(*layer) != 0) {
                     r = 0;
                     g = 0;
                     b = 0;
                     a = 0.0f;
                     continue;
                 }

                 float planeAlpha = testLayers->getPlaneAlpha(*layer);

                 /* If the layer is a solid color, fill the color and
                  * continue. */
                 if (testLayers->getComposition(*layer)
                         == HWC2_COMPOSITION_SOLID_COLOR) {
                     const auto color = testLayers->getColor(*layer);
                     r = color.r;
                     g = color.g;
                     b = color.b;
                     a = color.a * planeAlpha;
                     continue;
                 }

                 float xPos = x;
                 float yPos = y;

                 hwc_transform_t transform = testLayers->getTransform(*layer);

                 float dfW = dfR - dfL;
                 float dfH = dfB - dfT;

                 /* If a layer has a transform, find which location on the
                  * layer will end up in the current pixel location. We
                  * can calculate the color of the current pixel using that
                  * location. */
                 if (transform > 0) {
                     /* Change origin to be the center of the layer. */
                     xPos = xPos - dfL - dfW / 2.0;
                     yPos = yPos - dfT - dfH / 2.0;

                     /* Flip Horizontal by reflecting across the y axis. */
                     if (transform & HWC_TRANSFORM_FLIP_H)
                         xPos = -xPos;

                     /* Flip vertical by reflecting across the x axis. */
                     if (transform & HWC_TRANSFORM_FLIP_V)
                         yPos = -yPos;

                     /* Rotate 90 by using a basic linear algebra rotation
                      * and scaling the result so the display frame remains
                      * the same. For example, a buffer of size 100x50 should
                      * rotate 90 degress but remain the same dimension
                      * (100x50) at the end of the transformation. */
                     if (transform & HWC_TRANSFORM_ROT_90) {
                         float tmp = xPos;
                         xPos = yPos * dfW / dfH;
                         yPos = -tmp * dfH / dfW;
                     }

                     /* Change origin back to the top left corner of the
                      * layer. */
                     xPos = xPos + dfL + dfW / 2.0;
                     yPos = yPos + dfT + dfH / 2.0;
                 }

                 hwc_frect_t sc = testLayers->getSourceCrop(*layer);
                 float scL = sc.left, scT = sc.top;

                 float dfWDivScW = dfW / (sc.right - scL);
                 float dfHDivScH = dfH / (sc.bottom - scT);

                 float max = 255, min = 0;

                 /* Choose the pixel color. Similar to generateBuffer,
                  * each layer will be divided into 3x3 colors. Because
                  * both the source crop and display frame must be taken into
                  * account, the formulas are more complicated.
                  *
                  * If the source crop and display frame were not taken into
                  * account, we would simply divide the buffer into three
                  * sections by height. Each section would get one color.
                  * For example the formula for the first section would be:
                  *
                  * if (yPos < bufferArea.height / 3)
                  *        //Select first section color
                  *
                  * However the pixel color is chosen based on the source
                  * crop and displayed based on the display frame.
                  *
                  * If the display frame top was 0 and the source crop height
                  * and display frame height were the same. The only factor
                  * would be the source crop top. To calculate the new
                  * section boundary, the section boundary would be moved up
                  * by the height of the source crop top. The formula would
                  * be:
                  * if (yPos < (bufferArea.height / 3 - sourceCrop.top)
                  *        //Select first section color
                  *
                  * If the display frame top could also vary but source crop
                  * and display frame heights were the same, the formula
                  * would be:
                  * if (yPos < (bufferArea.height / 3 - sourceCrop.top
                  *              + displayFrameTop)
                  *        //Select first section color
                  *
                  * If the heights were not the same, the conversion between
                  * the source crop and display frame dimensions must be
                  * taken into account. The formula would be:
                  * if (yPos < ((bufferArea.height / 3) - sourceCrop.top)
                  *              * displayFrameHeight / sourceCropHeight
                  *              + displayFrameTop)
                  *        //Select first section color
                  */
                 if (yPos < ((bHDiv3) - scT) * dfHDivScH + dfT) {
                     min = 255 / 2;
                 } else if (yPos >= ((bH2Div3) - scT) * dfHDivScH + dfT) {
                     max = 255 / 2;
                 }

                 uint8_t rCur = min, gCur = min, bCur = min;
                 float aCur = 1.0f;

                 /* This further divides the color sections from 3 to 3x3.
                  * The math behind it follows the same logic as the previous
                  * comment */
                 if (xPos < ((bWDiv3) - scL) * (dfWDivScW) + dfL) {
                     rCur = max;
                 } else if (xPos < ((bW2Div3) - scL) * (dfWDivScW) + dfL) {
                     gCur = max;
                 } else {
                     bCur = max;
                 }


                 /* Blend the pixel color with the previous layers' pixel
                  * colors using the plane alpha and blend mode. The final
                  * pixel color is chosen using the plane alpha and blend
                  * mode formulas found in hwcomposer2.h */
                 hwc2_blend_mode_t blendMode = testLayers->getBlendMode(*layer);

                 if (blendMode == HWC2_BLEND_MODE_PREMULTIPLIED) {
                     rCur *= planeAlpha;
                     gCur *= planeAlpha;
                     bCur *= planeAlpha;
                 }

                 aCur *= planeAlpha;

                 if (blendMode == HWC2_BLEND_MODE_PREMULTIPLIED) {
                     r = rCur + r * (1.0 - aCur);
                     g = gCur + g * (1.0 - aCur);
                     b = bCur + b * (1.0 - aCur);
                     a = aCur + a * (1.0 - aCur);
                 } else if (blendMode == HWC2_BLEND_MODE_COVERAGE) {
                     r = rCur * aCur + r * (1.0 - aCur);
                     g = gCur * aCur + g * (1.0 - aCur);
                     b = bCur * aCur + b * (1.0 - aCur);
                     a = aCur * aCur + a * (1.0 - aCur);
                 } else {
                     r = rCur;
                     g = gCur;
                     b = bCur;
                     a = aCur;
                 }
             }

             /* Set the pixel color */
             setColor(x, y, format, stride, img, r, g, b, a * 255);
         }
     }

     graphicBuffer->unlock();
 }

 /* Generates a client target buffer using the layers assigned for client
  * composition. Takes into account the individual layer properties such as
  * transform, blend mode, source crop, etc. */
 int Hwc2TestClientTargetBuffer::get(buffer_handle_t* outHandle,
         int32_t* outFence, const Area& bufferArea,
         const Hwc2TestLayers* testLayers,
         const std::set<hwc2_layer_t>* clientLayers,
         const std::set<hwc2_layer_t>* clearLayers)
 {
     /* Create new graphic buffer with correct dimensions */
     mGraphicBuffer = new GraphicBuffer(bufferArea.width, bufferArea.height,
             mFormat, BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
             BufferUsage::COMPOSER_OVERLAY, "hwc2_test_buffer");

     int ret = mGraphicBuffer->initCheck();
     if (ret)
         return ret;

     if (!mGraphicBuffer->handle)
         return -EINVAL;

     compositeBufferFromLayers(mGraphicBuffer, mFormat, bufferArea, testLayers,
             clientLayers, clearLayers);

     *outFence = mFenceGenerator->get();
     *outHandle = mGraphicBuffer->handle;

     return 0;
 }

 void Hwc2TestVirtualBuffer::updateBufferArea(const Area& bufferArea)
 {
     mBufferArea.width = bufferArea.width;
     mBufferArea.height = bufferArea.height;
 }

 bool Hwc2TestVirtualBuffer::writeBufferToFile(std::string path)
 {
     SkFILEWStream file(path.c_str());
     const SkImageInfo info = SkImageInfo::Make(mBufferArea.width,
             mBufferArea.height, SkColorType::kRGBA_8888_SkColorType,
             SkAlphaType::kPremul_SkAlphaType);

     uint8_t* img;
     mGraphicBuffer->lock(static_cast<uint32_t>(BufferUsage::CPU_WRITE_OFTEN),
             (void**)(&img));

     SkPixmap pixmap(info, img, mGraphicBuffer->getStride());
     bool result = file.isValid() && SkEncodeImage(&file, pixmap,
             SkEncodedImageFormat::kPNG, 100);

     mGraphicBuffer->unlock();
     return result;
 }

 /* Generates a buffer that holds the expected result of compositing all of our
  * layers */
 int Hwc2TestExpectedBuffer::generateExpectedBuffer(
         const Hwc2TestLayers* testLayers,
         const std::vector<hwc2_layer_t>* allLayers,
         const std::set<hwc2_layer_t>* clearLayers)
 {
     mGraphicBuffer = new GraphicBuffer(mBufferArea.width, mBufferArea.height,
             mFormat, BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN,
             "hwc2_test_buffer");

     int ret = mGraphicBuffer->initCheck();
     if (ret)
         return ret;

     if (!mGraphicBuffer->handle)
         return -EINVAL;

     const std::set<hwc2_layer_t> allLayerSet(allLayers->begin(),
             allLayers->end());

     compositeBufferFromLayers(mGraphicBuffer, mFormat, mBufferArea, testLayers,
             &allLayerSet, clearLayers);

     return 0;
 }

 int Hwc2TestOutputBuffer::getOutputBuffer(buffer_handle_t* outHandle,
         int32_t* outFence)
 {
     if (mBufferArea.width == -1 || mBufferArea.height == -1)
         return -EINVAL;

     mGraphicBuffer = new GraphicBuffer(mBufferArea.width, mBufferArea.height,
             mFormat, BufferUsage::CPU_READ_OFTEN |
             BufferUsage::GPU_RENDER_TARGET, "hwc2_test_buffer");

     int ret = mGraphicBuffer->initCheck();
     if (ret)
         return ret;

     if (!mGraphicBuffer->handle)
         return -EINVAL;

     *outFence = -1;
     *outHandle = mGraphicBuffer->handle;

     return 0;
 }
	/*
	* Copyright (C) 2016 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.
	*/

	#include <mutex>
	#include <array>
	#include <sstream>
	#include <algorithm>

	#include <gui/Surface.h>
	#include <gui/BufferItemConsumer.h>

	#include <ui/GraphicBuffer.h>
	#include <android/hardware/graphics/common/1.0/types.h>
	#include <math/vec4.h>

	#include <GLES3/gl3.h>
	#include <SkImageEncoder.h>
	#include <SkStream.h>
	#include "Hwc2TestBuffer.h"
	#include "Hwc2TestLayers.h"

	using namespace android;
	using android::hardware::graphics::common::V1_0::BufferUsage;

	/* Returns a fence from egl */
	typedef void (FenceCallback)(int32_t fence, void callbackArgs);

	/* Returns fence to fence generator */
	static void setFence(int32_t fence, void* fenceGenerator);


	/* Used to receive the surfaces and fences from egl. The egl buffers are thrown
	* away. The fences are sent to the requester via a callback */
	class Hwc2TestSurfaceManager {
	public:
	/* Listens for a new frame, detaches the buffer and returns the fence
	* through saved callback. */
	class BufferListener : public ConsumerBase::FrameAvailableListener {
	public:
	BufferListener(sp<IGraphicBufferConsumer> consumer,
	FenceCallback callback, void* callbackArgs)
	: mConsumer(consumer),
	mCallback(callback),
	mCallbackArgs(callbackArgs) { }

	void onFrameAvailable(const BufferItem& /item/)
	{
	BufferItem item;

	if (mConsumer->acquireBuffer(&item, 0))
	return;
	if (mConsumer->detachBuffer(item.mSlot))
	return;

	mCallback(item.mFence->dup(), mCallbackArgs);
	}

	private:
	sp<IGraphicBufferConsumer> mConsumer;
	FenceCallback mCallback;
	void* mCallbackArgs;
	};

	/* Creates a buffer listener that waits on a new frame from the buffer
	* queue. */
	void initialize(const Area& bufferArea, android_pixel_format_t format,
	FenceCallback callback, void* callbackArgs)
	{
	sp<IGraphicBufferProducer> producer;
	sp<IGraphicBufferConsumer> consumer;
	BufferQueue::createBufferQueue(&producer, &consumer);

	consumer->setDefaultBufferSize(bufferArea.width, bufferArea.height);
	consumer->setDefaultBufferFormat(format);

	mBufferItemConsumer = new BufferItemConsumer(consumer, 0);

	mListener = new BufferListener(consumer, callback, callbackArgs);
	mBufferItemConsumer->setFrameAvailableListener(mListener);

	mSurface = new Surface(producer, true);
	}

	/* Used by Egl manager. The surface is never displayed. */
	sp<Surface> getSurface() const
	{
	return mSurface;
	}

	private:
	sp<BufferItemConsumer> mBufferItemConsumer;
	sp<BufferListener> mListener;
	/* Used by Egl manager. The surface is never displayed */
	sp<Surface> mSurface;
	};


	/* Used to generate valid fences. It is not possible to create a dummy sync
	* fence for testing. Egl can generate buffers along with a valid fence.
	* The buffer cannot be guaranteed to be the same format across all devices so
	* a CPU filled buffer is used instead. The Egl fence is used along with the
	* CPU filled buffer. */
	class Hwc2TestEglManager {
	public:
	Hwc2TestEglManager()
	: mEglDisplay(EGL_NO_DISPLAY),
	mEglSurface(EGL_NO_SURFACE),
	mEglContext(EGL_NO_CONTEXT) { }

	~Hwc2TestEglManager()
	{
	cleanup();
	}

	int initialize(sp<Surface> surface)
	{
	mSurface = surface;

	mEglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	if (mEglDisplay == EGL_NO_DISPLAY) return false;

	EGLint major;
	EGLint minor;
	if (!eglInitialize(mEglDisplay, &major, &minor)) {
	ALOGW("Could not initialize EGL");
	return false;
	}

	/* We're going to use a 1x1 pbuffer surface later on
	* The configuration distance doesn't really matter for what we're
	* trying to do */
	EGLint configAttrs[] = {
	EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
	EGL_RED_SIZE, 8,
	EGL_GREEN_SIZE, 8,
	EGL_BLUE_SIZE, 8,
	EGL_ALPHA_SIZE, 0,
	EGL_DEPTH_SIZE, 24,
	EGL_STENCIL_SIZE, 0,
	EGL_NONE
	};

	EGLConfig configs[1];
	EGLint configCnt;
	if (!eglChooseConfig(mEglDisplay, configAttrs, configs, 1,
	&configCnt)) {
	ALOGW("Could not select EGL configuration");
	eglReleaseThread();
	eglTerminate(mEglDisplay);
	return false;
	}

	if (configCnt <= 0) {
	ALOGW("Could not find EGL configuration");
	eglReleaseThread();
	eglTerminate(mEglDisplay);
	return false;
	}

	/* These objects are initialized below but the default "null" values are
	* used to cleanup properly at any point in the initialization sequence */
	EGLint attrs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE };
	mEglContext = eglCreateContext(mEglDisplay, configs[0], EGL_NO_CONTEXT,
	attrs);
	if (mEglContext == EGL_NO_CONTEXT) {
	ALOGW("Could not create EGL context");
	cleanup();
	return false;
	}

	EGLint surfaceAttrs[] = { EGL_NONE };
	mEglSurface = eglCreateWindowSurface(mEglDisplay, configs[0],
	mSurface.get(), surfaceAttrs);
	if (mEglSurface == EGL_NO_SURFACE) {
	ALOGW("Could not create EGL surface");
	cleanup();
	return false;
	}

	if (!eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
	ALOGW("Could not change current EGL context");
	cleanup();
	return false;
	}

	return true;
	}

	void makeCurrent() const
	{
	eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
	}

	void present() const
	{
	eglSwapBuffers(mEglDisplay, mEglSurface);
	}

	private:
	void cleanup()
	{
	if (mEglDisplay == EGL_NO_DISPLAY)
	return;
	if (mEglSurface != EGL_NO_SURFACE)
	eglDestroySurface(mEglDisplay, mEglSurface);
	if (mEglContext != EGL_NO_CONTEXT)
	eglDestroyContext(mEglDisplay, mEglContext);

	eglMakeCurrent(mEglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE,
	EGL_NO_CONTEXT);
	eglReleaseThread();
	eglTerminate(mEglDisplay);
	}

	sp<Surface> mSurface;
	EGLDisplay mEglDisplay;
	EGLSurface mEglSurface;
	EGLContext mEglContext;
	};


	static const std::array<vec2, 4> triangles = {{
	{ 1.0f, 1.0f },
	{ -1.0f, 1.0f },
	{ 1.0f, -1.0f },
	{ -1.0f, -1.0f },
	}};

	class Hwc2TestFenceGenerator {
	public:

	Hwc2TestFenceGenerator()
	{
	mSurfaceManager.initialize({1, 1}, HAL_PIXEL_FORMAT_RGBA_8888,
	setFence, this);

	if (!mEglManager.initialize(mSurfaceManager.getSurface()))
	return;

	mEglManager.makeCurrent();

	glClearColor(0.0, 0.0, 0.0, 1.0);
	glEnableVertexAttribArray(0);
	}

	~Hwc2TestFenceGenerator()
	{
	if (mFence >= 0)
	close(mFence);
	mFence = -1;

	mEglManager.makeCurrent();
	}

	/* It is not possible to simply generate a fence. The easiest way is to
	* generate a buffer using egl and use the associated fence. The buffer
	* cannot be guaranteed to be a certain format across all devices using this
	* method. Instead the buffer is generated using the CPU */
	int32_t get()
	{
	if (mFence >= 0) {
	return dup(mFence);
	}

	std::unique_lock<std::mutex> lock(mMutex);

	/* If the pending is still set to false and times out, we cannot recover.
	* Set an error and return */
	while (mPending != false) {
	if (mCv.wait_for(lock, std::chrono::seconds(2)) == std::cv_status::timeout)
	return -ETIME;
	}

	/* Generate a fence. The fence will be returned through the setFence
	* callback */
	mEglManager.makeCurrent();

	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, triangles.data());
	glClear(GL_COLOR_BUFFER_BIT);

	mEglManager.present();

	/* Wait for the setFence callback */
	while (mPending != true) {
	if (mCv.wait_for(lock, std::chrono::seconds(2)) == std::cv_status::timeout)
	return -ETIME;
	}

	mPending = false;

	return dup(mFence);
	}

	/* Callback that sets the fence */
	void set(int32_t fence)
	{
	mFence = fence;
	mPending = true;

	mCv.notify_all();
	}

	private:

	Hwc2TestSurfaceManager mSurfaceManager;
	Hwc2TestEglManager mEglManager;

	std::mutex mMutex;
	std::condition_variable mCv;

	int32_t mFence = -1;
	bool mPending = false;
	};


	static void setFence(int32_t fence, void* fenceGenerator)
	{
	static_cast<Hwc2TestFenceGenerator*>(fenceGenerator)->set(fence);
	}


	/* Sets the pixel of a buffer given the location, format, stride and color.
	* Currently only supports RGBA_8888 */
	static void setColor(int32_t x, int32_t y,
	android_pixel_format_t format, uint32_t stride, uint8_t* img, uint8_t r,
	uint8_t g, uint8_t b, uint8_t a)
	{
	switch (format) {
	case HAL_PIXEL_FORMAT_RGBA_8888:
	img[(y * stride + x) * 4 + 0] = r;
	img[(y * stride + x) * 4 + 1] = g;
	img[(y * stride + x) * 4 + 2] = b;
	img[(y * stride + x) * 4 + 3] = a;
	break;
	default:
	break;
	}
	}

	Hwc2TestBuffer::Hwc2TestBuffer()
	: mFenceGenerator(new Hwc2TestFenceGenerator()) { }

	Hwc2TestBuffer::~Hwc2TestBuffer() = default;

	/* When the buffer changes sizes, save the new size and invalidate the current
	* buffer */
	void Hwc2TestBuffer::updateBufferArea(const Area& bufferArea)
	{
	if (mBufferArea.width == bufferArea.width
	&& mBufferArea.height == bufferArea.height)
	return;

	mBufferArea.width = bufferArea.width;
	mBufferArea.height = bufferArea.height;

	mValidBuffer = false;
	}

	/* Returns a valid buffer handle and fence. The handle is filled using the CPU
	* to ensure the correct format across all devices. The fence is created using
	* egl. */
	int Hwc2TestBuffer::get(buffer_handle_t* outHandle, int32_t* outFence)
	{
	if (mBufferArea.width == -1 \|\| mBufferArea.height == -1)
	return -EINVAL;

	/* If the current buffer is valid, the previous buffer can be reused.
	* Otherwise, create new buffer */
	if (!mValidBuffer) {
	int ret = generateBuffer();
	if (ret)
	return ret;
	}

	*outFence = mFenceGenerator->get();
	*outHandle = mHandle;

	mValidBuffer = true;

	return 0;
	}

	/* CPU fills a buffer to guarantee the correct buffer format across all
	* devices */
	int Hwc2TestBuffer::generateBuffer()
	{
	/* Create new graphic buffer with correct dimensions */
	mGraphicBuffer = new GraphicBuffer(mBufferArea.width, mBufferArea.height,
	mFormat, BufferUsage::CPU_READ_OFTEN \| BufferUsage::CPU_WRITE_OFTEN \|
	BufferUsage::COMPOSER_OVERLAY, "hwc2_test_buffer");

	int ret = mGraphicBuffer->initCheck();
	if (ret) {
	return ret;
	}
	if (!mGraphicBuffer->handle) {
	return -EINVAL;
	}

	/* Locks the buffer for writing */
	uint8_t* img;
	mGraphicBuffer->lock(static_cast<uint32_t>(BufferUsage::CPU_WRITE_OFTEN),
	(void**)(&img));

	uint32_t stride = mGraphicBuffer->getStride();

	/* Iterate from the top row of the buffer to the bottom row */
	for (int32_t y = 0; y < mBufferArea.height; y++) {

	/* Will be used as R, G and B values for pixel colors */
	uint8_t max = 255;
	uint8_t min = 0;

	/* Divide the rows into 3 sections. The first section will contain
	* the lighest colors. The last section will contain the darkest
	* colors. */
	if (y < mBufferArea.height * 1.0 / 3.0) {
	min = 255 / 2;
	} else if (y >= mBufferArea.height * 2.0 / 3.0) {
	max = 255 / 2;
	}

	/* Divide the columns into 3 sections. The first section is red,
	* the second is green and the third is blue */
	int32_t x = 0;
	for (; x < mBufferArea.width / 3; x++) {
	setColor(x, y, mFormat, stride, img, max, min, min, 255);
	}

	for (; x < mBufferArea.width * 2 / 3; x++) {
	setColor(x, y, mFormat, stride, img, min, max, min, 255);
	}

	for (; x < mBufferArea.width; x++) {
	setColor(x, y, mFormat, stride, img, min, min, max, 255);
	}
	}

	/* Unlock the buffer for reading */
	mGraphicBuffer->unlock();

	mHandle = mGraphicBuffer->handle;

	return 0;
	}


	Hwc2TestClientTargetBuffer::Hwc2TestClientTargetBuffer()
	: mFenceGenerator(new Hwc2TestFenceGenerator()) { }

	Hwc2TestClientTargetBuffer::~Hwc2TestClientTargetBuffer() { }

	/* Generates a buffer from layersToDraw.
	* Takes into account the individual layer properties such as
	* transform, blend mode, source crop, etc. */
	static void compositeBufferFromLayers(
	const android::sp<android::GraphicBuffer>& graphicBuffer,
	android_pixel_format_t format, const Area& bufferArea,
	const Hwc2TestLayers* testLayers,
	const std::set<hwc2_layer_t>* layersToDraw,
	const std::set<hwc2_layer_t>* clearLayers)
	{
	/* Locks the buffer for writing */
	uint8_t* img;
	graphicBuffer->lock(static_cast<uint32_t>(BufferUsage::CPU_WRITE_OFTEN),
	(void**)(&img));

	uint32_t stride = graphicBuffer->getStride();

	float bWDiv3 = bufferArea.width / 3;
	float bW2Div3 = bufferArea.width * 2 / 3;
	float bHDiv3 = bufferArea.height / 3;
	float bH2Div3 = bufferArea.height * 2 / 3;

	/* Cycle through every pixel in the buffer and determine what color it
	* should be. */
	for (int32_t y = 0; y < bufferArea.height; y++) {
	for (int32_t x = 0; x < bufferArea.width; x++) {

	uint8_t r = 0, g = 0, b = 0;
	float a = 0.0f;

	/* Cycle through each layer from back to front and
	* update the pixel color. */
	for (auto layer = layersToDraw->rbegin();
	layer != layersToDraw->rend(); ++layer) {

	const hwc_rect_t df = testLayers->getDisplayFrame(*layer);

	float dfL = df.left;
	float dfT = df.top;
	float dfR = df.right;
	float dfB = df.bottom;

	/* If the pixel location falls outside of the layer display
	* frame, skip the layer. */
	if (x < dfL \|\| x >= dfR \|\| y < dfT \|\| y >= dfB)
	continue;

	/* If the device has requested the layer be clear, clear
	* the pixel and continue. */
	if (clearLayers->count(*layer) != 0) {
	r = 0;
	g = 0;
	b = 0;
	a = 0.0f;
	continue;
	}

	float planeAlpha = testLayers->getPlaneAlpha(*layer);

	/* If the layer is a solid color, fill the color and
	* continue. */
	if (testLayers->getComposition(*layer)
	== HWC2_COMPOSITION_SOLID_COLOR) {
	const auto color = testLayers->getColor(*layer);
	r = color.r;
	g = color.g;
	b = color.b;
	a = color.a * planeAlpha;
	continue;
	}

	float xPos = x;
	float yPos = y;

	hwc_transform_t transform = testLayers->getTransform(*layer);

	float dfW = dfR - dfL;
	float dfH = dfB - dfT;

	/* If a layer has a transform, find which location on the
	* layer will end up in the current pixel location. We
	* can calculate the color of the current pixel using that
	* location. */
	if (transform > 0) {
	/* Change origin to be the center of the layer. */
	xPos = xPos - dfL - dfW / 2.0;
	yPos = yPos - dfT - dfH / 2.0;

	/* Flip Horizontal by reflecting across the y axis. */
	if (transform & HWC_TRANSFORM_FLIP_H)
	xPos = -xPos;

	/* Flip vertical by reflecting across the x axis. */
	if (transform & HWC_TRANSFORM_FLIP_V)
	yPos = -yPos;

	/* Rotate 90 by using a basic linear algebra rotation
	* and scaling the result so the display frame remains
	* the same. For example, a buffer of size 100x50 should
	* rotate 90 degress but remain the same dimension
	* (100x50) at the end of the transformation. */
	if (transform & HWC_TRANSFORM_ROT_90) {
	float tmp = xPos;
	xPos = yPos * dfW / dfH;
	yPos = -tmp * dfH / dfW;
	}

	/* Change origin back to the top left corner of the
	* layer. */
	xPos = xPos + dfL + dfW / 2.0;
	yPos = yPos + dfT + dfH / 2.0;
	}

	hwc_frect_t sc = testLayers->getSourceCrop(*layer);
	float scL = sc.left, scT = sc.top;

	float dfWDivScW = dfW / (sc.right - scL);
	float dfHDivScH = dfH / (sc.bottom - scT);

	float max = 255, min = 0;

	/* Choose the pixel color. Similar to generateBuffer,
	* each layer will be divided into 3x3 colors. Because
	* both the source crop and display frame must be taken into
	* account, the formulas are more complicated.
	*
	* If the source crop and display frame were not taken into
	* account, we would simply divide the buffer into three
	* sections by height. Each section would get one color.
	* For example the formula for the first section would be:
	*
	* if (yPos < bufferArea.height / 3)
	* //Select first section color
	*
	* However the pixel color is chosen based on the source
	* crop and displayed based on the display frame.
	*
	* If the display frame top was 0 and the source crop height
	* and display frame height were the same. The only factor
	* would be the source crop top. To calculate the new
	* section boundary, the section boundary would be moved up
	* by the height of the source crop top. The formula would
	* be:
	* if (yPos < (bufferArea.height / 3 - sourceCrop.top)
	* //Select first section color
	*
	* If the display frame top could also vary but source crop
	* and display frame heights were the same, the formula
	* would be:
	* if (yPos < (bufferArea.height / 3 - sourceCrop.top
	* + displayFrameTop)
	* //Select first section color
	*
	* If the heights were not the same, the conversion between
	* the source crop and display frame dimensions must be
	* taken into account. The formula would be:
	* if (yPos < ((bufferArea.height / 3) - sourceCrop.top)
	* * displayFrameHeight / sourceCropHeight
	* + displayFrameTop)
	* //Select first section color
	*/
	if (yPos < ((bHDiv3) - scT) * dfHDivScH + dfT) {
	min = 255 / 2;
	} else if (yPos >= ((bH2Div3) - scT) * dfHDivScH + dfT) {
	max = 255 / 2;
	}

	uint8_t rCur = min, gCur = min, bCur = min;
	float aCur = 1.0f;

	/* This further divides the color sections from 3 to 3x3.
	* The math behind it follows the same logic as the previous
	* comment */
	if (xPos < ((bWDiv3) - scL) * (dfWDivScW) + dfL) {
	rCur = max;
	} else if (xPos < ((bW2Div3) - scL) * (dfWDivScW) + dfL) {
	gCur = max;
	} else {
	bCur = max;
	}


	/* Blend the pixel color with the previous layers' pixel
	* colors using the plane alpha and blend mode. The final
	* pixel color is chosen using the plane alpha and blend
	* mode formulas found in hwcomposer2.h */
	hwc2_blend_mode_t blendMode = testLayers->getBlendMode(*layer);

	if (blendMode == HWC2_BLEND_MODE_PREMULTIPLIED) {
	rCur *= planeAlpha;
	gCur *= planeAlpha;
	bCur *= planeAlpha;
	}

	aCur *= planeAlpha;

	if (blendMode == HWC2_BLEND_MODE_PREMULTIPLIED) {
	r = rCur + r * (1.0 - aCur);
	g = gCur + g * (1.0 - aCur);
	b = bCur + b * (1.0 - aCur);
	a = aCur + a * (1.0 - aCur);
	} else if (blendMode == HWC2_BLEND_MODE_COVERAGE) {
	r = rCur * aCur + r * (1.0 - aCur);
	g = gCur * aCur + g * (1.0 - aCur);
	b = bCur * aCur + b * (1.0 - aCur);
	a = aCur * aCur + a * (1.0 - aCur);
	} else {
	r = rCur;
	g = gCur;
	b = bCur;
	a = aCur;
	}
	}

	/* Set the pixel color */
	setColor(x, y, format, stride, img, r, g, b, a * 255);
	}
	}

	graphicBuffer->unlock();
	}

	/* Generates a client target buffer using the layers assigned for client
	* composition. Takes into account the individual layer properties such as
	* transform, blend mode, source crop, etc. */
	int Hwc2TestClientTargetBuffer::get(buffer_handle_t* outHandle,
	int32_t* outFence, const Area& bufferArea,
	const Hwc2TestLayers* testLayers,
	const std::set<hwc2_layer_t>* clientLayers,
	const std::set<hwc2_layer_t>* clearLayers)
	{
	/* Create new graphic buffer with correct dimensions */
	mGraphicBuffer = new GraphicBuffer(bufferArea.width, bufferArea.height,
	mFormat, BufferUsage::CPU_READ_OFTEN \| BufferUsage::CPU_WRITE_OFTEN \|
	BufferUsage::COMPOSER_OVERLAY, "hwc2_test_buffer");

	int ret = mGraphicBuffer->initCheck();
	if (ret)
	return ret;

	if (!mGraphicBuffer->handle)
	return -EINVAL;

	compositeBufferFromLayers(mGraphicBuffer, mFormat, bufferArea, testLayers,
	clientLayers, clearLayers);

	*outFence = mFenceGenerator->get();
	*outHandle = mGraphicBuffer->handle;

	return 0;
	}

	void Hwc2TestVirtualBuffer::updateBufferArea(const Area& bufferArea)
	{
	mBufferArea.width = bufferArea.width;
	mBufferArea.height = bufferArea.height;
	}

	bool Hwc2TestVirtualBuffer::writeBufferToFile(std::string path)
	{
	SkFILEWStream file(path.c_str());
	const SkImageInfo info = SkImageInfo::Make(mBufferArea.width,
	mBufferArea.height, SkColorType::kRGBA_8888_SkColorType,
	SkAlphaType::kPremul_SkAlphaType);

	uint8_t* img;
	mGraphicBuffer->lock(static_cast<uint32_t>(BufferUsage::CPU_WRITE_OFTEN),
	(void**)(&img));

	SkPixmap pixmap(info, img, mGraphicBuffer->getStride());
	bool result = file.isValid() && SkEncodeImage(&file, pixmap,
	SkEncodedImageFormat::kPNG, 100);

	mGraphicBuffer->unlock();
	return result;
	}

	/* Generates a buffer that holds the expected result of compositing all of our
	* layers */
	int Hwc2TestExpectedBuffer::generateExpectedBuffer(
	const Hwc2TestLayers* testLayers,
	const std::vector<hwc2_layer_t>* allLayers,
	const std::set<hwc2_layer_t>* clearLayers)
	{
	mGraphicBuffer = new GraphicBuffer(mBufferArea.width, mBufferArea.height,
	mFormat, BufferUsage::CPU_READ_OFTEN \| BufferUsage::CPU_WRITE_OFTEN,
	"hwc2_test_buffer");

	int ret = mGraphicBuffer->initCheck();
	if (ret)
	return ret;

	if (!mGraphicBuffer->handle)
	return -EINVAL;

	const std::set<hwc2_layer_t> allLayerSet(allLayers->begin(),
	allLayers->end());

	compositeBufferFromLayers(mGraphicBuffer, mFormat, mBufferArea, testLayers,
	&allLayerSet, clearLayers);

	return 0;
	}

	int Hwc2TestOutputBuffer::getOutputBuffer(buffer_handle_t* outHandle,
	int32_t* outFence)
	{
	if (mBufferArea.width == -1 \|\| mBufferArea.height == -1)
	return -EINVAL;

	mGraphicBuffer = new GraphicBuffer(mBufferArea.width, mBufferArea.height,
	mFormat, BufferUsage::CPU_READ_OFTEN \|
	BufferUsage::GPU_RENDER_TARGET, "hwc2_test_buffer");

	int ret = mGraphicBuffer->initCheck();
	if (ret)
	return ret;

	if (!mGraphicBuffer->handle)
	return -EINVAL;

	*outFence = -1;
	*outHandle = mGraphicBuffer->handle;

	return 0;
	}