*/
#define ATRACE_TAG ATRACE_TAG_GRAPHICS
-#define LOG_TAG "GLWorker"
+#define LOG_TAG "hwc-gl-worker"
#include <algorithm>
#include <string>
#include <utils/Trace.h>
+#include "drmdisplaycomposition.h"
+
#include "glworker.h"
#include "seperate_rects.h"
return shader;
}
+static std::string GenerateVertexShader(int layer_count) {
+ std::ostringstream vertex_shader_stream;
+ vertex_shader_stream
+ << "#version 300 es\n"
+ << "#define LAYER_COUNT " << layer_count << "\n"
+ << "precision mediump int;\n"
+ << "uniform vec4 uViewport;\n"
+ << "uniform vec4 uLayerCrop[LAYER_COUNT];\n"
+ << "uniform mat2 uTexMatrix[LAYER_COUNT];\n"
+ << "in vec2 vPosition;\n"
+ << "in vec2 vTexCoords;\n"
+ << "out vec2 fTexCoords[LAYER_COUNT];\n"
+ << "void main() {\n"
+ << " for (int i = 0; i < LAYER_COUNT; i++) {\n"
+ << " vec2 tempCoords = vTexCoords * uTexMatrix[i];\n"
+ << " fTexCoords[i] =\n"
+ << " uLayerCrop[i].xy + tempCoords * uLayerCrop[i].zw;\n"
+ << " }\n"
+ << " vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw;\n"
+ << " gl_Position =\n"
+ << " vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0);\n"
+ << "}\n";
+ return vertex_shader_stream.str();
+}
+
+static std::string GenerateFragmentShader(int layer_count) {
+ std::ostringstream fragment_shader_stream;
+ fragment_shader_stream << "#version 300 es\n"
+ << "#define LAYER_COUNT " << layer_count << "\n"
+ << "#extension GL_OES_EGL_image_external : require\n"
+ << "precision mediump float;\n";
+ for (int i = 0; i < layer_count; ++i) {
+ fragment_shader_stream << "uniform samplerExternalOES uLayerTexture" << i
+ << ";\n";
+ }
+ fragment_shader_stream << "uniform float uLayerAlpha[LAYER_COUNT];\n"
+ << "uniform float uLayerPremult[LAYER_COUNT];\n"
+ << "in vec2 fTexCoords[LAYER_COUNT];\n"
+ << "out vec4 oFragColor;\n"
+ << "void main() {\n"
+ << " vec3 color = vec3(0.0, 0.0, 0.0);\n"
+ << " float alphaCover = 1.0;\n"
+ << " vec4 texSample;\n"
+ << " vec3 multRgb;\n";
+ for (int i = 0; i < layer_count; ++i) {
+ if (i > 0)
+ fragment_shader_stream << " if (alphaCover > 0.5/255.0) {\n";
+ // clang-format off
+ fragment_shader_stream
+ << " texSample = texture2D(uLayerTexture" << i << ",\n"
+ << " fTexCoords[" << i << "]);\n"
+ << " multRgb = texSample.rgb *\n"
+ << " max(texSample.a, uLayerPremult[" << i << "]);\n"
+ << " color += multRgb * uLayerAlpha[" << i << "] * alphaCover;\n"
+ << " alphaCover *= 1.0 - texSample.a * uLayerAlpha[" << i << "];\n";
+ // clang-format on
+ }
+ for (int i = 0; i < layer_count - 1; ++i)
+ fragment_shader_stream << " }\n";
+ fragment_shader_stream << " oFragColor = vec4(color, 1.0 - alphaCover);\n"
+ << "}\n";
+ return fragment_shader_stream.str();
+}
+
static int GenerateShaders(std::vector<AutoGLProgram> *blend_programs) {
// Limits: GL_MAX_VARYING_COMPONENTS, GL_MAX_TEXTURE_IMAGE_UNITS,
// GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS
- // clang-format off
- const GLchar *shader_preamble = "#version 300 es\n#define LAYER_COUNT ";
-
- const GLchar *vertex_shader_source =
-"\n"
-"precision mediump int; \n"
-"uniform vec4 uViewport; \n"
-"uniform sampler2D uLayerTextures[LAYER_COUNT]; \n"
-"uniform vec4 uLayerCrop[LAYER_COUNT]; \n"
-"uniform mat2 uTexMatrix[LAYER_COUNT]; \n"
-"in vec2 vPosition; \n"
-"in vec2 vTexCoords; \n"
-"out vec2 fTexCoords[LAYER_COUNT]; \n"
-"void main() { \n"
-" for (int i = 0; i < LAYER_COUNT; i++) { \n"
-" vec2 tempCoords = vTexCoords * uTexMatrix[i]; \n"
-" fTexCoords[i] = (uLayerCrop[i].xy + tempCoords * uLayerCrop[i].zw) / \n"
-" vec2(textureSize(uLayerTextures[i], 0)); \n"
-" } \n"
-" vec2 scaledPosition = uViewport.xy + vPosition * uViewport.zw; \n"
-" gl_Position = vec4(scaledPosition * vec2(2.0) - vec2(1.0), 0.0, 1.0); \n"
-"} \n";
-
- const GLchar *fragment_shader_source =
-"\n"
-"precision mediump float; \n"
-"uniform sampler2D uLayerTextures[LAYER_COUNT]; \n"
-"uniform float uLayerAlpha[LAYER_COUNT]; \n"
-"in vec2 fTexCoords[LAYER_COUNT]; \n"
-"out vec4 oFragColor; \n"
-"void main() { \n"
-" vec3 color = vec3(0.0, 0.0, 0.0); \n"
-" float alphaCover = 1.0; \n"
-" for (int i = 0; i < LAYER_COUNT; i++) { \n"
-" vec4 texSample = texture(uLayerTextures[i], fTexCoords[i]); \n"
-" float a = texSample.a * uLayerAlpha[i]; \n"
-" color += a * alphaCover * texSample.rgb; \n"
-" alphaCover *= 1.0 - a; \n"
-" if (alphaCover <= 0.5/255.0) \n"
-" break; \n"
-" } \n"
-" oFragColor = vec4(color, 1.0 - alphaCover); \n"
-"} \n";
- // clang-format on
-
int i, ret = 1;
GLint max_texture_images, status;
AutoGLShader vertex_shader, fragment_shader;
glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_images);
for (i = 1; i <= max_texture_images; i++) {
- std::ostringstream layer_count_formatter;
- layer_count_formatter << i;
- std::string layer_count(layer_count_formatter.str());
- const GLchar *shader_sources[3] = {shader_preamble, layer_count.c_str(),
- NULL};
-
- shader_sources[2] = vertex_shader_source;
- vertex_shader = CompileAndCheckShader(GL_VERTEX_SHADER, 3, shader_sources,
- ret ? &shader_log : NULL);
+ std::string vertex_shader_string = GenerateVertexShader(i);
+ const GLchar *vertex_shader_source = vertex_shader_string.c_str();
+ vertex_shader = CompileAndCheckShader(
+ GL_VERTEX_SHADER, 1, &vertex_shader_source, ret ? &shader_log : NULL);
if (!vertex_shader.get()) {
if (ret)
- ALOGE("Failed to make vertex shader:\n%s", shader_log.c_str());
+ ALOGE("Failed to make vertex shader:\n%sshader source:\n%s",
+ shader_log.c_str(), vertex_shader_source);
break;
}
- shader_sources[2] = fragment_shader_source;
- fragment_shader = CompileAndCheckShader(
- GL_FRAGMENT_SHADER, 3, shader_sources, ret ? &shader_log : NULL);
+ std::string fragment_shader_string = GenerateFragmentShader(i);
+ const GLchar *fragment_shader_source = fragment_shader_string.c_str();
+ fragment_shader =
+ CompileAndCheckShader(GL_FRAGMENT_SHADER, 1, &fragment_shader_source,
+ ret ? &shader_log : NULL);
if (!fragment_shader.get()) {
if (ret)
- ALOGE("Failed to make fragment shader:\n%s", shader_log.c_str());
+ ALOGE("Failed to make fragment shader:\n%sshader source:\n%s",
+ shader_log.c_str(), fragment_shader_source);
break;
}
unsigned texture_index;
float crop_bounds[4];
float alpha;
+ float premult;
float texture_matrix[4];
};
}
};
-static void ConstructCommands(const hwc_layer_1 *layers, size_t num_layers,
+static void ConstructCommands(DrmCompositionLayer *layers, size_t num_layers,
std::vector<RenderingCommand> *commands) {
std::vector<FRect> in_rects;
std::vector<FRectSet> out_rects;
int i;
for (unsigned rect_index = 0; rect_index < num_layers; rect_index++) {
- const hwc_layer_1 &layer = layers[rect_index];
- FRect rect;
- in_rects.push_back(FRect(layer.displayFrame.left, layer.displayFrame.top,
- layer.displayFrame.right,
- layer.displayFrame.bottom));
+ DrmCompositionLayer &layer = layers[rect_index];
+ in_rects.emplace_back(layer.display_frame);
}
seperate_frects_64(in_rects, &out_rects);
commands->push_back(RenderingCommand());
RenderingCommand &cmd = commands->back();
- memcpy(cmd.bounds, out_rect.rect.bounds, sizeof(cmd.bounds));
+ for (int i = 0; i < 4; i++)
+ cmd.bounds[i] = out_rect.rect.bounds[i];
uint64_t tex_set = out_rect.id_set.getBits();
for (unsigned i = num_layers - 1; tex_set != 0x0; i--) {
if (tex_set & (0x1 << i)) {
tex_set &= ~(0x1 << i);
- const hwc_layer_1 &layer = layers[i];
+ DrmCompositionLayer &layer = layers[i];
- FRect display_rect(layer.displayFrame.left, layer.displayFrame.top,
- layer.displayFrame.right, layer.displayFrame.bottom);
+ FRect display_rect(layer.display_frame);
float display_size[2] = {
display_rect.bounds[2] - display_rect.bounds[0],
display_rect.bounds[3] - display_rect.bounds[1]};
- FRect crop_rect(layer.sourceCropf.left, layer.sourceCropf.top,
- layer.sourceCropf.right, layer.sourceCropf.bottom);
+ float tex_width = layer.buffer->width;
+ float tex_height = layer.buffer->height;
+ FRect crop_rect(layer.source_crop.left / tex_width,
+ layer.source_crop.top / tex_height,
+ layer.source_crop.right / tex_width,
+ layer.source_crop.bottom / tex_height);
+
float crop_size[2] = {crop_rect.bounds[2] - crop_rect.bounds[0],
crop_rect.bounds[3] - crop_rect.bounds[1]};
bool swap_xy, flip_xy[2];
switch (layer.transform) {
- case HWC_TRANSFORM_FLIP_H:
- swap_xy = false; flip_xy[0] = true; flip_xy[1] = false;
+ case DrmHwcTransform::kFlipH:
+ swap_xy = false;
+ flip_xy[0] = true;
+ flip_xy[1] = false;
break;
- case HWC_TRANSFORM_FLIP_V:
- swap_xy = false; flip_xy[0] = false; flip_xy[1] = true;
+ case DrmHwcTransform::kFlipV:
+ swap_xy = false;
+ flip_xy[0] = false;
+ flip_xy[1] = true;
break;
- case HWC_TRANSFORM_ROT_90:
- swap_xy = true; flip_xy[0] = false; flip_xy[1] = true;
+ case DrmHwcTransform::kRotate90:
+ swap_xy = true;
+ flip_xy[0] = false;
+ flip_xy[1] = true;
break;
- case HWC_TRANSFORM_ROT_180:
- swap_xy = false; flip_xy[0] = true; flip_xy[1] = true;
+ case DrmHwcTransform::kRotate180:
+ swap_xy = false;
+ flip_xy[0] = true;
+ flip_xy[1] = true;
break;
- case HWC_TRANSFORM_ROT_270:
- swap_xy = true; flip_xy[0] = true; flip_xy[1] = false;
+ case DrmHwcTransform::kRotate270:
+ swap_xy = true;
+ flip_xy[0] = true;
+ flip_xy[1] = false;
break;
default:
ALOGE(
"Unknown transform for layer: defaulting to identity "
"transform");
- case 0:
- swap_xy = false; flip_xy[0] = false; flip_xy[1] = false;
+ case DrmHwcTransform::kIdentity:
+ swap_xy = false;
+ flip_xy[0] = false;
+ flip_xy[1] = false;
break;
}
}
}
- if (layer.blending == HWC_BLENDING_NONE) {
- src.alpha = 1.0f;
+ if (layer.blending == DrmHwcBlending::kNone) {
+ src.alpha = src.premult = 1.0f;
// This layer is opaque. There is no point in using layers below this
// one.
break;
}
- src.alpha = layer.planeAlpha / 255.0f;
+ src.alpha = layer.alpha / 255.0f;
+ src.premult =
+ (layer.blending == DrmHwcBlending::kPreMult) ? 1.0f : 0.0f;
}
}
}
GLuint texture;
glGenTextures(1, &texture);
- glBindTexture(GL_TEXTURE_2D, texture);
- glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
- glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
- glBindTexture(GL_TEXTURE_2D, 0);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
+ glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, (GLeglImageOES)image);
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_REPEAT);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
out->image.reset(egl_display, image);
out->texture.reset(texture);
if (!HasExtension("GL_OES_EGL_image", gl_extensions))
ALOGW("GL_OES_EGL_image extension not supported");
+ if (!HasExtension("GL_OES_EGL_image_external", gl_extensions))
+ ALOGW("GL_OES_EGL_image_external extension not supported");
+
GLuint vertex_buffer;
glGenBuffers(1, &vertex_buffer);
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
ALOGE("Failed to destroy OpenGL ES Context: %s", GetEGLError());
}
-int GLWorkerCompositor::Composite(hwc_layer_1 *layers, size_t num_layers,
+int GLWorkerCompositor::Composite(DrmCompositionLayer *layers,
+ size_t num_layers,
const sp<GraphicBuffer> &framebuffer) {
ATRACE_CALL();
int ret = 0;
}
for (i = 0; i < num_layers; i++) {
- struct hwc_layer_1 *layer = &layers[i];
-
- if (ret) {
- if (layer->acquireFenceFd >= 0) {
- close(layer->acquireFenceFd);
- layer->acquireFenceFd = -1;
- }
- continue;
- }
+ DrmCompositionLayer *layer = &layers[i];
layer_textures.emplace_back();
- ret = CreateTextureFromHandle(egl_display_, layer->handle,
+ ret = CreateTextureFromHandle(egl_display_, layer->get_usable_handle(),
&layer_textures.back());
if (!ret) {
- ret = EGLFenceWait(egl_display_, layer->acquireFenceFd);
- layer->acquireFenceFd = -1;
+ ret = EGLFenceWait(egl_display_, layer->acquire_fence.Release());
}
if (ret) {
layer_textures.pop_back();
GLint program = blend_programs_[cmd.texture_count - 1].get();
glUseProgram(program);
GLint gl_viewport_loc = glGetUniformLocation(program, "uViewport");
- GLint gl_tex_loc = glGetUniformLocation(program, "uLayerTextures");
GLint gl_crop_loc = glGetUniformLocation(program, "uLayerCrop");
GLint gl_alpha_loc = glGetUniformLocation(program, "uLayerAlpha");
+ GLint gl_premult_loc = glGetUniformLocation(program, "uLayerPremult");
GLint gl_tex_matrix_loc = glGetUniformLocation(program, "uTexMatrix");
glUniform4f(gl_viewport_loc, cmd.bounds[0] / (float)frame_width,
cmd.bounds[1] / (float)frame_height,
(cmd.bounds[3] - cmd.bounds[1]) / (float)frame_height);
for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
+ std::ostringstream texture_name_formatter;
+ texture_name_formatter << "uLayerTexture" << src_index;
+ GLint gl_tex_loc =
+ glGetUniformLocation(program, texture_name_formatter.str().c_str());
+
const RenderingCommand::TextureSource &src = cmd.textures[src_index];
glUniform1f(gl_alpha_loc + src_index, src.alpha);
+ glUniform1f(gl_premult_loc + src_index, src.premult);
glUniform4f(gl_crop_loc + src_index, src.crop_bounds[0],
src.crop_bounds[1], src.crop_bounds[2] - src.crop_bounds[0],
src.crop_bounds[3] - src.crop_bounds[1]);
- glUniform1i(gl_tex_loc + src_index, src_index);
+ glUniform1i(gl_tex_loc, src_index);
glUniformMatrix2fv(gl_tex_matrix_loc + src_index, 1, GL_FALSE,
src.texture_matrix);
glActiveTexture(GL_TEXTURE0 + src_index);
- glBindTexture(GL_TEXTURE_2D,
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES,
layer_textures[src.texture_index].texture.get());
}
for (unsigned src_index = 0; src_index < cmd.texture_count; src_index++) {
glActiveTexture(GL_TEXTURE0 + src_index);
- glBindTexture(GL_TEXTURE_2D, 0);
+ glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
}
}
OSDN Git Service
