src/gallium/state_trackers/egl/common/egl_g3d_st.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.9
   4  *
   5  * Copyright (C) 2010 LunarG Inc.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the "Software"),
   9  * to deal in the Software without restriction, including without limitation
  10  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11  * and/or sell copies of the Software, and to permit persons to whom the
  12  * Software is furnished to do so, subject to 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 OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  *
  25  * Authors:
  26  *    Chia-I Wu <olv@lunarg.com>
  27  */
  28
  29 #include "util/u_memory.h"
  30 #include "util/u_string.h"
  31 #include "util/u_inlines.h"
  32 #include "util/u_pointer.h"
  33 #include "util/u_dl.h"
  34 #include "egldriver.h"
  35 #include "eglimage.h"
  36 #include "eglmutex.h"
  37
  38 #include "egl_g3d.h"
  39 #include "egl_g3d_st.h"
  40
  41 struct egl_g3d_st_manager {
  42    struct st_manager base;
  43    _EGLDisplay *display;
  44 };
  45
  46 static INLINE struct egl_g3d_st_manager *
  47 egl_g3d_st_manager(struct st_manager *smapi)
  48 {
  49    return (struct egl_g3d_st_manager *) smapi;
  50 }
  51
  52 static boolean
  53 egl_g3d_st_manager_get_egl_image(struct st_manager *smapi,
  54                                  void *egl_image,
  55                                  struct st_egl_image *out)
  56 {
  57    struct egl_g3d_st_manager *gsmapi = egl_g3d_st_manager(smapi);
  58    EGLImageKHR handle = (EGLImageKHR) egl_image;
  59    _EGLImage *img;
  60    struct egl_g3d_image *gimg;
  61
  62    /* this is called from state trackers */
  63    _eglLockMutex(&gsmapi->display->Mutex);
  64
  65    img = _eglLookupImage(handle, gsmapi->display);
  66    if (!img) {
  67       _eglUnlockMutex(&gsmapi->display->Mutex);
  68       return FALSE;
  69    }
  70
  71    gimg = egl_g3d_image(img);
  72
  73    out->texture = NULL;
  74    pipe_resource_reference(&out->texture, gimg->texture);
  75    out->level = gimg->level;
  76    out->layer = gimg->layer;
  77
  78    _eglUnlockMutex(&gsmapi->display->Mutex);
  79
  80    return TRUE;
  81 }
  82
  83 static int
  84 egl_g3d_st_manager_get_param(struct st_manager *smapi,
  85                              enum st_manager_param param)
  86 {
  87    return 0;
  88 }
  89
  90 struct st_manager *
  91 egl_g3d_create_st_manager(_EGLDisplay *dpy)
  92 {
  93    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
  94    struct egl_g3d_st_manager *gsmapi;
  95
  96    gsmapi = CALLOC_STRUCT(egl_g3d_st_manager);
  97    if (gsmapi) {
  98       gsmapi->display = dpy;
  99
 100       gsmapi->base.screen = gdpy->native->screen;
 101       gsmapi->base.get_egl_image = egl_g3d_st_manager_get_egl_image;
 102       gsmapi->base.get_param = egl_g3d_st_manager_get_param;
 103    }
 104
 105    return &gsmapi->base;;
 106 }
 107
 108 void
 109 egl_g3d_destroy_st_manager(struct st_manager *smapi)
 110 {
 111    struct egl_g3d_st_manager *gsmapi = egl_g3d_st_manager(smapi);
 112    FREE(gsmapi);
 113 }
 114
 115 static boolean
 116 egl_g3d_st_framebuffer_flush_front_pbuffer(struct st_framebuffer_iface *stfbi,
 117                                            enum st_attachment_type statt)
 118 {
 119    return TRUE;
 120 }
 121
 122 static void
 123 pbuffer_reference_openvg_image(struct egl_g3d_surface *gsurf)
 124 {
 125    /* TODO */
 126 }
 127
 128 static void
 129 pbuffer_allocate_pbuffer_texture(struct egl_g3d_surface *gsurf)
 130 {
 131    struct egl_g3d_display *gdpy =
 132       egl_g3d_display(gsurf->base.Resource.Display);
 133    struct pipe_screen *screen = gdpy->native->screen;
 134    struct pipe_resource templ, *ptex;
 135
 136    memset(&templ, 0, sizeof(templ));
 137    templ.target = PIPE_TEXTURE_2D;
 138    templ.last_level = 0;
 139    templ.width0 = gsurf->base.Width;
 140    templ.height0 = gsurf->base.Height;
 141    templ.depth0 = 1;
 142    templ.array_size = 1;
 143    templ.format = gsurf->stvis.color_format;
 144    /* for rendering and binding to texture */
 145    templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 146
 147    ptex = screen->resource_create(screen, &templ);
 148    gsurf->render_texture = ptex;
 149 }
 150
 151 static boolean
 152 egl_g3d_st_framebuffer_validate_pbuffer(struct st_framebuffer_iface *stfbi,
 153                                         const enum st_attachment_type *statts,
 154                                         unsigned count,
 155                                         struct pipe_resource **out)
 156 {
 157    _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
 158    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 159    unsigned i;
 160
 161    for (i = 0; i < count; i++) {
 162       out[i] = NULL;
 163
 164       if (gsurf->stvis.render_buffer != statts[i])
 165          continue;
 166
 167       if (!gsurf->render_texture) {
 168          switch (gsurf->client_buffer_type) {
 169          case EGL_NONE:
 170             pbuffer_allocate_pbuffer_texture(gsurf);
 171             break;
 172          case EGL_OPENVG_IMAGE:
 173             pbuffer_reference_openvg_image(gsurf);
 174             break;
 175          default:
 176             break;
 177          }
 178
 179          if (!gsurf->render_texture)
 180             return FALSE;
 181       }
 182
 183       pipe_resource_reference(&out[i], gsurf->render_texture);
 184    }
 185
 186    return TRUE;
 187 }
 188
 189 static boolean
 190 egl_g3d_st_framebuffer_flush_front(struct st_framebuffer_iface *stfbi,
 191                                    enum st_attachment_type statt)
 192 {
 193    _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
 194    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 195
 196    return gsurf->native->present(gsurf->native,
 197          NATIVE_ATTACHMENT_FRONT_LEFT, FALSE, 0);
 198 }
 199
 200 static boolean
 201 egl_g3d_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
 202                                 const enum st_attachment_type *statts,
 203                                 unsigned count,
 204                                 struct pipe_resource **out)
 205 {
 206    _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
 207    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 208    struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
 209    uint attachment_mask = 0;
 210    unsigned i;
 211
 212    for (i = 0; i < count; i++) {
 213       int natt;
 214
 215       switch (statts[i]) {
 216       case ST_ATTACHMENT_FRONT_LEFT:
 217          natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 218          break;
 219       case ST_ATTACHMENT_BACK_LEFT:
 220          natt = NATIVE_ATTACHMENT_BACK_LEFT;
 221          break;
 222       case ST_ATTACHMENT_FRONT_RIGHT:
 223          natt = NATIVE_ATTACHMENT_FRONT_RIGHT;
 224          break;
 225       case ST_ATTACHMENT_BACK_RIGHT:
 226          natt = NATIVE_ATTACHMENT_BACK_RIGHT;
 227          break;
 228       default:
 229          natt = -1;
 230          break;
 231       }
 232
 233       if (natt >= 0)
 234          attachment_mask |= 1 << natt;
 235    }
 236
 237    if (!gsurf->native->validate(gsurf->native, attachment_mask,
 238          &gsurf->sequence_number, textures, &gsurf->base.Width,
 239          &gsurf->base.Height))
 240       return FALSE;
 241
 242    for (i = 0; i < count; i++) {
 243       struct pipe_resource *tex;
 244       int natt;
 245
 246       switch (statts[i]) {
 247       case ST_ATTACHMENT_FRONT_LEFT:
 248          natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 249          break;
 250       case ST_ATTACHMENT_BACK_LEFT:
 251          natt = NATIVE_ATTACHMENT_BACK_LEFT;
 252          break;
 253       case ST_ATTACHMENT_FRONT_RIGHT:
 254          natt = NATIVE_ATTACHMENT_FRONT_RIGHT;
 255          break;
 256       case ST_ATTACHMENT_BACK_RIGHT:
 257          natt = NATIVE_ATTACHMENT_BACK_RIGHT;
 258          break;
 259       default:
 260          natt = -1;
 261          break;
 262       }
 263
 264       if (natt >= 0) {
 265          tex = textures[natt];
 266
 267          if (statts[i] == stfbi->visual->render_buffer)
 268             pipe_resource_reference(&gsurf->render_texture, tex);
 269
 270          if (attachment_mask & (1 << natt)) {
 271             /* transfer the ownership to the caller */
 272             out[i] = tex;
 273             attachment_mask &= ~(1 << natt);
 274          }
 275          else {
 276             /* the attachment is listed more than once */
 277             pipe_resource_reference(&out[i], tex);
 278          }
 279       }
 280    }
 281
 282    return TRUE;
 283 }
 284
 285 struct st_framebuffer_iface *
 286 egl_g3d_create_st_framebuffer(_EGLSurface *surf)
 287 {
 288    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 289    struct st_framebuffer_iface *stfbi;
 290
 291    stfbi = CALLOC_STRUCT(st_framebuffer_iface);
 292    if (!stfbi)
 293       return NULL;
 294
 295    stfbi->visual = &gsurf->stvis;
 296    p_atomic_set(&stfbi->stamp, 1);
 297
 298    if (gsurf->base.Type != EGL_PBUFFER_BIT) {
 299       stfbi->flush_front = egl_g3d_st_framebuffer_flush_front;
 300       stfbi->validate = egl_g3d_st_framebuffer_validate;
 301    }
 302    else {
 303       stfbi->flush_front = egl_g3d_st_framebuffer_flush_front_pbuffer;
 304       stfbi->validate = egl_g3d_st_framebuffer_validate_pbuffer;
 305    }
 306    stfbi->st_manager_private = (void *) &gsurf->base;
 307
 308    return stfbi;
 309 }
 310
 311 void
 312 egl_g3d_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
 313 {
 314    FREE(stfbi);
 315 }