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_render_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    templ.bind = PIPE_BIND_RENDER_TARGET;
 145
 146    ptex = screen->resource_create(screen, &templ);
 147    gsurf->render_texture = ptex;
 148 }
 149
 150 static boolean
 151 egl_g3d_st_framebuffer_validate_pbuffer(struct st_framebuffer_iface *stfbi,
 152                                         const enum st_attachment_type *statts,
 153                                         unsigned count,
 154                                         struct pipe_resource **out)
 155 {
 156    _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
 157    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 158    unsigned i;
 159
 160    for (i = 0; i < count; i++) {
 161       out[i] = NULL;
 162
 163       if (gsurf->stvis.render_buffer != statts[i])
 164          continue;
 165
 166       if (!gsurf->render_texture) {
 167          switch (gsurf->client_buffer_type) {
 168          case EGL_NONE:
 169             pbuffer_allocate_render_texture(gsurf);
 170             break;
 171          case EGL_OPENVG_IMAGE:
 172             pbuffer_reference_openvg_image(gsurf);
 173             break;
 174          default:
 175             break;
 176          }
 177
 178          if (!gsurf->render_texture)
 179             return FALSE;
 180       }
 181
 182       pipe_resource_reference(&out[i], gsurf->render_texture);
 183    }
 184
 185    return TRUE;
 186 }
 187
 188 static boolean
 189 egl_g3d_st_framebuffer_flush_front(struct st_framebuffer_iface *stfbi,
 190                                    enum st_attachment_type statt)
 191 {
 192    _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
 193    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 194
 195    return gsurf->native->present(gsurf->native,
 196          NATIVE_ATTACHMENT_FRONT_LEFT, FALSE, 0);
 197 }
 198
 199 static boolean
 200 egl_g3d_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
 201                                 const enum st_attachment_type *statts,
 202                                 unsigned count,
 203                                 struct pipe_resource **out)
 204 {
 205    _EGLSurface *surf = (_EGLSurface *) stfbi->st_manager_private;
 206    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 207    struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
 208    uint attachment_mask = 0;
 209    unsigned i;
 210
 211    for (i = 0; i < count; i++) {
 212       int natt;
 213
 214       switch (statts[i]) {
 215       case ST_ATTACHMENT_FRONT_LEFT:
 216          natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 217          break;
 218       case ST_ATTACHMENT_BACK_LEFT:
 219          natt = NATIVE_ATTACHMENT_BACK_LEFT;
 220          break;
 221       case ST_ATTACHMENT_FRONT_RIGHT:
 222          natt = NATIVE_ATTACHMENT_FRONT_RIGHT;
 223          break;
 224       case ST_ATTACHMENT_BACK_RIGHT:
 225          natt = NATIVE_ATTACHMENT_BACK_RIGHT;
 226          break;
 227       default:
 228          natt = -1;
 229          break;
 230       }
 231
 232       if (natt >= 0)
 233          attachment_mask |= 1 << natt;
 234    }
 235
 236    if (!gsurf->native->validate(gsurf->native, attachment_mask,
 237          &gsurf->sequence_number, textures, &gsurf->base.Width,
 238          &gsurf->base.Height))
 239       return FALSE;
 240
 241    for (i = 0; i < count; i++) {
 242       struct pipe_resource *tex;
 243       int natt;
 244
 245       switch (statts[i]) {
 246       case ST_ATTACHMENT_FRONT_LEFT:
 247          natt = NATIVE_ATTACHMENT_FRONT_LEFT;
 248          break;
 249       case ST_ATTACHMENT_BACK_LEFT:
 250          natt = NATIVE_ATTACHMENT_BACK_LEFT;
 251          break;
 252       case ST_ATTACHMENT_FRONT_RIGHT:
 253          natt = NATIVE_ATTACHMENT_FRONT_RIGHT;
 254          break;
 255       case ST_ATTACHMENT_BACK_RIGHT:
 256          natt = NATIVE_ATTACHMENT_BACK_RIGHT;
 257          break;
 258       default:
 259          natt = -1;
 260          break;
 261       }
 262
 263       if (natt >= 0) {
 264          tex = textures[natt];
 265
 266          if (statts[i] == stfbi->visual->render_buffer)
 267             pipe_resource_reference(&gsurf->render_texture, tex);
 268
 269          if (attachment_mask & (1 << natt)) {
 270             /* transfer the ownership to the caller */
 271             out[i] = tex;
 272             attachment_mask &= ~(1 << natt);
 273          }
 274          else {
 275             /* the attachment is listed more than once */
 276             pipe_resource_reference(&out[i], tex);
 277          }
 278       }
 279    }
 280
 281    return TRUE;
 282 }
 283
 284 struct st_framebuffer_iface *
 285 egl_g3d_create_st_framebuffer(_EGLSurface *surf)
 286 {
 287    struct egl_g3d_surface *gsurf = egl_g3d_surface(surf);
 288    struct st_framebuffer_iface *stfbi;
 289
 290    stfbi = CALLOC_STRUCT(st_framebuffer_iface);
 291    if (!stfbi)
 292       return NULL;
 293
 294    stfbi->visual = &gsurf->stvis;
 295    p_atomic_set(&stfbi->stamp, 1);
 296
 297    if (gsurf->base.Type != EGL_PBUFFER_BIT) {
 298       stfbi->flush_front = egl_g3d_st_framebuffer_flush_front;
 299       stfbi->validate = egl_g3d_st_framebuffer_validate;
 300    }
 301    else {
 302       stfbi->flush_front = egl_g3d_st_framebuffer_flush_front_pbuffer;
 303       stfbi->validate = egl_g3d_st_framebuffer_validate_pbuffer;
 304    }
 305    stfbi->st_manager_private = (void *) &gsurf->base;
 306
 307    return stfbi;
 308 }
 309
 310 void
 311 egl_g3d_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
 312 {
 313    FREE(stfbi);
 314 }