add video cube

Uses gstreamer for a simple decoder.  If decoder can give us dma-buf's
directly, we'll directly use that as a texture (zero copy), otherwise
memcpy into a buffer from gbm.  This should work with both hw and sw
decoders.

Probably room for improvement.  And the interface between gl and the
decoder is pretty simple so I suppose other decoders would be possible.
(But hopefully they could already be supported via gstreamer.)

Signed-off-by: Rob Clark <robdclark@gmail.com>
Reviewed-by: Emil Velikov <emil.l.velikov@gmail.com>

1 files changed, 386 insertions, 0 deletions

diff --git a/cube-video.c b/cube-video.c
new file mode 100644
index 0000000..6ce20da
--- /dev/null
+++ b/cube-video.c
@@ -0,0 +1,386 @@
+/*
+ * Copyright (c) 2017 Rob Clark <rclark@redhat.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sub license,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the
+ * next paragraph) shall be included in all copies or substantial portions
+ * of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#define _GNU_SOURCE
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common.h"
+#include "esUtil.h"
+
+struct {
+	struct egl egl;
+
+	GLfloat aspect;
+	const struct gbm *gbm;
+
+	GLuint program, blit_program;
+	/* uniform handles: */
+	GLint modelviewmatrix, modelviewprojectionmatrix, normalmatrix;
+	GLint texture, blit_texture;
+	GLuint vbo;
+	GLuint positionsoffset, texcoordsoffset, normalsoffset;
+	GLuint tex;
+
+	/* video decoder: */
+	struct decoder *decoder;
+	int filenames_count, idx;
+	const char *filenames[32];
+} gl;
+
+static const struct egl *egl = &gl.egl;
+
+static const GLfloat vVertices[] = {
+		// front
+		-1.0f, -1.0f, +1.0f,
+		+1.0f, -1.0f, +1.0f,
+		-1.0f, +1.0f, +1.0f,
+		+1.0f, +1.0f, +1.0f,
+		// back
+		+1.0f, -1.0f, -1.0f,
+		-1.0f, -1.0f, -1.0f,
+		+1.0f, +1.0f, -1.0f,
+		-1.0f, +1.0f, -1.0f,
+		// right
+		+1.0f, -1.0f, +1.0f,
+		+1.0f, -1.0f, -1.0f,
+		+1.0f, +1.0f, +1.0f,
+		+1.0f, +1.0f, -1.0f,
+		// left
+		-1.0f, -1.0f, -1.0f,
+		-1.0f, -1.0f, +1.0f,
+		-1.0f, +1.0f, -1.0f,
+		-1.0f, +1.0f, +1.0f,
+		// top
+		-1.0f, +1.0f, +1.0f,
+		+1.0f, +1.0f, +1.0f,
+		-1.0f, +1.0f, -1.0f,
+		+1.0f, +1.0f, -1.0f,
+		// bottom
+		-1.0f, -1.0f, -1.0f,
+		+1.0f, -1.0f, -1.0f,
+		-1.0f, -1.0f, +1.0f,
+		+1.0f, -1.0f, +1.0f,
+};
+
+static const GLfloat vTexCoords[] = {
+		//front
+		0.0f, 1.0f,
+		1.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		//back
+		0.0f, 1.0f,
+		1.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		//right
+		0.0f, 1.0f,
+		1.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		//left
+		0.0f, 1.0f,
+		1.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		//top
+		0.0f, 1.0f,
+		1.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+		//bottom
+		0.0f, 1.0f,
+		1.0f, 1.0f,
+		0.0f, 0.0f,
+		1.0f, 0.0f,
+};
+
+static const GLfloat vNormals[] = {
+		// front
+		+0.0f, +0.0f, +1.0f, // forward
+		+0.0f, +0.0f, +1.0f, // forward
+		+0.0f, +0.0f, +1.0f, // forward
+		+0.0f, +0.0f, +1.0f, // forward
+		// back
+		+0.0f, +0.0f, -1.0f, // backward
+		+0.0f, +0.0f, -1.0f, // backward
+		+0.0f, +0.0f, -1.0f, // backward
+		+0.0f, +0.0f, -1.0f, // backward
+		// right
+		+1.0f, +0.0f, +0.0f, // right
+		+1.0f, +0.0f, +0.0f, // right
+		+1.0f, +0.0f, +0.0f, // right
+		+1.0f, +0.0f, +0.0f, // right
+		// left
+		-1.0f, +0.0f, +0.0f, // left
+		-1.0f, +0.0f, +0.0f, // left
+		-1.0f, +0.0f, +0.0f, // left
+		-1.0f, +0.0f, +0.0f, // left
+		// top
+		+0.0f, +1.0f, +0.0f, // up
+		+0.0f, +1.0f, +0.0f, // up
+		+0.0f, +1.0f, +0.0f, // up
+		+0.0f, +1.0f, +0.0f, // up
+		// bottom
+		+0.0f, -1.0f, +0.0f, // down
+		+0.0f, -1.0f, +0.0f, // down
+		+0.0f, -1.0f, +0.0f, // down
+		+0.0f, -1.0f, +0.0f  // down
+};
+
+static const char *blit_vs =
+		"attribute vec4 in_position;        \n"
+		"attribute vec2 in_TexCoord;        \n"
+		"                                   \n"
+		"varying vec2 vTexCoord;            \n"
+		"                                   \n"
+		"void main()                        \n"
+		"{                                  \n"
+		"    gl_Position = in_position;     \n"
+		"    vTexCoord = in_TexCoord;       \n"
+		"}                                  \n";
+
+static const char *blit_fs =
+		"#extension GL_OES_EGL_image_external : enable\n"
+		"precision mediump float;           \n"
+		"                                   \n"
+		"uniform samplerExternalOES uTex;   \n"
+		"                                   \n"
+		"varying vec2 vTexCoord;            \n"
+		"                                   \n"
+		"void main()                        \n"
+		"{                                  \n"
+		"    gl_FragColor = texture2D(uTex, vTexCoord);\n"
+		"}                                  \n";
+
+static const char *vertex_shader_source =
+		"uniform mat4 modelviewMatrix;      \n"
+		"uniform mat4 modelviewprojectionMatrix;\n"
+		"uniform mat3 normalMatrix;         \n"
+		"                                   \n"
+		"attribute vec4 in_position;        \n"
+		"attribute vec2 in_TexCoord;        \n"
+		"attribute vec3 in_normal;          \n"
+		"                                   \n"
+		"vec4 lightSource = vec4(2.0, 2.0, 20.0, 0.0);\n"
+		"                                   \n"
+		"varying vec4 vVaryingColor;        \n"
+		"varying vec2 vTexCoord;            \n"
+		"                                   \n"
+		"void main()                        \n"
+		"{                                  \n"
+		"    gl_Position = modelviewprojectionMatrix * in_position;\n"
+		"    vec3 vEyeNormal = normalMatrix * in_normal;\n"
+		"    vec4 vPosition4 = modelviewMatrix * in_position;\n"
+		"    vec3 vPosition3 = vPosition4.xyz / vPosition4.w;\n"
+		"    vec3 vLightDir = normalize(lightSource.xyz - vPosition3);\n"
+		"    float diff = max(0.0, dot(vEyeNormal, vLightDir));\n"
+		"    vVaryingColor = vec4(diff * vec3(1.0, 1.0, 1.0), 1.0);\n"
+		"    vTexCoord = in_TexCoord; \n"
+		"}                            \n";
+
+static const char *fragment_shader_source =
+		"#extension GL_OES_EGL_image_external : enable\n"
+		"precision mediump float;           \n"
+		"                                   \n"
+		"uniform samplerExternalOES uTex;   \n"
+		"                                   \n"
+		"varying vec4 vVaryingColor;        \n"
+		"varying vec2 vTexCoord;            \n"
+		"                                   \n"
+		"void main()                        \n"
+		"{                                  \n"
+		"    gl_FragColor = vVaryingColor * texture2D(uTex, vTexCoord);\n"
+		"}                                  \n";
+
+
+static void draw_cube_video(unsigned i)
+{
+	ESMatrix modelview;
+	EGLImage frame;
+
+	frame = video_frame(gl.decoder);
+	if (!frame) {
+		/* end of stream */
+		glDeleteTextures(1, &gl.tex);
+		glGenTextures(1, &gl.tex);
+		video_deinit(gl.decoder);
+		gl.idx = (gl.idx + 1) % gl.filenames_count;
+		gl.decoder = video_init(&gl.egl, gl.gbm, gl.filenames[gl.idx]);
+	}
+
+	glUseProgram(gl.blit_program);
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_EXTERNAL_OES, gl.tex);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	egl->glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, frame);
+
+	/* clear the color buffer */
+	glClearColor(0.5, 0.5, 0.5, 1.0);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	glUseProgram(gl.blit_program);
+	glUniform1i(gl.blit_texture, 0); /* '0' refers to texture unit 0. */
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+	glUseProgram(gl.program);
+
+	esMatrixLoadIdentity(&modelview);
+	esTranslate(&modelview, 0.0f, 0.0f, -8.0f);
+	esRotate(&modelview, 45.0f + (0.25f * i), 1.0f, 0.0f, 0.0f);
+	esRotate(&modelview, 45.0f - (0.5f * i), 0.0f, 1.0f, 0.0f);
+	esRotate(&modelview, 10.0f + (0.15f * i), 0.0f, 0.0f, 1.0f);
+
+	ESMatrix projection;
+	esMatrixLoadIdentity(&projection);
+	esFrustum(&projection, -2.1f, +2.1f, -2.1f * gl.aspect, +2.1f * gl.aspect, 6.0f, 10.0f);
+
+	ESMatrix modelviewprojection;
+	esMatrixLoadIdentity(&modelviewprojection);
+	esMatrixMultiply(&modelviewprojection, &modelview, &projection);
+
+	float normal[9];
+	normal[0] = modelview.m[0][0];
+	normal[1] = modelview.m[0][1];
+	normal[2] = modelview.m[0][2];
+	normal[3] = modelview.m[1][0];
+	normal[4] = modelview.m[1][1];
+	normal[5] = modelview.m[1][2];
+	normal[6] = modelview.m[2][0];
+	normal[7] = modelview.m[2][1];
+	normal[8] = modelview.m[2][2];
+
+	glUniformMatrix4fv(gl.modelviewmatrix, 1, GL_FALSE, &modelview.m[0][0]);
+	glUniformMatrix4fv(gl.modelviewprojectionmatrix, 1, GL_FALSE, &modelviewprojection.m[0][0]);
+	glUniformMatrix3fv(gl.normalmatrix, 1, GL_FALSE, normal);
+	glUniform1i(gl.texture, 0); /* '0' refers to texture unit 0. */
+
+	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+	glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
+	glDrawArrays(GL_TRIANGLE_STRIP, 8, 4);
+	glDrawArrays(GL_TRIANGLE_STRIP, 12, 4);
+	glDrawArrays(GL_TRIANGLE_STRIP, 16, 4);
+	glDrawArrays(GL_TRIANGLE_STRIP, 20, 4);
+}
+
+const struct egl * init_cube_video(const struct gbm *gbm, const char *filenames)
+{
+	char *fnames, *s;
+	int ret, i = 0;
+
+	ret = init_egl(&gl.egl, gbm);
+	if (ret)
+		return NULL;
+
+	if (!gl.egl.eglCreateImageKHR) {
+		printf("no eglCreateImageKHR\n");
+		return NULL;
+	}
+
+	fnames = strdup(filenames);
+	while ((s = strstr(fnames, ","))) {
+		gl.filenames[i] = fnames;
+		s[0] = '\0';
+		fnames = &s[1];
+		i++;
+	}
+	gl.filenames[i] = fnames;
+	gl.filenames_count = ++i;
+
+	gl.decoder = video_init(&gl.egl, gbm, gl.filenames[gl.idx]);
+	if (!gl.decoder) {
+		printf("cannot create video decoder\n");
+		return NULL;
+	}
+
+	gl.aspect = (GLfloat)(gbm->height) / (GLfloat)(gbm->width);
+	gl.gbm = gbm;
+
+	ret = create_program(blit_vs, blit_fs);
+	if (ret < 0)
+		return NULL;
+
+	gl.blit_program = ret;
+
+	glBindAttribLocation(gl.blit_program, 0, "in_position");
+	glBindAttribLocation(gl.blit_program, 1, "in_TexCoord");
+
+	ret = link_program(gl.blit_program);
+	if (ret)
+		return NULL;
+
+	gl.blit_texture = glGetUniformLocation(gl.blit_program, "uTex");
+
+	ret = create_program(vertex_shader_source, fragment_shader_source);
+	if (ret < 0)
+		return NULL;
+
+	gl.program = ret;
+
+	glBindAttribLocation(gl.program, 0, "in_position");
+	glBindAttribLocation(gl.program, 1, "in_TexCoord");
+	glBindAttribLocation(gl.program, 2, "in_normal");
+
+	ret = link_program(gl.program);
+	if (ret)
+		return NULL;
+
+	gl.modelviewmatrix = glGetUniformLocation(gl.program, "modelviewMatrix");
+	gl.modelviewprojectionmatrix = glGetUniformLocation(gl.program, "modelviewprojectionMatrix");
+	gl.normalmatrix = glGetUniformLocation(gl.program, "normalMatrix");
+	gl.texture   = glGetUniformLocation(gl.program, "uTex");
+
+	glViewport(0, 0, gbm->width, gbm->height);
+	glEnable(GL_CULL_FACE);
+
+	gl.positionsoffset = 0;
+	gl.texcoordsoffset = sizeof(vVertices);
+	gl.normalsoffset = sizeof(vVertices) + sizeof(vTexCoords);
+
+	glGenBuffers(1, &gl.vbo);
+	glBindBuffer(GL_ARRAY_BUFFER, gl.vbo);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(vVertices) + sizeof(vTexCoords) + sizeof(vNormals), 0, GL_STATIC_DRAW);
+	glBufferSubData(GL_ARRAY_BUFFER, gl.positionsoffset, sizeof(vVertices), &vVertices[0]);
+	glBufferSubData(GL_ARRAY_BUFFER, gl.texcoordsoffset, sizeof(vTexCoords), &vTexCoords[0]);
+	glBufferSubData(GL_ARRAY_BUFFER, gl.normalsoffset, sizeof(vNormals), &vNormals[0]);
+	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(intptr_t)gl.positionsoffset);
+	glEnableVertexAttribArray(0);
+	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(intptr_t)gl.texcoordsoffset);
+	glEnableVertexAttribArray(1);
+	glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)(intptr_t)gl.normalsoffset);
+	glEnableVertexAttribArray(2);
+
+	glGenTextures(1, &gl.tex);
+
+	gl.egl.draw = draw_cube_video;
+
+	return &gl.egl;
+}