composer/gl_layer_stitch_impl.cpp - platform/hardware/qcom/display - Gitiles

 /*
  * Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
     * Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
     * Redistributions in binary form must reproduce the above
       copyright notice, this list of conditions and the following
       disclaimer in the documentation and/or other materials provided
       with the distribution.
     * Neither the name of The Linux Foundation nor the names of its
       contributors may be used to endorse or promote products derived
       from this software without specific prior written permission.

  * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
  * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include <vector>

 #include "gl_layer_stitch_impl.h"

 #define __CLASS__ "GLLayerStitchImpl"

 namespace sdm {

 const float kFullScreenVertices[] = {
   -1.0f,  3.0f,
   -1.0f, -1.0f,
   3.0f, -1.0f
 };

 const float kFullScreenTexCoords[] = {
   0.0f, 2.0f,
   0.0f, 0.0f,
   2.0f, 0.0f
 };

 const char *kVertexShader1 = ""
   "#version 300 es                                                       \n"
   "precision highp float;                                                \n"
   "layout(location = 0) in vec2 in_pos;                                  \n"
   "layout(location = 1) in vec2 in_uv;                                   \n"
   "                                                                      \n"
   "out vec2 uv;                                                          \n"
   "                                                                      \n"
   "void main()                                                           \n"
   "{                                                                     \n"
   "    gl_Position = vec4(in_pos, 0.0, 1.0);                             \n"
   "    uv = in_uv;                                                       \n"
   "}                                                                     \n";

 const char *kConvertRenderRGBShader = ""
   "precision highp float;                                                \n"
   "                                                                      \n"
   "layout(binding = 0) uniform sampler2D u_sTexture;                     \n"
   "                                                                      \n"
   "in vec2 uv;                                                           \n"
   "out vec4 color;                                                       \n"
   "                                                                      \n"
   "void main()                                                           \n"
   "{                                                                     \n"
   "    color = texture(u_sTexture, uv);                                  \n"
   "}                                                                     \n";

 static bool IsValid(const GLRect &rect) {
   return ((rect.right - rect.left) && (rect.bottom - rect.top));
 }

 int GLLayerStitchImpl::CreateContext(bool secure) {
   ctx_.egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
   EGL(eglBindAPI(EGL_OPENGL_ES_API));

   // Initialize current display.
   EGL(eglInitialize(ctx_.egl_display, nullptr, nullptr));

   // Get attributes corresponing to render target.
   // Describes Framebuffer attributes like buffer depth, color space etc;
   EGLConfig eglConfig;
   int numConfig = 0;
   EGLint eglConfigAttribList[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
                                   EGL_RED_SIZE,     8,
                                   EGL_GREEN_SIZE,   8,
                                   EGL_BLUE_SIZE,    8,
                                   EGL_ALPHA_SIZE,   8,
                                   EGL_NONE};
   EGL(eglChooseConfig(ctx_.egl_display, eglConfigAttribList, &eglConfig, 1, &numConfig));

   // When GPU runs in protected context it can read from
   //  - Protected sources
   //  - UnProtected source
   // and writes into Protected buffer.
   // VS in UnProtected context it can read/write happen from/to Unprotected sources.
   EGLint egl_contextAttribList[] = {EGL_CONTEXT_CLIENT_VERSION, 3,
                                     secure ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
                                     secure ? EGL_TRUE : EGL_NONE,
                                     EGL_NONE};
   ctx_.egl_context = eglCreateContext(ctx_.egl_display, eglConfig, NULL, egl_contextAttribList);

   // eglCreatePbufferSurface creates an off-screen pixel buffer surface and returns its handle
   EGLint egl_surfaceAttribList[] = {EGL_WIDTH, 1,
                                     EGL_HEIGHT, 1,
                                     secure ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
                                     secure ? EGL_TRUE : EGL_NONE,
                                     EGL_NONE};
   ctx_.egl_surface = eglCreatePbufferSurface(ctx_.egl_display, eglConfig, egl_surfaceAttribList);

   // eglMakeCurrent attaches rendering context to rendering surface.
   MakeCurrent(&ctx_);

   DLOGI("Created context = %p", (void *)(&ctx_.egl_context));

   // Load Vertex and Fragment shaders.
   const char *fragment_shaders[2] = { };
   int count = 0;
   const char *version = "#version 300 es\n";

   fragment_shaders[count++] = version;

   // ToDo: Add support to yuv_to_rgb shader.
   fragment_shaders[count++] = kConvertRenderRGBShader;

   ctx_.program_id = LoadProgram(1, &kVertexShader1, count, fragment_shaders);

   SetRealTimePriority();
   InitContext();

   return 0;
 }

 int GLLayerStitchImpl::Blit(const std::vector<StitchParams> &stitch_params,
                             shared_ptr<Fence> *release_fence) {
   DTRACE_SCOPED();

   std::vector<shared_ptr<Fence>> acquire_fences;
   std::vector<shared_ptr<Fence>> release_fences;
   bool can_batch = !NeedsGLScissor(stitch_params);
   for (auto &info : stitch_params) {
     SetSourceBuffer(info.src_hnd);
     SetDestinationBuffer(info.dst_hnd);
     SetViewport(info.dst_rect);
     ClearWithTransparency(info.scissor_rect);
     glDrawArrays(GL_TRIANGLES, 0, 3);

     acquire_fences.push_back(info.src_acquire_fence);

     if (!can_batch) {
       // Trigger flush and cache release fence.
       WaitOnInputFence(acquire_fences);
       shared_ptr<Fence> temp_release_fence = nullptr;
       CreateOutputFence(&temp_release_fence);
       release_fences.push_back(temp_release_fence);
       acquire_fences = {};
     }
   }

   if (can_batch) {
     // Create output fence for client to wait on.
     WaitOnInputFence(acquire_fences);
     CreateOutputFence(release_fence);
   } else {
     // Merge all fd's and return one.
     *release_fence = Fence::Merge(release_fences, false);
   }

   return 0;
 }

 int GLLayerStitchImpl::NeedsGLScissor(const std::vector<StitchParams> &stitch_params) {
   for (auto &info : stitch_params) {
     if (IsValid(info.scissor_rect)) {
       return true;
     }
   }

   return false;
 }

 int GLLayerStitchImpl::Init() {
   return CreateContext(secure_);
 }

 int GLLayerStitchImpl::Deinit() {
   MakeCurrent(&ctx_);
   DestroyContext(&ctx_);

   return 0;
 }

 void GLLayerStitchImpl::ClearWithTransparency(const GLRect &scissor_rect) {
   if (!IsValid(scissor_rect)) {
     // Disable scissor.
     GL(glDisable(GL_SCISSOR_TEST));
     return;
   }

   DTRACE_SCOPED();
   // Enable scissor test.
   GL(glEnable(GL_SCISSOR_TEST));
   GL(glScissor(scissor_rect.left, scissor_rect.top, scissor_rect.right - scissor_rect.left,
                scissor_rect.bottom - scissor_rect.top));
   GL(glClearColor(0, 0, 0, 0));
   GL(glClear(GL_COLOR_BUFFER_BIT));
 }

 void GLLayerStitchImpl::InitContext() {
   // eglMakeCurrent attaches rendering context to rendering surface.
   MakeCurrent(&ctx_);
   SetProgram(ctx_.program_id);
   SetRealTimePriority();
   // Set vertices.
   glEnableVertexAttribArray(0);
   glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, kFullScreenVertices);
   glEnableVertexAttribArray(1);
   glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, kFullScreenTexCoords);
 }

 GLLayerStitchImpl::~GLLayerStitchImpl() {}

 GLLayerStitchImpl::GLLayerStitchImpl(bool secure) {
   secure_ = secure;
 }

 }  // namespace sdm
	/*
	* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are
	* met:
	* Redistributions of source code must retain the above copyright
	notice, this list of conditions and the following disclaimer.
	* Redistributions in binary form must reproduce the above
	copyright notice, this list of conditions and the following
	disclaimer in the documentation and/or other materials provided
	with the distribution.
	* Neither the name of The Linux Foundation nor the names of its
	contributors may be used to endorse or promote products derived
	from this software without specific prior written permission.

	* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS
	* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
	* OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
	* IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include <vector>

	#include "gl_layer_stitch_impl.h"

	#define __CLASS__ "GLLayerStitchImpl"

	namespace sdm {

	const float kFullScreenVertices[] = {
	-1.0f, 3.0f,
	-1.0f, -1.0f,
	3.0f, -1.0f
	};

	const float kFullScreenTexCoords[] = {
	0.0f, 2.0f,
	0.0f, 0.0f,
	2.0f, 0.0f
	};

	const char *kVertexShader1 = ""
	"#version 300 es \n"
	"precision highp float; \n"
	"layout(location = 0) in vec2 in_pos; \n"
	"layout(location = 1) in vec2 in_uv; \n"
	" \n"
	"out vec2 uv; \n"
	" \n"
	"void main() \n"
	"{ \n"
	" gl_Position = vec4(in_pos, 0.0, 1.0); \n"
	" uv = in_uv; \n"
	"} \n";

	const char *kConvertRenderRGBShader = ""
	"precision highp float; \n"
	" \n"
	"layout(binding = 0) uniform sampler2D u_sTexture; \n"
	" \n"
	"in vec2 uv; \n"
	"out vec4 color; \n"
	" \n"
	"void main() \n"
	"{ \n"
	" color = texture(u_sTexture, uv); \n"
	"} \n";

	static bool IsValid(const GLRect &rect) {
	return ((rect.right - rect.left) && (rect.bottom - rect.top));
	}

	int GLLayerStitchImpl::CreateContext(bool secure) {
	ctx_.egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
	EGL(eglBindAPI(EGL_OPENGL_ES_API));

	// Initialize current display.
	EGL(eglInitialize(ctx_.egl_display, nullptr, nullptr));

	// Get attributes corresponing to render target.
	// Describes Framebuffer attributes like buffer depth, color space etc;
	EGLConfig eglConfig;
	int numConfig = 0;
	EGLint eglConfigAttribList[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
	EGL_RED_SIZE, 8,
	EGL_GREEN_SIZE, 8,
	EGL_BLUE_SIZE, 8,
	EGL_ALPHA_SIZE, 8,
	EGL_NONE};
	EGL(eglChooseConfig(ctx_.egl_display, eglConfigAttribList, &eglConfig, 1, &numConfig));

	// When GPU runs in protected context it can read from
	// - Protected sources
	// - UnProtected source
	// and writes into Protected buffer.
	// VS in UnProtected context it can read/write happen from/to Unprotected sources.
	EGLint egl_contextAttribList[] = {EGL_CONTEXT_CLIENT_VERSION, 3,
	secure ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
	secure ? EGL_TRUE : EGL_NONE,
	EGL_NONE};
	ctx_.egl_context = eglCreateContext(ctx_.egl_display, eglConfig, NULL, egl_contextAttribList);

	// eglCreatePbufferSurface creates an off-screen pixel buffer surface and returns its handle
	EGLint egl_surfaceAttribList[] = {EGL_WIDTH, 1,
	EGL_HEIGHT, 1,
	secure ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
	secure ? EGL_TRUE : EGL_NONE,
	EGL_NONE};
	ctx_.egl_surface = eglCreatePbufferSurface(ctx_.egl_display, eglConfig, egl_surfaceAttribList);

	// eglMakeCurrent attaches rendering context to rendering surface.
	MakeCurrent(&ctx_);

	DLOGI("Created context = %p", (void *)(&ctx_.egl_context));

	// Load Vertex and Fragment shaders.
	const char *fragment_shaders[2] = { };
	int count = 0;
	const char *version = "#version 300 es\n";

	fragment_shaders[count++] = version;

	// ToDo: Add support to yuv_to_rgb shader.
	fragment_shaders[count++] = kConvertRenderRGBShader;

	ctx_.program_id = LoadProgram(1, &kVertexShader1, count, fragment_shaders);

	SetRealTimePriority();
	InitContext();

	return 0;
	}

	int GLLayerStitchImpl::Blit(const std::vector<StitchParams> &stitch_params,
	shared_ptr<Fence> *release_fence) {
	DTRACE_SCOPED();

	std::vector<shared_ptr<Fence>> acquire_fences;
	std::vector<shared_ptr<Fence>> release_fences;
	bool can_batch = !NeedsGLScissor(stitch_params);
	for (auto &info : stitch_params) {
	SetSourceBuffer(info.src_hnd);
	SetDestinationBuffer(info.dst_hnd);
	SetViewport(info.dst_rect);
	ClearWithTransparency(info.scissor_rect);
	glDrawArrays(GL_TRIANGLES, 0, 3);

	acquire_fences.push_back(info.src_acquire_fence);

	if (!can_batch) {
	// Trigger flush and cache release fence.
	WaitOnInputFence(acquire_fences);
	shared_ptr<Fence> temp_release_fence = nullptr;
	CreateOutputFence(&temp_release_fence);
	release_fences.push_back(temp_release_fence);
	acquire_fences = {};
	}
	}

	if (can_batch) {
	// Create output fence for client to wait on.
	WaitOnInputFence(acquire_fences);
	CreateOutputFence(release_fence);
	} else {
	// Merge all fd's and return one.
	*release_fence = Fence::Merge(release_fences, false);
	}

	return 0;
	}

	int GLLayerStitchImpl::NeedsGLScissor(const std::vector<StitchParams> &stitch_params) {
	for (auto &info : stitch_params) {
	if (IsValid(info.scissor_rect)) {
	return true;
	}
	}

	return false;
	}

	int GLLayerStitchImpl::Init() {
	return CreateContext(secure_);
	}

	int GLLayerStitchImpl::Deinit() {
	MakeCurrent(&ctx_);
	DestroyContext(&ctx_);

	return 0;
	}

	void GLLayerStitchImpl::ClearWithTransparency(const GLRect &scissor_rect) {
	if (!IsValid(scissor_rect)) {
	// Disable scissor.
	GL(glDisable(GL_SCISSOR_TEST));
	return;
	}

	DTRACE_SCOPED();
	// Enable scissor test.
	GL(glEnable(GL_SCISSOR_TEST));
	GL(glScissor(scissor_rect.left, scissor_rect.top, scissor_rect.right - scissor_rect.left,
	scissor_rect.bottom - scissor_rect.top));
	GL(glClearColor(0, 0, 0, 0));
	GL(glClear(GL_COLOR_BUFFER_BIT));
	}

	void GLLayerStitchImpl::InitContext() {
	// eglMakeCurrent attaches rendering context to rendering surface.
	MakeCurrent(&ctx_);
	SetProgram(ctx_.program_id);
	SetRealTimePriority();
	// Set vertices.
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, kFullScreenVertices);
	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, kFullScreenTexCoords);
	}

	GLLayerStitchImpl::~GLLayerStitchImpl() {}

	GLLayerStitchImpl::GLLayerStitchImpl(bool secure) {
	secure_ = secure;
	}

	} // namespace sdm