Subversion Repositories Kolibri OS

/*

 * Mesa 3-D graphics library

 *

 * Copyright (C) 2010 LunarG Inc.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 *

 * Authors:

 *    Chia-I Wu 

 */

#include "pipe/p_screen.h"

#include "util/u_memory.h"

#include "util/u_rect.h"

#include "util/u_inlines.h"

#include "eglcurrent.h"

#include "egllog.h"

#include "native.h"

#include "egl_g3d.h"

#include "egl_g3d_image.h"

/**

 * Reference and return the front left buffer of the native pixmap.

 */

static struct pipe_resource *

egl_g3d_reference_native_pixmap(_EGLDisplay *dpy, EGLNativePixmapType pix)

{

   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);

   struct native_surface *nsurf;

   struct pipe_resource *textures[NUM_NATIVE_ATTACHMENTS];

   enum native_attachment natt;

   nsurf = gdpy->native->create_pixmap_surface(gdpy->native, pix, NULL);

   if (!nsurf)

      return NULL;

   natt = NATIVE_ATTACHMENT_FRONT_LEFT;

   if (!nsurf->validate(nsurf, 1 << natt, NULL, textures, NULL, NULL))

      textures[natt] = NULL;

   nsurf->destroy(nsurf);

   return textures[natt];

}

#ifdef EGL_MESA_drm_image

static struct pipe_resource *

egl_g3d_create_drm_buffer(_EGLDisplay *dpy, _EGLImage *img,

                          const EGLint *attribs)

{

   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);

   struct pipe_screen *screen = gdpy->native->screen;

   struct pipe_resource templ;

   _EGLImageAttribs attrs;

   EGLint format, valid_use;

   if (_eglParseImageAttribList(&attrs, dpy, attribs) != EGL_SUCCESS)

      return NULL;

   if (attrs.Width <= 0 || attrs.Height <= 0) {

      _eglLog(_EGL_DEBUG, "bad width or height (%dx%d)",

            attrs.Width, attrs.Height);

      return NULL;

   }

   switch (attrs.DRMBufferFormatMESA) {

   case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:

      format = PIPE_FORMAT_B8G8R8A8_UNORM;

      break;

   default:

      _eglLog(_EGL_DEBUG, "bad image format value 0x%04x",

            attrs.DRMBufferFormatMESA);

      return NULL;

      break;

   }

   valid_use = EGL_DRM_BUFFER_USE_SCANOUT_MESA |

               EGL_DRM_BUFFER_USE_SHARE_MESA |

               EGL_DRM_BUFFER_USE_CURSOR_MESA;

   if (attrs.DRMBufferUseMESA & ~valid_use) {

      _eglLog(_EGL_DEBUG, "bad image use bit 0x%04x",

            attrs.DRMBufferUseMESA);

      return NULL;

   }

   memset(&templ, 0, sizeof(templ));

   templ.target = PIPE_TEXTURE_2D;

   templ.format = format;

   templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;

   templ.width0 = attrs.Width;

   templ.height0 = attrs.Height;

   templ.depth0 = 1;

   templ.array_size = 1;

   /*

    * XXX fix apps (e.g. wayland) and pipe drivers (e.g. i915) and remove the

    * size check

    */

   if ((attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SCANOUT_MESA) &&

       attrs.Width >= 640 && attrs.Height >= 480)

      templ.bind |= PIPE_BIND_SCANOUT;

   if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_SHARE_MESA)

      templ.bind |= PIPE_BIND_SHARED;

   if (attrs.DRMBufferUseMESA & EGL_DRM_BUFFER_USE_CURSOR_MESA) {

      if (attrs.Width != 64 || attrs.Height != 64)

         return NULL;

      templ.bind |= PIPE_BIND_CURSOR;

   }

   return screen->resource_create(screen, &templ);

}

static struct pipe_resource *

egl_g3d_reference_drm_buffer(_EGLDisplay *dpy, EGLint name,

                             _EGLImage *img, const EGLint *attribs)

{

   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);

   _EGLImageAttribs attrs;

   EGLint format;

   struct native_buffer nbuf;

   if (!dpy->Extensions.MESA_drm_image)

      return NULL;

   if (_eglParseImageAttribList(&attrs, dpy, attribs) != EGL_SUCCESS)

      return NULL;

   if (attrs.Width <= 0 || attrs.Height <= 0 ||

       attrs.DRMBufferStrideMESA <= 0) {

      _eglLog(_EGL_DEBUG, "bad width, height, or stride (%dx%dx%d)",

            attrs.Width, attrs.Height, attrs.DRMBufferStrideMESA);

      return NULL;

   }

   switch (attrs.DRMBufferFormatMESA) {

   case EGL_DRM_BUFFER_FORMAT_ARGB32_MESA:

      format = PIPE_FORMAT_B8G8R8A8_UNORM;

      break;

   default:

      _eglLog(_EGL_DEBUG, "bad image format value 0x%04x",

            attrs.DRMBufferFormatMESA);

      return NULL;

      break;

   }

   memset(&nbuf, 0, sizeof(nbuf));

   nbuf.type = NATIVE_BUFFER_DRM;

   nbuf.u.drm.templ.target = PIPE_TEXTURE_2D;

   nbuf.u.drm.templ.format = format;

   nbuf.u.drm.templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;

   nbuf.u.drm.templ.width0 = attrs.Width;

   nbuf.u.drm.templ.height0 = attrs.Height;

   nbuf.u.drm.templ.depth0 = 1;

   nbuf.u.drm.templ.array_size = 1;

   nbuf.u.drm.name = name;

   nbuf.u.drm.stride =

      attrs.DRMBufferStrideMESA * util_format_get_blocksize(format);

   return gdpy->native->buffer->import_buffer(gdpy->native, &nbuf);

}

#endif /* EGL_MESA_drm_image */

#ifdef EGL_WL_bind_wayland_display

static struct pipe_resource *

egl_g3d_reference_wl_buffer(_EGLDisplay *dpy, struct wl_buffer *buffer,

                            _EGLImage *img, const EGLint *attribs)

{

   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);

   struct pipe_resource *resource = NULL, *tmp = NULL;

   if (!gdpy->native->wayland_bufmgr)

      return NULL;

   tmp = gdpy->native->wayland_bufmgr->buffer_get_resource(gdpy->native, buffer);

   pipe_resource_reference(&resource, tmp);

   return resource;

}

#endif /* EGL_WL_bind_wayland_display */

#ifdef EGL_ANDROID_image_native_buffer

static struct pipe_resource *

egl_g3d_reference_android_native_buffer(_EGLDisplay *dpy,

                                        struct ANativeWindowBuffer *buf)

{

   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);

   struct native_buffer nbuf;

   memset(&nbuf, 0, sizeof(nbuf));

   nbuf.type = NATIVE_BUFFER_ANDROID;

   nbuf.u.android = buf;

   return gdpy->native->buffer->import_buffer(gdpy->native, &nbuf);

}

#endif /* EGL_ANDROID_image_native_buffer */

_EGLImage *

egl_g3d_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx,

                     EGLenum target, EGLClientBuffer buffer,

                     const EGLint *attribs)

{

   struct pipe_resource *ptex;

   struct egl_g3d_image *gimg;

   unsigned level = 0, layer = 0;

   gimg = CALLOC_STRUCT(egl_g3d_image);

   if (!gimg) {

      _eglError(EGL_BAD_ALLOC, "eglCreateEGLImageKHR");

      return NULL;

   }

   if (!_eglInitImage(&gimg->base, dpy)) {

      FREE(gimg);

      return NULL;

   }

   switch (target) {

   case EGL_NATIVE_PIXMAP_KHR:

      ptex = egl_g3d_reference_native_pixmap(dpy,

            (EGLNativePixmapType) buffer);

      break;

#ifdef EGL_MESA_drm_image

   case EGL_DRM_BUFFER_MESA:

      ptex = egl_g3d_reference_drm_buffer(dpy,

            (EGLint) pointer_to_intptr(buffer), &gimg->base, attribs);

      break;

#endif

#ifdef EGL_WL_bind_wayland_display

   case EGL_WAYLAND_BUFFER_WL:

      ptex = egl_g3d_reference_wl_buffer(dpy,

            (struct wl_buffer *) buffer, &gimg->base, attribs);

      break;

#endif

#ifdef EGL_ANDROID_image_native_buffer

   case EGL_NATIVE_BUFFER_ANDROID:

      ptex = egl_g3d_reference_android_native_buffer(dpy,

            (struct ANativeWindowBuffer *) buffer);

      break;

#endif

   default:

      ptex = NULL;

      break;

   }

   if (!ptex) {

      FREE(gimg);

      return NULL;

   }

   if (level > ptex->last_level) {

      _eglError(EGL_BAD_MATCH, "eglCreateEGLImageKHR");

      pipe_resource_reference(&gimg->texture, NULL);

      FREE(gimg);

      return NULL;

   }

   if (layer >= (u_minify(ptex->depth0, level) + ptex->array_size - 1)) {

      _eglError(EGL_BAD_PARAMETER, "eglCreateEGLImageKHR");

      pipe_resource_reference(&gimg->texture, NULL);

      FREE(gimg);

      return NULL;

   }

   /* transfer the ownership to the image */

   gimg->texture = ptex;

   gimg->level = level;

   gimg->layer = layer;

   return &gimg->base;

}

EGLBoolean

egl_g3d_destroy_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img)

{

   struct egl_g3d_image *gimg = egl_g3d_image(img);

   pipe_resource_reference(&gimg->texture, NULL);

   FREE(gimg);

   return EGL_TRUE;

}

_EGLImage *

egl_g3d_create_drm_image(_EGLDriver *drv, _EGLDisplay *dpy,

                         const EGLint *attribs)

{

   struct egl_g3d_image *gimg;

   struct pipe_resource *ptex;

   gimg = CALLOC_STRUCT(egl_g3d_image);

   if (!gimg) {

      _eglError(EGL_BAD_ALLOC, "eglCreateDRMImageKHR");

      return NULL;

   }

   if (!_eglInitImage(&gimg->base, dpy)) {

      FREE(gimg);

      return NULL;

   }

#ifdef EGL_MESA_drm_image

   ptex = egl_g3d_create_drm_buffer(dpy, &gimg->base, attribs);

#else

   ptex = NULL;

#endif

   if (!ptex) {

      FREE(gimg);

      return NULL;

   }

   /* transfer the ownership to the image */

   gimg->texture = ptex;

   gimg->level = 0;

   gimg->layer = 0;

   return &gimg->base;

}

EGLBoolean

egl_g3d_export_drm_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img,

			 EGLint *name, EGLint *handle, EGLint *stride)

{

   struct egl_g3d_display *gdpy = egl_g3d_display(dpy);

   struct egl_g3d_image *gimg = egl_g3d_image(img);

   struct native_buffer nbuf;

   if (!dpy->Extensions.MESA_drm_image)

      return EGL_FALSE;

   memset(&nbuf, 0, sizeof(nbuf));

   nbuf.type = NATIVE_BUFFER_DRM;

   if (name)

      nbuf.u.drm.templ.bind |= PIPE_BIND_SHARED;

   if (!gdpy->native->buffer->export_buffer(gdpy->native,

                                            gimg->texture, &nbuf))

      return EGL_FALSE;

   if (name)

      *name = nbuf.u.drm.name;

   if (handle)

      *handle = nbuf.u.drm.handle;

   if (stride)

      *stride = nbuf.u.drm.stride;

   return EGL_TRUE;

}