host/tests/TextureDraw_unittest.cpp - platform/hardware/google/gfxstream - Git at Google

 // Copyright (C) 2018 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 <gtest/gtest.h>

 #include "GLTestUtils.h"
 #include "OpenGLTestContext.h"
 #include "TextureDraw.h"

 namespace gfxstream {
 namespace gl {
 namespace {

 void TestTextureDrawBasic(const GLESv2Dispatch* gl, GLenum internalformat,
                           GLenum format, bool should_work) {
     GLint viewport[4] = {};
     gl->glGetIntegerv(GL_VIEWPORT, viewport);
     EXPECT_EQ(0, viewport[0]);
     EXPECT_EQ(0, viewport[1]);
     const int width = viewport[2];
     const int height = viewport[3];
     const GLenum type = GL_UNSIGNED_BYTE;
     const int bpp = 4;
     const int bytes = width * height * bpp;

     GLuint textureToDraw;

     gl->glGenTextures(1, &textureToDraw);
     gl->glActiveTexture(GL_TEXTURE0);
     gl->glBindTexture(GL_TEXTURE_2D, textureToDraw);

     gl->glPixelStorei(GL_PACK_ALIGNMENT, 1);
     gl->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     gl->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

     std::vector<unsigned char> pixels(bytes);

     for (int i = 0; i < height; i++) {
         for (int j = 0; j < width; j++) {
             pixels[i * width * bpp + j * bpp + 0] = (0xaa + i) % 0x100;
             pixels[i * width * bpp + j * bpp + 1] = (0x00 + j) % 0x100;
             pixels[i * width * bpp + j * bpp + 2] = (0x11 + i) % 0x100;
             // Use 0xff for alpha blending.
             pixels[i * width * bpp + j * bpp + 3] = 0xff;
         }
     }
     GLenum err = gl->glGetError();
     EXPECT_EQ(GL_NO_ERROR, err);
     gl->glTexImage2D(GL_TEXTURE_2D, 0, internalformat, width, height, 0,
                      format, type, pixels.data());
     err = gl->glGetError();
     if (should_work) {
         EXPECT_EQ(GL_NO_ERROR, err);
     } else {
         EXPECT_NE(GL_NO_ERROR, err);
         return;
     }
     gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

     GLint fbStatus = gl->glCheckFramebufferStatus(GL_FRAMEBUFFER);
     EXPECT_EQ((GLint)GL_FRAMEBUFFER_COMPLETE, fbStatus);

     TextureDraw textureDraw;

     textureDraw.draw(textureToDraw, 0, 0, 0);

     std::vector<unsigned char> pixelsOut(bytes, 0xff);

     gl->glReadPixels(0, 0, width, height, format, type, pixelsOut.data());

     // Check that the texture is drawn upside down (because that's what SurfaceFlinger wants)
     for (int i = 0; i < height; i++) {
         size_t rowBytes = width * bpp;
         EXPECT_TRUE(RowMatches(i, width * bpp,
                                pixels.data() + i * rowBytes,
                                pixelsOut.data() + (height - i - 1) * rowBytes));
     }
 }

 void TestTextureDrawLayer(const GLESv2Dispatch* gl) {
     GLint viewport[4] = {};
     gl->glGetIntegerv(GL_VIEWPORT, viewport);
     EXPECT_EQ(0, viewport[0]);
     EXPECT_EQ(0, viewport[1]);
     const int width = viewport[2];
     const int height = viewport[3];
     const GLenum type = GL_UNSIGNED_BYTE;
     const int bpp = 4;
     const int bytes = width * height * bpp;

     GLuint textureToDraw;

     gl->glGenTextures(1, &textureToDraw);
     gl->glActiveTexture(GL_TEXTURE0);
     gl->glBindTexture(GL_TEXTURE_2D, textureToDraw);

     gl->glPixelStorei(GL_PACK_ALIGNMENT, 1);
     gl->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
     gl->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

     std::vector<unsigned char> pixels(bytes);

     for (int i = 0; i < height; i++) {
         for (int j = 0; j < width; j++) {
             pixels[i * width * bpp + j * bpp + 0] = 0xff;
             pixels[i * width * bpp + j * bpp + 1] = 0x0;
             pixels[i * width * bpp + j * bpp + 2] = 0x0;
             pixels[i * width * bpp + j * bpp + 3] = 0xff;
         }
     }
     GLenum err = gl->glGetError();
     EXPECT_EQ(GL_NO_ERROR, err);
     gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
                      GL_RGBA, type, pixels.data());
     err = gl->glGetError();
     EXPECT_EQ(GL_NO_ERROR, err);
     gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

     GLint fbStatus = gl->glCheckFramebufferStatus(GL_FRAMEBUFFER);
     EXPECT_EQ((GLint)GL_FRAMEBUFFER_COMPLETE, fbStatus);

     TextureDraw textureDraw;

     // Test HWC2_COMPOSITION_SOLID_COLOR mode, red color
     ComposeLayer l = {0,
                       HWC2_COMPOSITION_SOLID_COLOR,
                       {0, 0, width, height},
                       {0.0, 0.0, (float)width, (float)height},
                       HWC2_BLEND_MODE_NONE,
                       1.0,
                       {255, 0, 0, 255},
                       (hwc_transform_t)0};
     textureDraw.prepareForDrawLayer();
     textureDraw.drawLayer(l, width, height, width, height, textureToDraw);
     std::vector<unsigned char> pixelsOut(bytes, 0xff);
     gl->glReadPixels(0, 0, width, height, GL_RGBA, type, pixelsOut.data());
     EXPECT_TRUE(ImageMatches(width, height, bpp, width,
                              pixels.data(), pixelsOut.data()));


     // Test HWC2_COMPOSITION_DEVICE mode, blue texture
     for (int i = 0; i < height; i++) {
         for (int j = 0; j < width; j++) {
             pixels[i * width * bpp + j * bpp + 0] = 0x0;
             pixels[i * width * bpp + j * bpp + 1] = 0x0;
             pixels[i * width * bpp + j * bpp + 2] = 0xff;
             pixels[i * width * bpp + j * bpp + 3] = 0xff;
         }
     }
     err = gl->glGetError();
     EXPECT_EQ(GL_NO_ERROR, err);
     gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
                      GL_RGBA, type, pixels.data());
     l.composeMode = HWC2_COMPOSITION_DEVICE;
     textureDraw.drawLayer(l, width, height, width, height, textureToDraw);
     gl->glReadPixels(0, 0, width, height, GL_RGBA, type, pixelsOut.data());
     EXPECT_TRUE(ImageMatches(width, height, bpp, width,
                              pixels.data(), pixelsOut.data()));


     // Test composing 2 layers, layer1 draws blue to the upper half frame;
     // layer2 draws the bottom half of the texture to the bottom half frame
     ComposeLayer l1 = {0,
                        HWC2_COMPOSITION_SOLID_COLOR,
                        {0, 0, width, height/2},
                        {0.0, 0.0, (float)width, (float)height/2},
                        HWC2_BLEND_MODE_NONE,
                        1.0,
                        {0, 0, 255, 255},
                        (hwc_transform_t)0};
     ComposeLayer l2 = {0,
                        HWC2_COMPOSITION_DEVICE,
                        {0, height/2, width, height},
                        {0.0, (float)height/2, (float)width, (float)height},
                        HWC2_BLEND_MODE_NONE,
                        1.0,
                        {0, 0, 0, 0},
                        (hwc_transform_t)0};
     for (int i = 0; i < height; i++) {
         for (int j = 0; j < width; j++) {
             // texture bottom half green
             if (i >= height/2) {
                 pixels[i * width * bpp + j * bpp + 0] = 0x0;
                 pixels[i * width * bpp + j * bpp + 2] = 0xff;
             }
         }
     }
     gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
                      GL_RGBA, type, pixels.data());
     textureDraw.drawLayer(l1, width, height, width, height, textureToDraw);
     textureDraw.drawLayer(l2, width, height, width, height, textureToDraw);
     gl->glReadPixels(0, 0, width, height, GL_RGBA, type, pixelsOut.data());
     EXPECT_TRUE(ImageMatches(width, height, bpp, width,
                              pixels.data(), pixelsOut.data()));

 }

 #define GL_BGRA_EXT 0x80E1

 TEST_F(GLTest, TextureDrawBasic) {
     TestTextureDrawBasic(gl, GL_RGBA, GL_RGBA, true);
     // Assumes BGRA is supported
     // Note: On NVIDIA EGL, the format mismatch with RGBA cauases a failure.
     // TestTextureDrawBasic(gl, GL_BGRA_EXT, GL_BGRA_EXT, true);
     // TestTextureDrawBasic(gl, GL_RGBA, GL_BGRA_EXT, false);
     TestTextureDrawLayer(gl);
 }

 }  // namespace
 }  // namespace gl
 }  // namespace gfxstream
	// Copyright (C) 2018 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 <gtest/gtest.h>

	#include "GLTestUtils.h"
	#include "OpenGLTestContext.h"
	#include "TextureDraw.h"

	namespace gfxstream {
	namespace gl {
	namespace {

	void TestTextureDrawBasic(const GLESv2Dispatch* gl, GLenum internalformat,
	GLenum format, bool should_work) {
	GLint viewport[4] = {};
	gl->glGetIntegerv(GL_VIEWPORT, viewport);
	EXPECT_EQ(0, viewport[0]);
	EXPECT_EQ(0, viewport[1]);
	const int width = viewport[2];
	const int height = viewport[3];
	const GLenum type = GL_UNSIGNED_BYTE;
	const int bpp = 4;
	const int bytes = width * height * bpp;

	GLuint textureToDraw;

	gl->glGenTextures(1, &textureToDraw);
	gl->glActiveTexture(GL_TEXTURE0);
	gl->glBindTexture(GL_TEXTURE_2D, textureToDraw);

	gl->glPixelStorei(GL_PACK_ALIGNMENT, 1);
	gl->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	gl->glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);

	std::vector<unsigned char> pixels(bytes);

	for (int i = 0; i < height; i++) {
	for (int j = 0; j < width; j++) {
	pixels[i * width * bpp + j * bpp + 0] = (0xaa + i) % 0x100;
	pixels[i * width * bpp + j * bpp + 1] = (0x00 + j) % 0x100;
	pixels[i * width * bpp + j * bpp + 2] = (0x11 + i) % 0x100;
	// Use 0xff for alpha blending.
	pixels[i * width * bpp + j * bpp + 3] = 0xff;
	}
	}
	GLenum err = gl->glGetError();
	EXPECT_EQ(GL_NO_ERROR, err);
	gl->glTexImage2D(GL_TEXTURE_2D, 0, internalformat, width, height, 0,
	format, type, pixels.data());
	err = gl->glGetError();
	if (should_work) {
	EXPECT_EQ(GL_NO_ERROR, err);
	} else {
	EXPECT_NE(GL_NO_ERROR, err);
	return;
	}
	gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	GLint fbStatus = gl->glCheckFramebufferStatus(GL_FRAMEBUFFER);
	EXPECT_EQ((GLint)GL_FRAMEBUFFER_COMPLETE, fbStatus);

	TextureDraw textureDraw;

	textureDraw.draw(textureToDraw, 0, 0, 0);

	std::vector<unsigned char> pixelsOut(bytes, 0xff);

	gl->glReadPixels(0, 0, width, height, format, type, pixelsOut.data());

	// Check that the texture is drawn upside down (because that's what SurfaceFlinger wants)
	for (int i = 0; i < height; i++) {
	size_t rowBytes = width * bpp;
	EXPECT_TRUE(RowMatches(i, width * bpp,
	pixels.data() + i * rowBytes,
	pixelsOut.data() + (height - i - 1) * rowBytes));
	}
	}

	void TestTextureDrawLayer(const GLESv2Dispatch* gl) {
	GLint viewport[4] = {};
	gl->glGetIntegerv(GL_VIEWPORT, viewport);
	EXPECT_EQ(0, viewport[0]);
	EXPECT_EQ(0, viewport[1]);
	const int width = viewport[2];
	const int height = viewport[3];
	const GLenum type = GL_UNSIGNED_BYTE;
	const int bpp = 4;
	const int bytes = width * height * bpp;

	GLuint textureToDraw;

	gl->glGenTextures(1, &textureToDraw);
	gl->glActiveTexture(GL_TEXTURE0);
	gl->glBindTexture(GL_TEXTURE_2D, textureToDraw);

	gl->glPixelStorei(GL_PACK_ALIGNMENT, 1);
	gl->glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	gl->glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);

	std::vector<unsigned char> pixels(bytes);

	for (int i = 0; i < height; i++) {
	for (int j = 0; j < width; j++) {
	pixels[i * width * bpp + j * bpp + 0] = 0xff;
	pixels[i * width * bpp + j * bpp + 1] = 0x0;
	pixels[i * width * bpp + j * bpp + 2] = 0x0;
	pixels[i * width * bpp + j * bpp + 3] = 0xff;
	}
	}
	GLenum err = gl->glGetError();
	EXPECT_EQ(GL_NO_ERROR, err);
	gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
	GL_RGBA, type, pixels.data());
	err = gl->glGetError();
	EXPECT_EQ(GL_NO_ERROR, err);
	gl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	GLint fbStatus = gl->glCheckFramebufferStatus(GL_FRAMEBUFFER);
	EXPECT_EQ((GLint)GL_FRAMEBUFFER_COMPLETE, fbStatus);

	TextureDraw textureDraw;

	// Test HWC2_COMPOSITION_SOLID_COLOR mode, red color
	ComposeLayer l = {0,
	HWC2_COMPOSITION_SOLID_COLOR,
	{0, 0, width, height},
	{0.0, 0.0, (float)width, (float)height},
	HWC2_BLEND_MODE_NONE,
	1.0,
	{255, 0, 0, 255},
	(hwc_transform_t)0};
	textureDraw.prepareForDrawLayer();
	textureDraw.drawLayer(l, width, height, width, height, textureToDraw);
	std::vector<unsigned char> pixelsOut(bytes, 0xff);
	gl->glReadPixels(0, 0, width, height, GL_RGBA, type, pixelsOut.data());
	EXPECT_TRUE(ImageMatches(width, height, bpp, width,
	pixels.data(), pixelsOut.data()));


	// Test HWC2_COMPOSITION_DEVICE mode, blue texture
	for (int i = 0; i < height; i++) {
	for (int j = 0; j < width; j++) {
	pixels[i * width * bpp + j * bpp + 0] = 0x0;
	pixels[i * width * bpp + j * bpp + 1] = 0x0;
	pixels[i * width * bpp + j * bpp + 2] = 0xff;
	pixels[i * width * bpp + j * bpp + 3] = 0xff;
	}
	}
	err = gl->glGetError();
	EXPECT_EQ(GL_NO_ERROR, err);
	gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
	GL_RGBA, type, pixels.data());
	l.composeMode = HWC2_COMPOSITION_DEVICE;
	textureDraw.drawLayer(l, width, height, width, height, textureToDraw);
	gl->glReadPixels(0, 0, width, height, GL_RGBA, type, pixelsOut.data());
	EXPECT_TRUE(ImageMatches(width, height, bpp, width,
	pixels.data(), pixelsOut.data()));


	// Test composing 2 layers, layer1 draws blue to the upper half frame;
	// layer2 draws the bottom half of the texture to the bottom half frame
	ComposeLayer l1 = {0,
	HWC2_COMPOSITION_SOLID_COLOR,
	{0, 0, width, height/2},
	{0.0, 0.0, (float)width, (float)height/2},
	HWC2_BLEND_MODE_NONE,
	1.0,
	{0, 0, 255, 255},
	(hwc_transform_t)0};
	ComposeLayer l2 = {0,
	HWC2_COMPOSITION_DEVICE,
	{0, height/2, width, height},
	{0.0, (float)height/2, (float)width, (float)height},
	HWC2_BLEND_MODE_NONE,
	1.0,
	{0, 0, 0, 0},
	(hwc_transform_t)0};
	for (int i = 0; i < height; i++) {
	for (int j = 0; j < width; j++) {
	// texture bottom half green
	if (i >= height/2) {
	pixels[i * width * bpp + j * bpp + 0] = 0x0;
	pixels[i * width * bpp + j * bpp + 2] = 0xff;
	}
	}
	}
	gl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0,
	GL_RGBA, type, pixels.data());
	textureDraw.drawLayer(l1, width, height, width, height, textureToDraw);
	textureDraw.drawLayer(l2, width, height, width, height, textureToDraw);
	gl->glReadPixels(0, 0, width, height, GL_RGBA, type, pixelsOut.data());
	EXPECT_TRUE(ImageMatches(width, height, bpp, width,
	pixels.data(), pixelsOut.data()));

	}

	#define GL_BGRA_EXT 0x80E1

	TEST_F(GLTest, TextureDrawBasic) {
	TestTextureDrawBasic(gl, GL_RGBA, GL_RGBA, true);
	// Assumes BGRA is supported
	// Note: On NVIDIA EGL, the format mismatch with RGBA cauases a failure.
	// TestTextureDrawBasic(gl, GL_BGRA_EXT, GL_BGRA_EXT, true);
	// TestTextureDrawBasic(gl, GL_RGBA, GL_BGRA_EXT, false);
	TestTextureDrawLayer(gl);
	}

	} // namespace
	} // namespace gl
	} // namespace gfxstream