cube-video.c

/*
 * 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];

  EGLSyncKHR last_fence;
} 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;

  if (gl.last_fence) {
    egl->eglClientWaitSyncKHR(egl->display, gl.last_fence, 0, EGL_FOREVER_KHR);
    egl->eglDestroySyncKHR(egl->display, gl.last_fence);
    gl.last_fence = NULL;
  }

  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);

  gl.last_fence = egl->eglCreateSyncKHR(egl->display, EGL_SYNC_FENCE_KHR, NULL);
}

const struct egl *init_cube_video(const struct gbm *gbm, const char *filenames,
                                  int samples) {
  char *fnames, *s;
  int ret, i = 0;

  ret = init_egl(&gl.egl, gbm, samples);
  if (ret)
    return NULL;

  if (egl_check(&gl.egl, glEGLImageTargetTexture2DOES) ||
      egl_check(egl, eglCreateSyncKHR) || egl_check(egl, eglDestroySyncKHR) ||
      egl_check(egl, eglClientWaitSyncKHR))
    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;
}