src/gallium/state_trackers/dri/dri_helpers.c

   1 /*
   2  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included
  12  * in all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  18  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  19  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  20  * OTHER DEALINGS IN THE SOFTWARE.
  21  */
  22
  23 #include <dlfcn.h>
  24 #include "util/u_memory.h"
  25 #include "pipe/p_screen.h"
  26 #include "state_tracker/st_texture.h"
  27 #include "state_tracker/st_context.h"
  28 #include "state_tracker/st_cb_fbo.h"
  29 #include "main/texobj.h"
  30
  31 #include "dri_helpers.h"
  32
  33 static bool
  34 dri2_is_opencl_interop_loaded_locked(struct dri_screen *screen)
  35 {
  36    return screen->opencl_dri_event_add_ref &&
  37           screen->opencl_dri_event_release &&
  38           screen->opencl_dri_event_wait &&
  39           screen->opencl_dri_event_get_fence;
  40 }
  41
  42 static bool
  43 dri2_load_opencl_interop(struct dri_screen *screen)
  44 {
  45 #if defined(RTLD_DEFAULT)
  46    bool success;
  47
  48    mtx_lock(&screen->opencl_func_mutex);
  49
  50    if (dri2_is_opencl_interop_loaded_locked(screen)) {
  51       mtx_unlock(&screen->opencl_func_mutex);
  52       return true;
  53    }
  54
  55    screen->opencl_dri_event_add_ref =
  56       dlsym(RTLD_DEFAULT, "opencl_dri_event_add_ref");
  57    screen->opencl_dri_event_release =
  58       dlsym(RTLD_DEFAULT, "opencl_dri_event_release");
  59    screen->opencl_dri_event_wait =
  60       dlsym(RTLD_DEFAULT, "opencl_dri_event_wait");
  61    screen->opencl_dri_event_get_fence =
  62       dlsym(RTLD_DEFAULT, "opencl_dri_event_get_fence");
  63
  64    success = dri2_is_opencl_interop_loaded_locked(screen);
  65    mtx_unlock(&screen->opencl_func_mutex);
  66    return success;
  67 #else
  68    return false;
  69 #endif
  70 }
  71
  72 struct dri2_fence {
  73    struct dri_screen *driscreen;
  74    struct pipe_fence_handle *pipe_fence;
  75    void *cl_event;
  76 };
  77
  78 static unsigned dri2_fence_get_caps(__DRIscreen *_screen)
  79 {
  80    struct dri_screen *driscreen = dri_screen(_screen);
  81    struct pipe_screen *screen = driscreen->base.screen;
  82    unsigned caps = 0;
  83
  84    if (screen->get_param(screen, PIPE_CAP_NATIVE_FENCE_FD))
  85       caps |= __DRI_FENCE_CAP_NATIVE_FD;
  86
  87    return caps;
  88 }
  89
  90 static void *
  91 dri2_create_fence(__DRIcontext *_ctx)
  92 {
  93    struct st_context_iface *stapi = dri_context(_ctx)->st;
  94    struct dri2_fence *fence = CALLOC_STRUCT(dri2_fence);
  95
  96    if (!fence)
  97       return NULL;
  98
  99    stapi->flush(stapi, 0, &fence->pipe_fence);
 100
 101    if (!fence->pipe_fence) {
 102       FREE(fence);
 103       return NULL;
 104    }
 105
 106    fence->driscreen = dri_screen(_ctx->driScreenPriv);
 107    return fence;
 108 }
 109
 110 static void *
 111 dri2_create_fence_fd(__DRIcontext *_ctx, int fd)
 112 {
 113    struct st_context_iface *stapi = dri_context(_ctx)->st;
 114    struct pipe_context *ctx = stapi->pipe;
 115    struct dri2_fence *fence = CALLOC_STRUCT(dri2_fence);
 116
 117    if (fd == -1) {
 118       /* exporting driver created fence, flush: */
 119       stapi->flush(stapi, ST_FLUSH_FENCE_FD, &fence->pipe_fence);
 120    } else {
 121       /* importing a foreign fence fd: */
 122       ctx->create_fence_fd(ctx, &fence->pipe_fence, fd, PIPE_FD_TYPE_NATIVE_SYNC);
 123    }
 124    if (!fence->pipe_fence) {
 125       FREE(fence);
 126       return NULL;
 127    }
 128
 129    fence->driscreen = dri_screen(_ctx->driScreenPriv);
 130    return fence;
 131 }
 132
 133 static int
 134 dri2_get_fence_fd(__DRIscreen *_screen, void *_fence)
 135 {
 136    struct dri_screen *driscreen = dri_screen(_screen);
 137    struct pipe_screen *screen = driscreen->base.screen;
 138    struct dri2_fence *fence = (struct dri2_fence*)_fence;
 139
 140    return screen->fence_get_fd(screen, fence->pipe_fence);
 141 }
 142
 143 static void *
 144 dri2_get_fence_from_cl_event(__DRIscreen *_screen, intptr_t cl_event)
 145 {
 146    struct dri_screen *driscreen = dri_screen(_screen);
 147    struct dri2_fence *fence;
 148
 149    if (!dri2_load_opencl_interop(driscreen))
 150       return NULL;
 151
 152    fence = CALLOC_STRUCT(dri2_fence);
 153    if (!fence)
 154       return NULL;
 155
 156    fence->cl_event = (void*)cl_event;
 157
 158    if (!driscreen->opencl_dri_event_add_ref(fence->cl_event)) {
 159       free(fence);
 160       return NULL;
 161    }
 162
 163    fence->driscreen = driscreen;
 164    return fence;
 165 }
 166
 167 static void
 168 dri2_destroy_fence(__DRIscreen *_screen, void *_fence)
 169 {
 170    struct dri_screen *driscreen = dri_screen(_screen);
 171    struct pipe_screen *screen = driscreen->base.screen;
 172    struct dri2_fence *fence = (struct dri2_fence*)_fence;
 173
 174    if (fence->pipe_fence)
 175       screen->fence_reference(screen, &fence->pipe_fence, NULL);
 176    else if (fence->cl_event)
 177       driscreen->opencl_dri_event_release(fence->cl_event);
 178    else
 179       assert(0);
 180
 181    FREE(fence);
 182 }
 183
 184 static GLboolean
 185 dri2_client_wait_sync(__DRIcontext *_ctx, void *_fence, unsigned flags,
 186                       uint64_t timeout)
 187 {
 188    struct dri2_fence *fence = (struct dri2_fence*)_fence;
 189    struct dri_screen *driscreen = fence->driscreen;
 190    struct pipe_screen *screen = driscreen->base.screen;
 191
 192    /* No need to flush. The context was flushed when the fence was created. */
 193
 194    if (fence->pipe_fence)
 195       return screen->fence_finish(screen, NULL, fence->pipe_fence, timeout);
 196    else if (fence->cl_event) {
 197       struct pipe_fence_handle *pipe_fence =
 198          driscreen->opencl_dri_event_get_fence(fence->cl_event);
 199
 200       if (pipe_fence)
 201          return screen->fence_finish(screen, NULL, pipe_fence, timeout);
 202       else
 203          return driscreen->opencl_dri_event_wait(fence->cl_event, timeout);
 204    }
 205    else {
 206       assert(0);
 207       return false;
 208    }
 209 }
 210
 211 static void
 212 dri2_server_wait_sync(__DRIcontext *_ctx, void *_fence, unsigned flags)
 213 {
 214    struct pipe_context *ctx = dri_context(_ctx)->st->pipe;
 215    struct dri2_fence *fence = (struct dri2_fence*)_fence;
 216
 217    /* We might be called here with a NULL fence as a result of WaitSyncKHR
 218     * on a EGL_KHR_reusable_sync fence. Nothing to do here in such case.
 219     */
 220    if (!fence)
 221       return;
 222
 223    if (ctx->fence_server_sync)
 224       ctx->fence_server_sync(ctx, fence->pipe_fence);
 225 }
 226
 227 const __DRI2fenceExtension dri2FenceExtension = {
 228    .base = { __DRI2_FENCE, 2 },
 229
 230    .create_fence = dri2_create_fence,
 231    .get_fence_from_cl_event = dri2_get_fence_from_cl_event,
 232    .destroy_fence = dri2_destroy_fence,
 233    .client_wait_sync = dri2_client_wait_sync,
 234    .server_wait_sync = dri2_server_wait_sync,
 235    .get_capabilities = dri2_fence_get_caps,
 236    .create_fence_fd = dri2_create_fence_fd,
 237    .get_fence_fd = dri2_get_fence_fd,
 238 };
 239
 240 __DRIimage *
 241 dri2_lookup_egl_image(struct dri_screen *screen, void *handle)
 242 {
 243    const __DRIimageLookupExtension *loader = screen->sPriv->dri2.image;
 244    __DRIimage *img;
 245
 246    if (!loader->lookupEGLImage)
 247       return NULL;
 248
 249    img = loader->lookupEGLImage(screen->sPriv,
 250                                 handle, screen->sPriv->loaderPrivate);
 251
 252    return img;
 253 }
 254
 255 __DRIimage *
 256 dri2_create_image_from_renderbuffer2(__DRIcontext *context,
 257                                      int renderbuffer, void *loaderPrivate,
 258                                      unsigned *error)
 259 {
 260    struct gl_context *ctx = ((struct st_context *)dri_context(context)->st)->ctx;
 261    struct gl_renderbuffer *rb;
 262    struct pipe_resource *tex;
 263    __DRIimage *img;
 264
 265    /* Section 3.9 (EGLImage Specification and Management) of the EGL 1.5
 266     * specification says:
 267     *
 268     *   "If target is EGL_GL_RENDERBUFFER and buffer is not the name of a
 269     *    renderbuffer object, or if buffer is the name of a multisampled
 270     *    renderbuffer object, the error EGL_BAD_PARAMETER is generated."
 271     *
 272     *   "If target is EGL_GL_TEXTURE_2D , EGL_GL_TEXTURE_CUBE_MAP_*,
 273     *    EGL_GL_RENDERBUFFER or EGL_GL_TEXTURE_3D and buffer refers to the
 274     *    default GL texture object (0) for the corresponding GL target, the
 275     *    error EGL_BAD_PARAMETER is generated."
 276     *   (rely on _mesa_lookup_renderbuffer returning NULL in this case)
 277     */
 278    rb = _mesa_lookup_renderbuffer(ctx, renderbuffer);
 279    if (!rb || rb->NumSamples > 0) {
 280       *error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
 281       return NULL;
 282    }
 283
 284    tex = st_get_renderbuffer_resource(rb);
 285    if (!tex) {
 286       *error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
 287       return NULL;
 288    }
 289
 290    img = CALLOC_STRUCT(__DRIimageRec);
 291    if (!img) {
 292       *error = __DRI_IMAGE_ERROR_BAD_ALLOC;
 293       return NULL;
 294    }
 295
 296    img->dri_format = driGLFormatToImageFormat(rb->Format);
 297    img->loader_private = loaderPrivate;
 298
 299    pipe_resource_reference(&img->texture, tex);
 300
 301    *error = __DRI_IMAGE_ERROR_SUCCESS;
 302    return img;
 303 }
 304
 305 __DRIimage *
 306 dri2_create_image_from_renderbuffer(__DRIcontext *context,
 307                                     int renderbuffer, void *loaderPrivate)
 308 {
 309    unsigned error;
 310    return dri2_create_image_from_renderbuffer2(context, renderbuffer,
 311                                                loaderPrivate, &error);
 312 }
 313
 314 void
 315 dri2_destroy_image(__DRIimage *img)
 316 {
 317    pipe_resource_reference(&img->texture, NULL);
 318    FREE(img);
 319 }
 320
 321
 322 __DRIimage *
 323 dri2_create_from_texture(__DRIcontext *context, int target, unsigned texture,
 324                          int depth, int level, unsigned *error,
 325                          void *loaderPrivate)
 326 {
 327    __DRIimage *img;
 328    struct gl_context *ctx = ((struct st_context *)dri_context(context)->st)->ctx;
 329    struct gl_texture_object *obj;
 330    struct pipe_resource *tex;
 331    GLuint face = 0;
 332
 333    obj = _mesa_lookup_texture(ctx, texture);
 334    if (!obj || obj->Target != target) {
 335       *error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
 336       return NULL;
 337    }
 338
 339    tex = st_get_texobj_resource(obj);
 340    if (!tex) {
 341       *error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
 342       return NULL;
 343    }
 344
 345    if (target == GL_TEXTURE_CUBE_MAP)
 346       face = depth;
 347
 348    _mesa_test_texobj_completeness(ctx, obj);
 349    if (!obj->_BaseComplete || (level > 0 && !obj->_MipmapComplete)) {
 350       *error = __DRI_IMAGE_ERROR_BAD_PARAMETER;
 351       return NULL;
 352    }
 353
 354    if (level < obj->BaseLevel || level > obj->_MaxLevel) {
 355       *error = __DRI_IMAGE_ERROR_BAD_MATCH;
 356       return NULL;
 357    }
 358
 359    if (target == GL_TEXTURE_3D && obj->Image[face][level]->Depth < depth) {
 360       *error = __DRI_IMAGE_ERROR_BAD_MATCH;
 361       return NULL;
 362    }
 363
 364    img = CALLOC_STRUCT(__DRIimageRec);
 365    if (!img) {
 366       *error = __DRI_IMAGE_ERROR_BAD_ALLOC;
 367       return NULL;
 368    }
 369
 370    img->level = level;
 371    img->layer = depth;
 372    img->dri_format = driGLFormatToImageFormat(obj->Image[face][level]->TexFormat);
 373
 374    img->loader_private = loaderPrivate;
 375
 376    pipe_resource_reference(&img->texture, tex);
 377
 378    *error = __DRI_IMAGE_ERROR_SUCCESS;
 379    return img;
 380 }
 381
 382 static const struct dri2_format_mapping dri2_format_table[] = {
 383       { __DRI_IMAGE_FOURCC_ABGR16161616F, __DRI_IMAGE_FORMAT_ABGR16161616F,
 384         __DRI_IMAGE_COMPONENTS_RGBA,      PIPE_FORMAT_R16G16B16A16_FLOAT, 1,
 385         { { 0, 0, 0, __DRI_IMAGE_FORMAT_ABGR16161616F, 4 } } },
 386       { __DRI_IMAGE_FOURCC_XBGR16161616F, __DRI_IMAGE_FORMAT_XBGR16161616F,
 387         __DRI_IMAGE_COMPONENTS_RGB,       PIPE_FORMAT_R16G16B16X16_FLOAT, 1,
 388         { { 0, 0, 0, __DRI_IMAGE_FORMAT_XBGR16161616F, 4 } } },
 389       { __DRI_IMAGE_FOURCC_ARGB2101010,   __DRI_IMAGE_FORMAT_ARGB2101010,
 390         __DRI_IMAGE_COMPONENTS_RGBA,      PIPE_FORMAT_B10G10R10A2_UNORM, 1,
 391         { { 0, 0, 0, __DRI_IMAGE_FORMAT_ARGB2101010, 4 } } },
 392       { __DRI_IMAGE_FOURCC_XRGB2101010,   __DRI_IMAGE_FORMAT_XRGB2101010,
 393         __DRI_IMAGE_COMPONENTS_RGB,       PIPE_FORMAT_B10G10R10X2_UNORM, 1,
 394         { { 0, 0, 0, __DRI_IMAGE_FORMAT_XRGB2101010, 4 } } },
 395       { __DRI_IMAGE_FOURCC_ABGR2101010,   __DRI_IMAGE_FORMAT_ABGR2101010,
 396         __DRI_IMAGE_COMPONENTS_RGBA,      PIPE_FORMAT_R10G10B10A2_UNORM, 1,
 397         { { 0, 0, 0, __DRI_IMAGE_FORMAT_ABGR2101010, 4 } } },
 398       { __DRI_IMAGE_FOURCC_XBGR2101010,   __DRI_IMAGE_FORMAT_XBGR2101010,
 399         __DRI_IMAGE_COMPONENTS_RGB,       PIPE_FORMAT_R10G10B10X2_UNORM, 1,
 400         { { 0, 0, 0, __DRI_IMAGE_FORMAT_XBGR2101010, 4 } } },
 401       { __DRI_IMAGE_FOURCC_ARGB8888,      __DRI_IMAGE_FORMAT_ARGB8888,
 402         __DRI_IMAGE_COMPONENTS_RGBA,      PIPE_FORMAT_BGRA8888_UNORM, 1,
 403         { { 0, 0, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 } } },
 404       { __DRI_IMAGE_FOURCC_ABGR8888,      __DRI_IMAGE_FORMAT_ABGR8888,
 405         __DRI_IMAGE_COMPONENTS_RGBA,      PIPE_FORMAT_RGBA8888_UNORM, 1,
 406         { { 0, 0, 0, __DRI_IMAGE_FORMAT_ABGR8888, 4 } } },
 407       { __DRI_IMAGE_FOURCC_SARGB8888,     __DRI_IMAGE_FORMAT_SARGB8,
 408         __DRI_IMAGE_COMPONENTS_RGBA,      PIPE_FORMAT_BGRA8888_SRGB, 1,
 409         { { 0, 0, 0, __DRI_IMAGE_FORMAT_SARGB8, 4 } } },
 410       { __DRI_IMAGE_FOURCC_XRGB8888,      __DRI_IMAGE_FORMAT_XRGB8888,
 411         __DRI_IMAGE_COMPONENTS_RGB,       PIPE_FORMAT_BGRX8888_UNORM, 1,
 412         { { 0, 0, 0, __DRI_IMAGE_FORMAT_XRGB8888, 4 }, } },
 413       { __DRI_IMAGE_FOURCC_XBGR8888,      __DRI_IMAGE_FORMAT_XBGR8888,
 414         __DRI_IMAGE_COMPONENTS_RGB,       PIPE_FORMAT_RGBX8888_UNORM, 1,
 415         { { 0, 0, 0, __DRI_IMAGE_FORMAT_XBGR8888, 4 }, } },
 416       { __DRI_IMAGE_FOURCC_ARGB1555,      __DRI_IMAGE_FORMAT_ARGB1555,
 417         __DRI_IMAGE_COMPONENTS_RGBA,      PIPE_FORMAT_B5G5R5A1_UNORM, 1,
 418         { { 0, 0, 0, __DRI_IMAGE_FORMAT_ARGB1555, 2 } } },
 419       { __DRI_IMAGE_FOURCC_RGB565,        __DRI_IMAGE_FORMAT_RGB565,
 420         __DRI_IMAGE_COMPONENTS_RGB,       PIPE_FORMAT_B5G6R5_UNORM, 1,
 421         { { 0, 0, 0, __DRI_IMAGE_FORMAT_RGB565, 2 } } },
 422       { __DRI_IMAGE_FOURCC_R8,            __DRI_IMAGE_FORMAT_R8,
 423         __DRI_IMAGE_COMPONENTS_R,         PIPE_FORMAT_R8_UNORM, 1,
 424         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 }, } },
 425       { __DRI_IMAGE_FOURCC_R16,           __DRI_IMAGE_FORMAT_R16,
 426         __DRI_IMAGE_COMPONENTS_R,         PIPE_FORMAT_R16_UNORM, 1,
 427         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R16, 1 }, } },
 428       { __DRI_IMAGE_FOURCC_GR88,          __DRI_IMAGE_FORMAT_GR88,
 429         __DRI_IMAGE_COMPONENTS_RG,        PIPE_FORMAT_RG88_UNORM, 1,
 430         { { 0, 0, 0, __DRI_IMAGE_FORMAT_GR88, 2 }, } },
 431       { __DRI_IMAGE_FOURCC_GR1616,        __DRI_IMAGE_FORMAT_GR1616,
 432         __DRI_IMAGE_COMPONENTS_RG,        PIPE_FORMAT_RG1616_UNORM, 1,
 433         { { 0, 0, 0, __DRI_IMAGE_FORMAT_GR1616, 2 }, } },
 434
 435       { __DRI_IMAGE_FOURCC_YUV410, __DRI_IMAGE_FORMAT_NONE,
 436         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 437         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 438           { 1, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 },
 439           { 2, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 } } },
 440       { __DRI_IMAGE_FOURCC_YUV411, __DRI_IMAGE_FORMAT_NONE,
 441         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 442         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 443           { 1, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 444           { 2, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
 445       { __DRI_IMAGE_FOURCC_YUV420,        __DRI_IMAGE_FORMAT_NONE,
 446         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 447         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 448           { 1, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 },
 449           { 2, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 } } },
 450       { __DRI_IMAGE_FOURCC_YUV422,        __DRI_IMAGE_FORMAT_NONE,
 451         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 452         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 453           { 1, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 454           { 2, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
 455       { __DRI_IMAGE_FOURCC_YUV444,        __DRI_IMAGE_FORMAT_NONE,
 456         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 457         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 458           { 1, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 459           { 2, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
 460
 461       { __DRI_IMAGE_FOURCC_YVU410,        __DRI_IMAGE_FORMAT_NONE,
 462         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 463         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 464           { 2, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 },
 465           { 1, 2, 2, __DRI_IMAGE_FORMAT_R8, 1 } } },
 466       { __DRI_IMAGE_FOURCC_YVU411,        __DRI_IMAGE_FORMAT_NONE,
 467         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 468         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 469           { 2, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 470           { 1, 2, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
 471       { __DRI_IMAGE_FOURCC_YVU420,        __DRI_IMAGE_FORMAT_NONE,
 472         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 473         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 474           { 2, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 },
 475           { 1, 1, 1, __DRI_IMAGE_FORMAT_R8, 1 } } },
 476       { __DRI_IMAGE_FOURCC_YVU422,        __DRI_IMAGE_FORMAT_NONE,
 477         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 478         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 479           { 2, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 480           { 1, 1, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
 481       { __DRI_IMAGE_FOURCC_YVU444,        __DRI_IMAGE_FORMAT_NONE,
 482         __DRI_IMAGE_COMPONENTS_Y_U_V,     PIPE_FORMAT_IYUV, 3,
 483         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 484           { 2, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 485           { 1, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 } } },
 486
 487       { __DRI_IMAGE_FOURCC_NV12,          __DRI_IMAGE_FORMAT_NONE,
 488         __DRI_IMAGE_COMPONENTS_Y_UV,      PIPE_FORMAT_NV12, 2,
 489         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 490           { 1, 1, 1, __DRI_IMAGE_FORMAT_GR88, 2 } } },
 491
 492       { __DRI_IMAGE_FOURCC_P010,          __DRI_IMAGE_FORMAT_NONE,
 493         __DRI_IMAGE_COMPONENTS_Y_UV,      PIPE_FORMAT_P016, 2,
 494         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R16, 2 },
 495           { 1, 1, 1, __DRI_IMAGE_FORMAT_GR1616, 4 } } },
 496       { __DRI_IMAGE_FOURCC_P012,          __DRI_IMAGE_FORMAT_NONE,
 497         __DRI_IMAGE_COMPONENTS_Y_UV,      PIPE_FORMAT_P016, 2,
 498         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R16, 2 },
 499           { 1, 1, 1, __DRI_IMAGE_FORMAT_GR1616, 4 } } },
 500       { __DRI_IMAGE_FOURCC_P016,          __DRI_IMAGE_FORMAT_NONE,
 501         __DRI_IMAGE_COMPONENTS_Y_UV,      PIPE_FORMAT_P016, 2,
 502         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R16, 2 },
 503           { 1, 1, 1, __DRI_IMAGE_FORMAT_GR1616, 4 } } },
 504
 505       { __DRI_IMAGE_FOURCC_NV16,          __DRI_IMAGE_FORMAT_NONE,
 506         __DRI_IMAGE_COMPONENTS_Y_UV,      PIPE_FORMAT_NV12, 2,
 507         { { 0, 0, 0, __DRI_IMAGE_FORMAT_R8, 1 },
 508           { 1, 1, 0, __DRI_IMAGE_FORMAT_GR88, 2 } } },
 509
 510       { __DRI_IMAGE_FOURCC_AYUV,      __DRI_IMAGE_FORMAT_ABGR8888,
 511         __DRI_IMAGE_COMPONENTS_AYUV,      PIPE_FORMAT_AYUV, 1,
 512         { { 0, 0, 0, __DRI_IMAGE_FORMAT_ABGR8888, 4 } } },
 513       { __DRI_IMAGE_FOURCC_XYUV8888,      __DRI_IMAGE_FORMAT_XBGR8888,
 514         __DRI_IMAGE_COMPONENTS_XYUV,      PIPE_FORMAT_XYUV, 1,
 515         { { 0, 0, 0, __DRI_IMAGE_FORMAT_XBGR8888, 4 } } },
 516
 517       /* For YUYV and UYVY buffers, we set up two overlapping DRI images
 518        * and treat them as planar buffers in the compositors.
 519        * Plane 0 is GR88 and samples YU or YV pairs and places Y into
 520        * the R component, while plane 1 is ARGB/ABGR and samples YUYV/UYVY
 521        * clusters and places pairs and places U into the G component and
 522        * V into A.  This lets the texture sampler interpolate the Y
 523        * components correctly when sampling from plane 0, and interpolate
 524        * U and V correctly when sampling from plane 1. */
 525       { __DRI_IMAGE_FOURCC_YUYV,          __DRI_IMAGE_FORMAT_NONE,
 526         __DRI_IMAGE_COMPONENTS_Y_XUXV,    PIPE_FORMAT_YUYV, 2,
 527         { { 0, 0, 0, __DRI_IMAGE_FORMAT_GR88, 2 },
 528           { 0, 1, 0, __DRI_IMAGE_FORMAT_ARGB8888, 4 } } },
 529       { __DRI_IMAGE_FOURCC_UYVY,          __DRI_IMAGE_FORMAT_NONE,
 530         __DRI_IMAGE_COMPONENTS_Y_UXVX,    PIPE_FORMAT_UYVY, 2,
 531         { { 0, 0, 0, __DRI_IMAGE_FORMAT_GR88, 2 },
 532           { 0, 1, 0, __DRI_IMAGE_FORMAT_ABGR8888, 4 } } }
 533 };
 534
 535 const struct dri2_format_mapping *
 536 dri2_get_mapping_by_fourcc(int fourcc)
 537 {
 538    for (unsigned i = 0; i < ARRAY_SIZE(dri2_format_table); i++) {
 539       if (dri2_format_table[i].dri_fourcc == fourcc)
 540          return &dri2_format_table[i];
 541    }
 542
 543    return NULL;
 544 }
 545
 546 const struct dri2_format_mapping *
 547 dri2_get_mapping_by_format(int format)
 548 {
 549    for (unsigned i = 0; i < ARRAY_SIZE(dri2_format_table); i++) {
 550       if (dri2_format_table[i].dri_format == format)
 551          return &dri2_format_table[i];
 552    }
 553
 554    return NULL;
 555 }
 556
 557 enum pipe_format
 558 dri2_get_pipe_format_for_dri_format(int format)
 559 {
 560    for (unsigned i = 0; i < ARRAY_SIZE(dri2_format_table); i++) {
 561       if (dri2_format_table[i].dri_format == format)
 562          return dri2_format_table[i].pipe_format;
 563    }
 564
 565    return PIPE_FORMAT_NONE;
 566 }
 567
 568 boolean
 569 dri2_query_dma_buf_formats(__DRIscreen *_screen, int max, int *formats,
 570                            int *count)
 571 {
 572    struct dri_screen *screen = dri_screen(_screen);
 573    struct pipe_screen *pscreen = screen->base.screen;
 574    int i, j;
 575
 576    for (i = 0, j = 0; (i < ARRAY_SIZE(dri2_format_table)) &&
 577          (j < max || max == 0); i++) {
 578       const struct dri2_format_mapping *map = &dri2_format_table[i];
 579
 580       /* The sRGB format is not a real FourCC as defined by drm_fourcc.h, so we
 581        * must not leak it out to clients.
 582        */
 583       if (dri2_format_table[i].dri_fourcc == __DRI_IMAGE_FOURCC_SARGB8888)
 584          continue;
 585
 586       if (pscreen->is_format_supported(pscreen, map->pipe_format,
 587                                        screen->target, 0, 0,
 588                                        PIPE_BIND_RENDER_TARGET) ||
 589           pscreen->is_format_supported(pscreen, map->pipe_format,
 590                                        screen->target, 0, 0,
 591                                        PIPE_BIND_SAMPLER_VIEW)) {
 592          if (j < max)
 593             formats[j] = map->dri_fourcc;
 594          j++;
 595       }
 596    }
 597    *count = j;
 598    return true;
 599 }
 600
 601 /* vim: set sw=3 ts=8 sts=3 expandtab: */