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

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.8
   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 "pipe/p_screen.h"
  30 #include "util/u_memory.h"
  31 #include "util/u_rect.h"
  32 #include "util/u_inlines.h"
  33 #include "eglcurrent.h"
  34 #include "egllog.h"
  35
  36 #include "native.h"
  37 #include "egl_g3d.h"
  38 #include "egl_g3d_api.h"
  39 #include "egl_g3d_image.h"
  40
  41 /* move this to native display? */
  42 #include "state_tracker/drm_driver.h"
  43
  44 /**
  45  * Reference and return the front left buffer of the native pixmap.
  46  */
  47 static struct pipe_resource *
  48 egl_g3d_reference_native_pixmap(_EGLDisplay *dpy, EGLNativePixmapType pix)
  49 {
  50    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
  51    struct egl_g3d_config *gconf;
  52    struct native_surface *nsurf;
  53    struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];
  54    enum native_attachment natt;
  55
  56    gconf = egl_g3d_config(egl_g3d_find_pixmap_config(dpy, pix));
  57    if (!gconf)
  58       return NULL;
  59
  60    nsurf = gdpy->native->create_pixmap_surface(gdpy->native,
  61          pix, gconf->native);
  62    if (!nsurf)
  63       return NULL;
  64
  65    natt = NATIVE_ATTACHMENT_FRONT_LEFT;
  66    if (!nsurf->validate(nsurf, 1 << natt, NULL, textures, NULL, NULL))
  67       textures[natt] = NULL;
  68
  69    nsurf->destroy(nsurf);
  70
  71    return textures[natt];
  72 }
  73
  74 #ifdef EGL_MESA_drm_image
  75
  76 static struct pipe_resource *
  77 egl_g3d_create_drm_buffer(_EGLDisplay *dpy, const EGLint *attribs)
  78 {
  79    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
  80    struct pipe_screen *screen = gdpy->native->screen;
  81    struct pipe_resource templ;
  82    EGLint width = 0, height = 0, format = 0, use = 0;
  83    EGLint valid_use;
  84    EGLint i, err = EGL_SUCCESS;
  85
  86    for (i = 0; attribs[i] != EGL_NONE; i++) {
  87       EGLint attr = attribs[i++];
  88       EGLint val = attribs[i];
  89
  90       switch (attr) {
  91       case EGL_WIDTH:
  92          width = val;
  93          break;
  94       case EGL_HEIGHT:
  95          height = val;
  96          break;
  97       case EGL_DRM_BUFFER_FORMAT_MESA:
  98          format = val;
  99          break;
 100       case EGL_DRM_BUFFER_USE_MESA:
 101          use = val;
 102          break;
 103       default:
 104          err = EGL_BAD_ATTRIBUTE;
 105          break;
 106       }
 107
 108       if (err != EGL_SUCCESS) {
 109          _eglLog(_EGL_DEBUG, "bad image attribute 0x%04x", attr);
 110          return NULL;
 111       }
 112    }
 113
 114    if (width <= 0 || height <= 0) {
 115       _eglLog(_EGL_DEBUG, "bad width or height (%dx%d)", width, height);
 116       return NULL;
 117    }
 118
 119    switch (format) {
 120    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
 121       format = PIPE_FORMAT_B8G8R8A8_UNORM;
 122       break;
 123    default:
 124       _eglLog(_EGL_DEBUG, "bad image format value 0x%04x", format);
 125       return NULL;
 126       break;
 127    }
 128
 129    valid_use = EGL_DRM_BUFFER_USE_SCANOUT_MESA |
 130                EGL_DRM_BUFFER_USE_SHARE_MESA;
 131    if (use & ~valid_use) {
 132       _eglLog(_EGL_DEBUG, "bad image use bit 0x%04x", use);
 133       return NULL;
 134    }
 135
 136    memset(&templ, 0, sizeof(templ));
 137    templ.target = PIPE_TEXTURE_2D;
 138    templ.format = format;
 139    templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 140    templ.width0 = width;
 141    templ.height0 = height;
 142    templ.depth0 = 1;
 143
 144    /*
 145     * XXX fix apps (e.g. wayland) and pipe drivers (e.g. i915) and remove the
 146     * size check
 147     */
 148    if ((use & EGL_DRM_BUFFER_USE_SCANOUT_MESA) &&
 149        width >= 640 && height >= 480)
 150       templ.bind |= PIPE_BIND_SCANOUT;
 151    if (use & EGL_DRM_BUFFER_USE_SHARE_MESA)
 152       templ.bind |= PIPE_BIND_SHARED;
 153
 154    return screen->resource_create(screen, &templ);
 155 }
 156
 157 static struct pipe_resource *
 158 egl_g3d_reference_drm_buffer(_EGLDisplay *dpy, EGLint name,
 159                              const EGLint *attribs)
 160 {
 161    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
 162    struct pipe_screen *screen = gdpy->native->screen;
 163    struct pipe_resource templ;
 164    struct winsys_handle wsh;
 165    EGLint width = 0, height = 0, format = 0, stride = 0;
 166    EGLint i, err = EGL_SUCCESS;
 167
 168    /* winsys_handle is in theory platform-specific */
 169    if (dpy->Platform != _EGL_PLATFORM_DRM)
 170       return NULL;
 171
 172    for (i = 0; attribs[i] != EGL_NONE; i++) {
 173       EGLint attr = attribs[i++];
 174       EGLint val = attribs[i];
 175
 176       switch (attr) {
 177       case EGL_WIDTH:
 178          width = val;
 179          break;
 180       case EGL_HEIGHT:
 181          height = val;
 182          break;
 183       case EGL_DRM_BUFFER_FORMAT_MESA:
 184          format = val;
 185          break;
 186       case EGL_DRM_BUFFER_STRIDE_MESA:
 187          stride = val;
 188          break;
 189       default:
 190          err = EGL_BAD_ATTRIBUTE;
 191          break;
 192       }
 193
 194       if (err != EGL_SUCCESS) {
 195          _eglLog(_EGL_DEBUG, "bad image attribute 0x%04x", attr);
 196          return NULL;
 197       }
 198    }
 199
 200    if (width <= 0 || height <= 0 || stride <= 0) {
 201       _eglLog(_EGL_DEBUG, "bad width, height, or stride (%dx%dx%d)",
 202             width, height, stride);
 203       return NULL;
 204    }
 205
 206    switch (format) {
 207    case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:
 208       format = PIPE_FORMAT_B8G8R8A8_UNORM;
 209       break;
 210    default:
 211       _eglLog(_EGL_DEBUG, "bad image format value 0x%04x", format);
 212       return NULL;
 213       break;
 214    }
 215
 216    memset(&templ, 0, sizeof(templ));
 217    templ.target = PIPE_TEXTURE_2D;
 218    templ.format = format;
 219    templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 220    templ.width0 = width;
 221    templ.height0 = height;
 222    templ.depth0 = 1;
 223
 224    memset(&wsh, 0, sizeof(wsh));
 225    wsh.handle = (unsigned) name;
 226    wsh.stride = stride;
 227
 228    return screen->resource_from_handle(screen, &templ, &wsh);
 229 }
 230
 231 #endif /* EGL_MESA_drm_image */
 232
 233 _EGLImage *
 234 egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx,
 235                      EGLenum target, EGLClientBuffer buffer,
 236                      const EGLint *attribs)
 237 {
 238    struct pipe_resource *ptex;
 239    struct egl_g3d_image *gimg;
 240    unsigned face = 0, level = 0, zslice = 0;
 241
 242    gimg = CALLOC_STRUCT(egl_g3d_image);
 243    if (!gimg) {
 244       _eglError(EGL_BAD_ALLOC, "eglCreateEGLImageKHR");
 245       return NULL;
 246    }
 247
 248    if (!_eglInitImage(&gimg->base, dpy, attribs)) {
 249       FREE(gimg);
 250       return NULL;
 251    }
 252
 253    switch (target) {
 254    case EGL_NATIVE_PIXMAP_KHR:
 255       ptex = egl_g3d_reference_native_pixmap(dpy,
 256             (EGLNativePixmapType) buffer);
 257       break;
 258 #ifdef EGL_MESA_drm_image
 259    case EGL_DRM_BUFFER_MESA:
 260       ptex = egl_g3d_reference_drm_buffer(dpy, (EGLint) buffer, attribs);
 261       break;
 262 #endif
 263    default:
 264       ptex = NULL;
 265       break;
 266    }
 267
 268    if (!ptex) {
 269       FREE(gimg);
 270       return NULL;
 271    }
 272
 273    if (level > ptex->last_level) {
 274       _eglError(EGL_BAD_MATCH, "eglCreateEGLImageKHR");
 275       pipe_resource_reference(&gimg->texture, NULL);
 276       FREE(gimg);
 277       return NULL;
 278    }
 279    if (zslice > ptex->depth0) {
 280       _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");
 281       pipe_resource_reference(&gimg->texture, NULL);
 282       FREE(gimg);
 283       return NULL;
 284    }
 285
 286    /* transfer the ownership to the image */
 287    gimg->texture = ptex;
 288    gimg->face = face;
 289    gimg->level = level;
 290    gimg->zslice = zslice;
 291
 292    return &gimg->base;
 293 }
 294
 295 EGLBoolean
 296 egl_g3d_destroy_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img)
 297 {
 298    struct egl_g3d_image *gimg = egl_g3d_image(img);
 299
 300    pipe_resource_reference(&gimg->texture, NULL);
 301    FREE(gimg);
 302
 303    return EGL_TRUE;
 304 }
 305
 306 _EGLImage *
 307 egl_g3d_create_drm_image(_EGLDriver *drv, _EGLDisplay *dpy,
 308                          const EGLint *attribs)
 309 {
 310    struct egl_g3d_image *gimg;
 311    struct pipe_resource *ptex;
 312
 313    gimg = CALLOC_STRUCT(egl_g3d_image);
 314    if (!gimg) {
 315       _eglError(EGL_BAD_ALLOC, "eglCreateDRMImageKHR");
 316       return NULL;
 317    }
 318
 319    if (!_eglInitImage(&gimg->base, dpy, attribs)) {
 320       FREE(gimg);
 321       return NULL;
 322    }
 323
 324 #ifdef EGL_MESA_drm_image
 325    ptex = egl_g3d_create_drm_buffer(dpy, attribs);
 326 #else
 327    ptex = NULL;
 328 #endif
 329    if (!ptex) {
 330       FREE(gimg);
 331       return NULL;
 332    }
 333
 334    /* transfer the ownership to the image */
 335    gimg->texture = ptex;
 336    gimg->face = 0;
 337    gimg->level = 0;
 338    gimg->zslice = 0;
 339
 340    return &gimg->base;
 341 }
 342
 343 EGLBoolean
 344 egl_g3d_export_drm_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img,
 345                          EGLint *name, EGLint *handle, EGLint *stride)
 346 {
 347    struct egl_g3d_display *gdpy = egl_g3d_display(dpy);
 348    struct egl_g3d_image *gimg = egl_g3d_image(img);
 349    struct pipe_screen *screen = gdpy->native->screen;
 350    struct winsys_handle wsh;
 351
 352    /* winsys_handle is in theory platform-specific */
 353    if (dpy->Platform != _EGL_PLATFORM_DRM)
 354       return EGL_FALSE;
 355
 356    /* get shared handle */
 357    if (name) {
 358       memset(&handle, 0, sizeof(handle));
 359       wsh.type = DRM_API_HANDLE_TYPE_SHARED;
 360       if (!screen->resource_get_handle(screen, gimg->texture, &wsh)) {
 361          return EGL_FALSE;
 362       }
 363
 364       *name = wsh.handle;
 365    }
 366
 367    /* get KMS handle */
 368    if (handle || stride) {
 369       memset(&wsh, 0, sizeof(wsh));
 370       wsh.type = DRM_API_HANDLE_TYPE_KMS;
 371       if (!screen->resource_get_handle(screen, gimg->texture, &wsh))
 372          return EGL_FALSE;
 373
 374       if (handle)
 375          *handle = wsh.handle;
 376       if (stride)
 377          *stride = wsh.stride;
 378    }
 379
 380    return EGL_TRUE;
 381 }