src/uterm_drm3d_render.c

   1 /*
   2  * uterm - Linux User-Space Terminal
   3  *
   4  * Copyright (c) 2011-2013 David Herrmann <dh.herrmann@googlemail.com>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining
   7  * a copy of this software and associated documentation files
   8  * (the "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sublicense, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included
  15  * in all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  21  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 /*
  27  * DRM Video backend
  28  */
  29
  30 #define EGL_EGLEXT_PROTOTYPES
  31 #define GL_GLEXT_PROTOTYPES
  32
  33 #include <EGL/egl.h>
  34 #include <EGL/eglext.h>
  35 #include <errno.h>
  36 #include <fcntl.h>
  37 #include <gbm.h>
  38 #include <GLES2/gl2.h>
  39 #include <GLES2/gl2ext.h>
  40 #include <inttypes.h>
  41 #include <stdbool.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <xf86drm.h>
  46 #include <xf86drmMode.h>
  47 #include "eloop.h"
  48 #include "log.h"
  49 #include "static_gl.h"
  50 #include "uterm_drm_shared_internal.h"
  51 #include "uterm_drm3d_internal.h"
  52 #include "uterm_video.h"
  53 #include "uterm_video_internal.h"
  54
  55 #define LOG_SUBSYSTEM "uterm_drm3d_render"
  56
  57 extern const char *gl_static_fill_vert;
  58 extern const char *gl_static_fill_frag;
  59 extern const char *gl_static_blend_vert;
  60 extern const char *gl_static_blend_frag;
  61 extern const char *gl_static_blit_vert;
  62 extern const char *gl_static_blit_frag;
  63
  64 static int init_shaders(struct uterm_video *video)
  65 {
  66         struct uterm_drm3d_video *v3d = uterm_drm_video_get_data(video);
  67         int ret;
  68         char *fill_attr[] = { "position", "color" };
  69         char *blend_attr[] = { "position", "texture_position" };
  70         char *blit_attr[] = { "position", "texture_position" };
  71
  72         if (v3d->sinit == 1)
  73                 return -EFAULT;
  74         else if (v3d->sinit == 2)
  75                 return 0;
  76
  77         v3d->sinit = 1;
  78
  79         ret = gl_shader_new(&v3d->fill_shader, gl_static_fill_vert,
  80                             gl_static_fill_frag, fill_attr, 2, log_llog);
  81         if (ret)
  82                 return ret;
  83
  84         v3d->uni_fill_proj = gl_shader_get_uniform(v3d->fill_shader,
  85                                                    "projection");
  86
  87         ret = gl_shader_new(&v3d->blend_shader, gl_static_blend_vert,
  88                             gl_static_blend_frag, blend_attr, 2, log_llog);
  89         if (ret)
  90                 return ret;
  91
  92         v3d->uni_blend_proj = gl_shader_get_uniform(v3d->blend_shader,
  93                                                     "projection");
  94         v3d->uni_blend_tex = gl_shader_get_uniform(v3d->blend_shader,
  95                                                    "texture");
  96         v3d->uni_blend_fgcol = gl_shader_get_uniform(v3d->blend_shader,
  97                                                      "fgcolor");
  98         v3d->uni_blend_bgcol = gl_shader_get_uniform(v3d->blend_shader,
  99                                                      "bgcolor");
 100
 101         ret = gl_shader_new(&v3d->blit_shader, gl_static_blit_vert,
 102                             gl_static_blit_frag, blit_attr, 2, log_llog);
 103         if (ret)
 104                 return ret;
 105
 106         v3d->uni_blit_proj = gl_shader_get_uniform(v3d->blit_shader,
 107                                                    "projection");
 108         v3d->uni_blit_tex = gl_shader_get_uniform(v3d->blit_shader,
 109                                                   "texture");
 110
 111         gl_tex_new(&v3d->tex, 1);
 112         v3d->sinit = 2;
 113
 114         return 0;
 115 }
 116
 117 void uterm_drm3d_deinit_shaders(struct uterm_video *video)
 118 {
 119         struct uterm_drm3d_video *v3d = uterm_drm_video_get_data(video);
 120
 121         if (v3d->sinit == 0)
 122                 return;
 123
 124         v3d->sinit = 0;
 125         gl_tex_free(&v3d->tex, 1);
 126         gl_shader_unref(v3d->blit_shader);
 127         gl_shader_unref(v3d->blend_shader);
 128         gl_shader_unref(v3d->fill_shader);
 129 }
 130
 131 int uterm_drm3d_display_blit(struct uterm_display *disp,
 132                              const struct uterm_video_buffer *buf,
 133                              unsigned int x, unsigned int y)
 134 {
 135         struct uterm_drm3d_video *v3d;
 136         unsigned int sw, sh, tmp, width, height, i;
 137         float mat[16];
 138         float vertices[6 * 2], texpos[6 * 2];
 139         int ret;
 140         uint8_t *packed, *src, *dst;
 141
 142         if (!buf || buf->format != UTERM_FORMAT_XRGB32)
 143                 return -EINVAL;
 144
 145         v3d = uterm_drm_video_get_data(disp->video);
 146         ret = uterm_drm3d_display_use(disp, NULL);
 147         if (ret)
 148                 return ret;
 149         ret = init_shaders(disp->video);
 150         if (ret)
 151                 return ret;
 152
 153         sw = uterm_drm_mode_get_width(disp->current_mode);
 154         sh = uterm_drm_mode_get_height(disp->current_mode);
 155
 156         vertices[0] = -1.0;
 157         vertices[1] = -1.0;
 158         vertices[2] = -1.0;
 159         vertices[3] = +1.0;
 160         vertices[4] = +1.0;
 161         vertices[5] = +1.0;
 162
 163         vertices[6] = -1.0;
 164         vertices[7] = -1.0;
 165         vertices[8] = +1.0;
 166         vertices[9] = +1.0;
 167         vertices[10] = +1.0;
 168         vertices[11] = -1.0;
 169
 170         texpos[0] = 0.0;
 171         texpos[1] = 1.0;
 172         texpos[2] = 0.0;
 173         texpos[3] = 0.0;
 174         texpos[4] = 1.0;
 175         texpos[5] = 0.0;
 176
 177         texpos[6] = 0.0;
 178         texpos[7] = 1.0;
 179         texpos[8] = 1.0;
 180         texpos[9] = 0.0;
 181         texpos[10] = 1.0;
 182         texpos[11] = 1.0;
 183
 184         tmp = x + buf->width;
 185         if (tmp < x || x >= sw)
 186                 return -EINVAL;
 187         if (tmp > sw)
 188                 width = sw - x;
 189         else
 190                 width = buf->width;
 191
 192         tmp = y + buf->height;
 193         if (tmp < y || y >= sh)
 194                 return -EINVAL;
 195         if (tmp > sh)
 196                 height = sh - y;
 197         else
 198                 height = buf->height;
 199
 200         glViewport(x, sh - y - height, width, height);
 201         glDisable(GL_BLEND);
 202
 203         gl_shader_use(v3d->blit_shader);
 204
 205         gl_m4_identity(mat);
 206         glUniformMatrix4fv(v3d->uni_blit_proj, 1, GL_FALSE, mat);
 207
 208         glActiveTexture(GL_TEXTURE0);
 209         glBindTexture(GL_TEXTURE_2D, v3d->tex);
 210         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 211
 212         if (v3d->supports_rowlen) {
 213                 glPixelStorei(GL_UNPACK_ROW_LENGTH, buf->stride / 4);
 214                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
 215                              GL_BGRA_EXT, GL_UNSIGNED_BYTE, buf->data);
 216                 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 217         } else if (buf->stride == width) {
 218                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
 219                              GL_BGRA_EXT, GL_UNSIGNED_BYTE, buf->data);
 220         } else {
 221                 packed = malloc(width * height);
 222                 if (!packed)
 223                         return -ENOMEM;
 224
 225                 src = buf->data;
 226                 dst = packed;
 227                 for (i = 0; i < height; ++i) {
 228                         memcpy(dst, src, width * 4);
 229                         dst += width * 4;
 230                         src += buf->stride;
 231                 }
 232
 233                 glTexImage2D(GL_TEXTURE_2D, 0, GL_BGRA_EXT, width, height, 0,
 234                              GL_BGRA_EXT, GL_UNSIGNED_BYTE, packed);
 235
 236                 free(packed);
 237         }
 238
 239         glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
 240         glUniform1i(v3d->uni_blit_tex, 0);
 241
 242         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices);
 243         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, texpos);
 244         glEnableVertexAttribArray(0);
 245         glEnableVertexAttribArray(1);
 246         glDrawArrays(GL_TRIANGLES, 0, 6);
 247         glDisableVertexAttribArray(0);
 248         glDisableVertexAttribArray(1);
 249
 250         if (gl_has_error(v3d->blit_shader)) {
 251                 log_warning("GL error");
 252                 return -EFAULT;
 253         }
 254
 255         return 0;
 256 }
 257
 258 static int display_blend(struct uterm_display *disp,
 259                          const struct uterm_video_buffer *buf,
 260                          unsigned int x, unsigned int y,
 261                          uint8_t fr, uint8_t fg, uint8_t fb,
 262                          uint8_t br, uint8_t bg, uint8_t bb)
 263 {
 264         struct uterm_drm3d_video *v3d;
 265         unsigned int sw, sh, tmp, width, height, i;
 266         float mat[16];
 267         float vertices[6 * 2], texpos[6 * 2], fgcol[3], bgcol[3];
 268         int ret;
 269         uint8_t *packed, *src, *dst;
 270
 271         if (!buf || buf->format != UTERM_FORMAT_GREY)
 272                 return -EINVAL;
 273
 274         v3d = uterm_drm_video_get_data(disp->video);
 275         ret = uterm_drm3d_display_use(disp, NULL);
 276         if (ret)
 277                 return ret;
 278         ret = init_shaders(disp->video);
 279         if (ret)
 280                 return ret;
 281
 282         sw = uterm_drm_mode_get_width(disp->current_mode);
 283         sh = uterm_drm_mode_get_height(disp->current_mode);
 284
 285         vertices[0] = -1.0;
 286         vertices[1] = -1.0;
 287         vertices[2] = -1.0;
 288         vertices[3] = +1.0;
 289         vertices[4] = +1.0;
 290         vertices[5] = +1.0;
 291
 292         vertices[6] = -1.0;
 293         vertices[7] = -1.0;
 294         vertices[8] = +1.0;
 295         vertices[9] = +1.0;
 296         vertices[10] = +1.0;
 297         vertices[11] = -1.0;
 298
 299         texpos[0] = 0.0;
 300         texpos[1] = 1.0;
 301         texpos[2] = 0.0;
 302         texpos[3] = 0.0;
 303         texpos[4] = 1.0;
 304         texpos[5] = 0.0;
 305
 306         texpos[6] = 0.0;
 307         texpos[7] = 1.0;
 308         texpos[8] = 1.0;
 309         texpos[9] = 0.0;
 310         texpos[10] = 1.0;
 311         texpos[11] = 1.0;
 312
 313         fgcol[0] = fr / 255.0;
 314         fgcol[1] = fg / 255.0;
 315         fgcol[2] = fb / 255.0;
 316         bgcol[0] = br / 255.0;
 317         bgcol[1] = bg / 255.0;
 318         bgcol[2] = bb / 255.0;
 319
 320         tmp = x + buf->width;
 321         if (tmp < x || x >= sw)
 322                 return -EINVAL;
 323         if (tmp > sw)
 324                 width = sw - x;
 325         else
 326                 width = buf->width;
 327
 328         tmp = y + buf->height;
 329         if (tmp < y || y >= sh)
 330                 return -EINVAL;
 331         if (tmp > sh)
 332                 height = sh - y;
 333         else
 334                 height = buf->height;
 335
 336         glViewport(x, sh - y - height, width, height);
 337         glDisable(GL_BLEND);
 338
 339         gl_shader_use(v3d->blend_shader);
 340
 341         gl_m4_identity(mat);
 342         glUniformMatrix4fv(v3d->uni_blend_proj, 1, GL_FALSE, mat);
 343
 344         glUniform3fv(v3d->uni_blend_fgcol, 1, fgcol);
 345         glUniform3fv(v3d->uni_blend_bgcol, 1, bgcol);
 346
 347         glActiveTexture(GL_TEXTURE0);
 348         glBindTexture(GL_TEXTURE_2D, v3d->tex);
 349         glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
 350
 351         if (v3d->supports_rowlen) {
 352                 glPixelStorei(GL_UNPACK_ROW_LENGTH, buf->stride);
 353                 glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0,
 354                              GL_ALPHA, GL_UNSIGNED_BYTE, buf->data);
 355                 glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
 356         } else if (buf->stride == width) {
 357                 glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0,
 358                              GL_ALPHA, GL_UNSIGNED_BYTE, buf->data);
 359         } else {
 360                 packed = malloc(width * height);
 361                 if (!packed)
 362                         return -ENOMEM;
 363
 364                 src = buf->data;
 365                 dst = packed;
 366                 for (i = 0; i < height; ++i) {
 367                         memcpy(dst, src, width);
 368                         dst += width;
 369                         src += buf->stride;
 370                 }
 371
 372                 glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0,
 373                              GL_ALPHA, GL_UNSIGNED_BYTE, packed);
 374
 375                 free(packed);
 376         }
 377
 378         glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
 379         glUniform1i(v3d->uni_blend_tex, 0);
 380
 381         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices);
 382         glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, texpos);
 383         glEnableVertexAttribArray(0);
 384         glEnableVertexAttribArray(1);
 385         glDrawArrays(GL_TRIANGLES, 0, 6);
 386         glDisableVertexAttribArray(0);
 387         glDisableVertexAttribArray(1);
 388
 389         if (gl_has_error(v3d->blend_shader)) {
 390                 log_warning("GL error");
 391                 return -EFAULT;
 392         }
 393
 394         return 0;
 395 }
 396
 397 int uterm_drm3d_display_fake_blendv(struct uterm_display *disp,
 398                                     const struct uterm_video_blend_req *req,
 399                                     size_t num)
 400 {
 401         int ret;
 402         unsigned int i;
 403
 404         if (!disp || !req)
 405                 return -EINVAL;
 406
 407         for (i = 0; i < num; ++i, ++req) {
 408                 if (!req->buf)
 409                         continue;
 410
 411                 ret = display_blend(disp, req->buf, req->x, req->y,
 412                                     req->fr, req->fg, req->fb,
 413                                     req->br, req->bg, req->bb);
 414                 if (ret)
 415                         return ret;
 416         }
 417
 418         return 0;
 419 }
 420
 421 int uterm_drm3d_display_fill(struct uterm_display *disp,
 422                              uint8_t r, uint8_t g, uint8_t b,
 423                              unsigned int x, unsigned int y,
 424                              unsigned int width, unsigned int height)
 425 {
 426         struct uterm_drm3d_video *v3d;
 427         unsigned int sw, sh, tmp, i;
 428         float mat[16];
 429         float vertices[6 * 2], colors[6 * 4];
 430         int ret;
 431
 432         v3d = uterm_drm_video_get_data(disp->video);
 433         ret = uterm_drm3d_display_use(disp, NULL);
 434         if (ret)
 435                 return ret;
 436         ret = init_shaders(disp->video);
 437         if (ret)
 438                 return ret;
 439
 440         sw = uterm_drm_mode_get_width(disp->current_mode);
 441         sh = uterm_drm_mode_get_height(disp->current_mode);
 442
 443         for (i = 0; i < 6; ++i) {
 444                 colors[i * 4 + 0] = r / 255.0;
 445                 colors[i * 4 + 1] = g / 255.0;
 446                 colors[i * 4 + 2] = b / 255.0;
 447                 colors[i * 4 + 3] = 1.0;
 448         }
 449
 450         vertices[0] = -1.0;
 451         vertices[1] = -1.0;
 452         vertices[2] = -1.0;
 453         vertices[3] = +1.0;
 454         vertices[4] = +1.0;
 455         vertices[5] = +1.0;
 456
 457         vertices[6] = -1.0;
 458         vertices[7] = -1.0;
 459         vertices[8] = +1.0;
 460         vertices[9] = +1.0;
 461         vertices[10] = +1.0;
 462         vertices[11] = -1.0;
 463
 464         tmp = x + width;
 465         if (tmp < x || x >= sw)
 466                 return -EINVAL;
 467         if (tmp > sw)
 468                 width = sw - x;
 469         tmp = y + height;
 470         if (tmp < y || y >= sh)
 471                 return -EINVAL;
 472         if (tmp > sh)
 473                 height = sh - y;
 474
 475         glViewport(x, y, width, height);
 476         glDisable(GL_BLEND);
 477
 478         gl_shader_use(v3d->fill_shader);
 479         gl_m4_identity(mat);
 480         glUniformMatrix4fv(v3d->uni_fill_proj, 1, GL_FALSE, mat);
 481         glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices);
 482         glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, colors);
 483         glEnableVertexAttribArray(0);
 484         glEnableVertexAttribArray(1);
 485         glDrawArrays(GL_TRIANGLES, 0, 6);
 486         glDisableVertexAttribArray(0);
 487         glDisableVertexAttribArray(1);
 488
 489         if (gl_has_error(v3d->fill_shader)) {
 490                 log_warning("GL error");
 491                 return -EFAULT;
 492         }
 493
 494         return 0;
 495 }