raspberrypi/test/gles_video.c

   1 /*
   2
   3 This file is based on Portable ZX-Spectrum emulator.
   4 Copyright (C) 2001-2012 SMT, Dexus, Alone Coder, deathsoft, djdron, scor
   5
   6 C++ to C code conversion by Pate
   7
   8 Modified by DPR for gpsp for Raspberry Pi
   9
  10 This program is free software: you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation, either version 3 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 */
  24
  25 #include "bcm_host.h"
  26 #include "GLES/gl.h"
  27 #include "EGL/egl.h"
  28 #include "EGL/eglext.h"
  29 #include "GLES2/gl2.h"
  30 #include <assert.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <memory.h>
  34
  35 static uint32_t frame_width = 0;
  36 static uint32_t frame_height = 0;
  37
  38
  39 #define SHOW_ERROR              gles_show_error();
  40
  41 static void SetOrtho(GLfloat m[4][4], GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near, GLfloat far, GLfloat scale_x, GLfloat scale_y);
  42
  43 static const char* vertex_shader =
  44         "uniform mat4 u_vp_matrix;                                                              \n"
  45         "attribute vec4 a_position;                                                             \n"
  46         "attribute vec2 a_texcoord;                                                             \n"
  47         "varying mediump vec2 v_texcoord;                                               \n"
  48         "void main()                                                                                    \n"
  49         "{                                                                                                              \n"
  50         "       v_texcoord = a_texcoord;                                                        \n"
  51         "       gl_Position = u_vp_matrix * a_position;                         \n"
  52         "}                                                                                                              \n";
  53
  54 static const char* fragment_shader =
  55         "varying mediump vec2 v_texcoord;                                               \n"
  56         "uniform sampler2D u_texture;                                                   \n"
  57         "void main()                                                                                    \n"
  58         "{                                                                                                              \n"
  59         "       gl_FragColor = texture2D(u_texture, v_texcoord);        \n"
  60         "}                                                                                                              \n";
  61 /*
  62 static const GLfloat vertices[] =
  63 {
  64         -0.5f, -0.5f, 0.0f,
  65         +0.5f, -0.5f, 0.0f,
  66         +0.5f, +0.5f, 0.0f,
  67         -0.5f, +0.5f, 0.0f,
  68 };
  69 */
  70 static const GLfloat vertices[] =
  71 {
  72         -0.5f, -0.5f, 0.0f,
  73         -0.5f, +0.5f, 0.0f,
  74         +0.5f, +0.5f, 0.0f,
  75         +0.5f, -0.5f, 0.0f,
  76 };
  77
  78 #define TEX_WIDTH       1024
  79 #define TEX_HEIGHT      512
  80
  81 static const GLfloat uvs[8];
  82
  83 static const GLushort indices[] =
  84 {
  85         0, 1, 2,
  86         0, 2, 3,
  87 };
  88
  89 static const int kVertexCount = 4;
  90 static const int kIndexCount = 6;
  91
  92
  93 void Create_uvs(GLfloat * matrix, GLfloat max_u, GLfloat max_v) {
  94     memset(matrix,0,sizeof(GLfloat)*8);
  95     matrix[3]=max_v;
  96     matrix[4]=max_u;
  97     matrix[5]=max_v;
  98     matrix[6]=max_u;
  99
 100 }
 101
 102 void gles_show_error()
 103 {
 104         GLenum error = GL_NO_ERROR;
 105     error = glGetError();
 106     if (GL_NO_ERROR != error)
 107         printf("GL Error %x encountered!\n", error);
 108 }
 109
 110 static GLuint CreateShader(GLenum type, const char *shader_src)
 111 {
 112         GLuint shader = glCreateShader(type);
 113         if(!shader)
 114                 return 0;
 115
 116         // Load and compile the shader source
 117         glShaderSource(shader, 1, &shader_src, NULL);
 118         glCompileShader(shader);
 119
 120         // Check the compile status
 121         GLint compiled = 0;
 122         glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
 123         if(!compiled)
 124         {
 125                 GLint info_len = 0;
 126                 glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_len);
 127                 if(info_len > 1)
 128                 {
 129                         char* info_log = (char *)malloc(sizeof(char) * info_len);
 130                         glGetShaderInfoLog(shader, info_len, NULL, info_log);
 131                         // TODO(dspringer): We could really use a logging API.
 132                         printf("Error compiling shader:\n%s\n", info_log);
 133                         free(info_log);
 134                 }
 135                 glDeleteShader(shader);
 136                 return 0;
 137         }
 138         return shader;
 139 }
 140
 141 static GLuint CreateProgram(const char *vertex_shader_src, const char *fragment_shader_src)
 142 {
 143         GLuint vertex_shader = CreateShader(GL_VERTEX_SHADER, vertex_shader_src);
 144         if(!vertex_shader)
 145                 return 0;
 146         GLuint fragment_shader = CreateShader(GL_FRAGMENT_SHADER, fragment_shader_src);
 147         if(!fragment_shader)
 148         {
 149                 glDeleteShader(vertex_shader);
 150                 return 0;
 151         }
 152
 153         GLuint program_object = glCreateProgram();
 154         if(!program_object)
 155                 return 0;
 156         glAttachShader(program_object, vertex_shader);
 157         glAttachShader(program_object, fragment_shader);
 158
 159         // Link the program
 160         glLinkProgram(program_object);
 161
 162         // Check the link status
 163         GLint linked = 0;
 164         glGetProgramiv(program_object, GL_LINK_STATUS, &linked);
 165         if(!linked)
 166         {
 167                 GLint info_len = 0;
 168                 glGetProgramiv(program_object, GL_INFO_LOG_LENGTH, &info_len);
 169                 if(info_len > 1)
 170                 {
 171                         char* info_log = (char *)malloc(info_len);
 172                         glGetProgramInfoLog(program_object, info_len, NULL, info_log);
 173                         // TODO(dspringer): We could really use a logging API.
 174                         printf("Error linking program:\n%s\n", info_log);
 175                         free(info_log);
 176                 }
 177                 glDeleteProgram(program_object);
 178                 return 0;
 179         }
 180         // Delete these here because they are attached to the program object.
 181         glDeleteShader(vertex_shader);
 182         glDeleteShader(fragment_shader);
 183         return program_object;
 184 }
 185
 186 typedef struct ShaderInfo {
 187                 GLuint program;
 188                 GLint a_position;
 189                 GLint a_texcoord;
 190                 GLint u_vp_matrix;
 191                 GLint u_texture;
 192 } ShaderInfo;
 193
 194 static ShaderInfo shader;
 195 static ShaderInfo shader_filtering;
 196 static GLuint buffers[3];
 197 static GLuint textures[2];
 198
 199
 200 static void gles2_create()
 201 {
 202         memset(&shader, 0, sizeof(ShaderInfo));
 203         shader.program = CreateProgram(vertex_shader, fragment_shader);
 204         if(shader.program)
 205         {
 206                 shader.a_position       = glGetAttribLocation(shader.program,   "a_position");
 207                 shader.a_texcoord       = glGetAttribLocation(shader.program,   "a_texcoord");
 208                 shader.u_vp_matrix      = glGetUniformLocation(shader.program,  "u_vp_matrix");
 209                 shader.u_texture        = glGetUniformLocation(shader.program,  "u_texture");
 210         }
 211         glGenTextures(1, textures);
 212         glBindTexture(GL_TEXTURE_2D, textures[0]);
 213         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEX_WIDTH, TEX_HEIGHT, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
 214
 215         Create_uvs(uvs, (float)frame_width/TEX_WIDTH, (float)frame_height/TEX_HEIGHT);
 216
 217         glGenBuffers(3, buffers);
 218         glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
 219         glBufferData(GL_ARRAY_BUFFER, kVertexCount * sizeof(GLfloat) * 3, vertices, GL_STATIC_DRAW);
 220         glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
 221         glBufferData(GL_ARRAY_BUFFER, kVertexCount * sizeof(GLfloat) * 2, uvs, GL_STATIC_DRAW);
 222         glBindBuffer(GL_ARRAY_BUFFER, 0);
 223         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[2]);
 224         glBufferData(GL_ELEMENT_ARRAY_BUFFER, kIndexCount * sizeof(GL_UNSIGNED_SHORT), indices, GL_STATIC_DRAW);
 225         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 226
 227         glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 228         glDisable(GL_DEPTH_TEST);
 229         glDisable(GL_BLEND);
 230         glDisable(GL_DITHER);
 231 }
 232
 233 static uint32_t screen_width = 0;
 234 static uint32_t screen_height = 0;
 235
 236 static EGLDisplay display = NULL;
 237 static EGLSurface surface = NULL;
 238 static EGLContext context = NULL;
 239 static EGL_DISPMANX_WINDOW_T nativewindow;
 240
 241 static GLfloat proj[4][4];
 242 static GLint filter_min;
 243 static GLint filter_mag;
 244
 245 void video_set_filter(uint32_t filter) {
 246         if (filter==0) {
 247             filter_min = GL_NEAREST;
 248             filter_mag = GL_NEAREST;
 249         } else  {
 250             filter_min = GL_LINEAR;
 251             filter_mag = GL_LINEAR;
 252         }
 253 }
 254
 255 void video_init(uint32_t _width, uint32_t _height, uint32_t filter)
 256 {
 257         if ((_width==0)||(_height==0))
 258                 return;
 259
 260         frame_width = _width;
 261         frame_height = _height;
 262
 263         //bcm_host_init();
 264
 265         // get an EGL display connection
 266         display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
 267         assert(display != EGL_NO_DISPLAY);
 268
 269         // initialize the EGL display connection
 270         EGLBoolean result = eglInitialize(display, NULL, NULL);
 271         assert(EGL_FALSE != result);
 272
 273         // get an appropriate EGL frame buffer configuration
 274         EGLint num_config;
 275         EGLConfig config;
 276         static const EGLint attribute_list[] =
 277         {
 278                 EGL_RED_SIZE, 8,
 279                 EGL_GREEN_SIZE, 8,
 280                 EGL_BLUE_SIZE, 8,
 281                 EGL_ALPHA_SIZE, 8,
 282                 EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
 283                 EGL_NONE
 284         };
 285         result = eglChooseConfig(display, attribute_list, &config, 1, &num_config);
 286         assert(EGL_FALSE != result);
 287
 288         result = eglBindAPI(EGL_OPENGL_ES_API);
 289         assert(EGL_FALSE != result);
 290
 291         // create an EGL rendering context
 292         static const EGLint context_attributes[] =
 293         {
 294                 EGL_CONTEXT_CLIENT_VERSION, 2,
 295                 EGL_NONE
 296         };
 297         context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attributes);
 298         assert(context != EGL_NO_CONTEXT);
 299
 300         // create an EGL window surface
 301         int32_t success = graphics_get_display_size(0, &screen_width, &screen_height);
 302         assert(success >= 0);
 303
 304         VC_RECT_T dst_rect;
 305         dst_rect.x = 0;
 306         dst_rect.y = 0;
 307         dst_rect.width = screen_width;
 308         dst_rect.height = screen_height;
 309
 310         VC_RECT_T src_rect;
 311         src_rect.x = 0;
 312         src_rect.y = 0;
 313         src_rect.width = screen_width << 16;
 314         src_rect.height = screen_height << 16;
 315
 316         DISPMANX_DISPLAY_HANDLE_T dispman_display = vc_dispmanx_display_open(0);
 317         DISPMANX_UPDATE_HANDLE_T dispman_update = vc_dispmanx_update_start(0);
 318         DISPMANX_ELEMENT_HANDLE_T dispman_element = vc_dispmanx_element_add(dispman_update, dispman_display,
 319          1, &dst_rect, 0, &src_rect, DISPMANX_PROTECTION_NONE, NULL, NULL, DISPMANX_NO_ROTATE);
 320
 321         nativewindow.element = dispman_element;
 322         nativewindow.width = screen_width;
 323         nativewindow.height = screen_height;
 324         vc_dispmanx_update_submit_sync(dispman_update);
 325
 326         surface = eglCreateWindowSurface(display, config, &nativewindow, NULL);
 327         assert(surface != EGL_NO_SURFACE);
 328
 329         // connect the context to the surface
 330         result = eglMakeCurrent(display, surface, surface, context);
 331         assert(EGL_FALSE != result);
 332
 333         gles2_create();
 334
 335         int r=(screen_height*10/frame_height);
 336         int h = (frame_height*r)/10;
 337         int w = (frame_width*r)/10;
 338         if (w>screen_width) {
 339             r = (screen_width*10/frame_width);
 340             h = (frame_height*r)/10;
 341             w = (frame_width*r)/10;
 342         }
 343         glViewport((screen_width-w)/2, (screen_height-h)/2, w, h);
 344         SetOrtho(proj, -0.5f, +0.5f, +0.5f, -0.5f, -1.0f, 1.0f, 1.0f ,1.0f );
 345         video_set_filter(filter);
 346 }
 347
 348 static void gles2_destroy()
 349 {
 350         if(!shader.program)
 351                 return;
 352         glDeleteBuffers(3, buffers); SHOW_ERROR
 353         glDeleteProgram(shader.program); SHOW_ERROR
 354 }
 355
 356 static void SetOrtho(GLfloat m[4][4], GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat near, GLfloat far, GLfloat scale_x, GLfloat scale_y)
 357 {
 358         memset(m, 0, 4*4*sizeof(GLfloat));
 359         m[0][0] = 2.0f/(right - left)*scale_x;
 360         m[1][1] = 2.0f/(top - bottom)*scale_y;
 361         m[2][2] = -2.0f/(far - near);
 362         m[3][0] = -(right + left)/(right - left);
 363         m[3][1] = -(top + bottom)/(top - bottom);
 364         m[3][2] = -(far + near)/(far - near);
 365         m[3][3] = 1;
 366 }
 367 #define RGB15(r, g, b)  (((r) << (5+6)) | ((g) << 6) | (b))
 368
 369 static void gles2_Draw( uint16_t *pixels)
 370 {
 371         if(!shader.program)
 372                 return;
 373
 374         glClear(GL_COLOR_BUFFER_BIT);
 375
 376         glUseProgram(shader.program);
 377
 378         glBindTexture(GL_TEXTURE_2D, textures[0]);
 379         glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, frame_width, frame_height, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, pixels);
 380         glActiveTexture(GL_TEXTURE0);
 381         glUniform1i(shader.u_texture, 0);
 382         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter_mag);
 383         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter_min);
 384         glGenerateMipmap(GL_TEXTURE_2D);
 385
 386         glBindBuffer(GL_ARRAY_BUFFER, buffers[0]);
 387         glVertexAttribPointer(shader.a_position, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), NULL);
 388         glEnableVertexAttribArray(shader.a_position);
 389
 390         glBindBuffer(GL_ARRAY_BUFFER, buffers[1]);
 391         glVertexAttribPointer(shader.a_texcoord, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), NULL);
 392         glEnableVertexAttribArray(shader.a_texcoord);
 393
 394         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffers[2]);
 395         glUniformMatrix4fv(shader.u_vp_matrix, 1, GL_FALSE, (const GLfloat * )&proj);
 396         glDrawElements(GL_TRIANGLES, kIndexCount, GL_UNSIGNED_SHORT, 0);
 397
 398         glBindBuffer(GL_ARRAY_BUFFER, 0);
 399         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 400         //glFlush();
 401 }
 402
 403 void video_close()
 404 {
 405         gles2_destroy();
 406         // Release OpenGL resources
 407         eglMakeCurrent( display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT );
 408         eglDestroySurface( display, surface );
 409         eglDestroyContext( display, context );
 410         eglTerminate( display );
 411 }
 412
 413 void video_draw(uint16_t *pixels)
 414 {
 415         gles2_Draw (pixels);
 416         eglSwapBuffers(display, surface);
 417 }