src/gallium/state_trackers/dri/common/dri_drawable.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009, VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27 /*
  28  * Author: Keith Whitwell <keithw@vmware.com>
  29  * Author: Jakob Bornecrantz <wallbraker@gmail.com>
  30  */
  31
  32 #include "dri_screen.h"
  33 #include "dri_context.h"
  34 #include "dri_drawable.h"
  35
  36 #include "pipe/p_screen.h"
  37 #include "util/u_format.h"
  38 #include "util/u_memory.h"
  39 #include "util/u_inlines.h"
  40
  41
  42 static boolean
  43 dri_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
  44                             const enum st_attachment_type *statts,
  45                             unsigned count,
  46                             struct pipe_resource **out)
  47 {
  48    struct dri_drawable *drawable =
  49       (struct dri_drawable *) stfbi->st_manager_private;
  50    struct dri_screen *screen = dri_screen(drawable->sPriv);
  51    unsigned statt_mask, new_mask;
  52    boolean new_stamp;
  53    int i;
  54
  55    statt_mask = 0x0;
  56    for (i = 0; i < count; i++)
  57       statt_mask |= (1 << statts[i]);
  58
  59    /* record newly allocated textures */
  60    new_mask = (statt_mask & ~drawable->texture_mask);
  61
  62    /*
  63     * dPriv->pStamp is the server stamp.  It should be accessed with a lock, at
  64     * least for DRI1.  dPriv->lastStamp is the client stamp.  It has the value
  65     * of the server stamp when last checked.
  66     */
  67    new_stamp = (drawable->texture_stamp != drawable->dPriv->lastStamp);
  68
  69    if (new_stamp || new_mask || screen->broken_invalidate) {
  70       if (new_stamp && drawable->update_drawable_info)
  71          drawable->update_drawable_info(drawable);
  72
  73       drawable->allocate_textures(drawable, statts, count);
  74
  75       /* add existing textures */
  76       for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
  77          if (drawable->textures[i])
  78             statt_mask |= (1 << i);
  79       }
  80
  81       drawable->texture_stamp = drawable->dPriv->lastStamp;
  82       drawable->texture_mask = statt_mask;
  83    }
  84
  85    if (!out)
  86       return TRUE;
  87
  88    for (i = 0; i < count; i++) {
  89       out[i] = NULL;
  90       pipe_resource_reference(&out[i], drawable->textures[statts[i]]);
  91    }
  92
  93    return TRUE;
  94 }
  95
  96 static boolean
  97 dri_st_framebuffer_flush_front(struct st_framebuffer_iface *stfbi,
  98                                enum st_attachment_type statt)
  99 {
 100    struct dri_drawable *drawable =
 101       (struct dri_drawable *) stfbi->st_manager_private;
 102
 103    /* XXX remove this and just set the correct one on the framebuffer */
 104    drawable->flush_frontbuffer(drawable, statt);
 105
 106    return TRUE;
 107 }
 108
 109 /**
 110  * This is called when we need to set up GL rendering to a new X window.
 111  */
 112 boolean
 113 dri_create_buffer(__DRIscreen * sPriv,
 114                   __DRIdrawable * dPriv,
 115                   const struct gl_config * visual, boolean isPixmap)
 116 {
 117    struct dri_screen *screen = sPriv->private;
 118    struct dri_drawable *drawable = NULL;
 119
 120    if (isPixmap)
 121       goto fail;                       /* not implemented */
 122
 123    drawable = CALLOC_STRUCT(dri_drawable);
 124    if (drawable == NULL)
 125       goto fail;
 126
 127    dri_fill_st_visual(&drawable->stvis, screen, visual);
 128
 129    /* setup the st_framebuffer_iface */
 130    drawable->base.visual = &drawable->stvis;
 131    drawable->base.flush_front = dri_st_framebuffer_flush_front;
 132    drawable->base.validate = dri_st_framebuffer_validate;
 133    drawable->base.st_manager_private = (void *) drawable;
 134
 135    drawable->screen = screen;
 136    drawable->sPriv = sPriv;
 137    drawable->dPriv = dPriv;
 138    dPriv->driverPrivate = (void *)drawable;
 139    p_atomic_set(&drawable->base.stamp, 1);
 140
 141    return GL_TRUE;
 142 fail:
 143    FREE(drawable);
 144    return GL_FALSE;
 145 }
 146
 147 void
 148 dri_destroy_buffer(__DRIdrawable * dPriv)
 149 {
 150    struct dri_drawable *drawable = dri_drawable(dPriv);
 151    int i;
 152
 153    pipe_surface_reference(&drawable->drisw_surface, NULL);
 154
 155    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
 156       pipe_resource_reference(&drawable->textures[i], NULL);
 157
 158    FREE(drawable);
 159 }
 160
 161 /**
 162  * Validate the texture at an attachment.  Allocate the texture if it does not
 163  * exist.  Used by the TFP extension.
 164  */
 165 static void
 166 dri_drawable_validate_att(struct dri_drawable *drawable,
 167                           enum st_attachment_type statt)
 168 {
 169    enum st_attachment_type statts[ST_ATTACHMENT_COUNT];
 170    unsigned i, count = 0;
 171
 172    /* check if buffer already exists */
 173    if (drawable->texture_mask & (1 << statt))
 174       return;
 175
 176    /* make sure DRI2 does not destroy existing buffers */
 177    for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
 178       if (drawable->texture_mask & (1 << i)) {
 179          statts[count++] = i;
 180       }
 181    }
 182    statts[count++] = statt;
 183
 184    drawable->texture_stamp = drawable->dPriv->lastStamp - 1;
 185
 186    drawable->base.validate(&drawable->base, statts, count, NULL);
 187 }
 188
 189 /**
 190  * These are used for GLX_EXT_texture_from_pixmap
 191  */
 192 static void
 193 dri_set_tex_buffer2(__DRIcontext *pDRICtx, GLint target,
 194                     GLint format, __DRIdrawable *dPriv)
 195 {
 196    struct dri_context *ctx = dri_context(pDRICtx);
 197    struct dri_drawable *drawable = dri_drawable(dPriv);
 198    struct pipe_resource *pt;
 199
 200    dri_drawable_validate_att(drawable, ST_ATTACHMENT_FRONT_LEFT);
 201
 202    pt = drawable->textures[ST_ATTACHMENT_FRONT_LEFT];
 203
 204    if (pt) {
 205       enum pipe_format internal_format = pt->format;
 206
 207       if (format == __DRI_TEXTURE_FORMAT_RGB)  {
 208          /* only need to cover the formats recognized by dri_fill_st_visual */
 209          switch (internal_format) {
 210          case PIPE_FORMAT_B8G8R8A8_UNORM:
 211             internal_format = PIPE_FORMAT_B8G8R8X8_UNORM;
 212             break;
 213          case PIPE_FORMAT_A8R8G8B8_UNORM:
 214             internal_format = PIPE_FORMAT_X8R8G8B8_UNORM;
 215             break;
 216          default:
 217             break;
 218          }
 219       }
 220
 221       ctx->st->teximage(ctx->st,
 222             (target == GL_TEXTURE_2D) ? ST_TEXTURE_2D : ST_TEXTURE_RECT,
 223             0, internal_format, pt, FALSE);
 224    }
 225 }
 226
 227 static void
 228 dri_set_tex_buffer(__DRIcontext *pDRICtx, GLint target,
 229                    __DRIdrawable *dPriv)
 230 {
 231    dri_set_tex_buffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv);
 232 }
 233
 234 const __DRItexBufferExtension driTexBufferExtension = {
 235     { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION },
 236    dri_set_tex_buffer,
 237    dri_set_tex_buffer2,
 238    NULL,
 239 };
 240
 241 /**
 242  * Get the format and binding of an attachment.
 243  */
 244 void
 245 dri_drawable_get_format(struct dri_drawable *drawable,
 246                         enum st_attachment_type statt,
 247                         enum pipe_format *format,
 248                         unsigned *bind)
 249 {
 250    switch (statt) {
 251    case ST_ATTACHMENT_FRONT_LEFT:
 252    case ST_ATTACHMENT_BACK_LEFT:
 253    case ST_ATTACHMENT_FRONT_RIGHT:
 254    case ST_ATTACHMENT_BACK_RIGHT:
 255       *format = drawable->stvis.color_format;
 256       *bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
 257       break;
 258    case ST_ATTACHMENT_DEPTH_STENCIL:
 259       *format = drawable->stvis.depth_stencil_format;
 260       *bind = PIPE_BIND_DEPTH_STENCIL; /* XXX sampler? */
 261       break;
 262    default:
 263       *format = PIPE_FORMAT_NONE;
 264       *bind = 0;
 265       break;
 266    }
 267 }
 268
 269 /* vim: set sw=3 ts=8 sts=3 expandtab: */