src/gallium/state_trackers/glx/xlib/xm_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
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  21  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *    Chia-I Wu <olv@lunarg.com>
  26  */
  27
  28 #include "util/u_memory.h"
  29 #include "util/u_inlines.h"
  30
  31 #include "xm_api.h"
  32 #include "xm_st.h"
  33
  34 struct xmesa_st_framebuffer {
  35    XMesaDisplay display;
  36    XMesaBuffer buffer;
  37    struct pipe_screen *screen;
  38
  39    struct st_visual stvis;
  40
  41    unsigned texture_width, texture_height, texture_mask;
  42    struct pipe_texture *textures[ST_ATTACHMENT_COUNT];
  43
  44    struct pipe_surface *display_surface;
  45 };
  46
  47 static INLINE struct xmesa_st_framebuffer *
  48 xmesa_st_framebuffer(struct st_framebuffer_iface *stfbi)
  49 {
  50    return (struct xmesa_st_framebuffer *) stfbi->st_manager_private;
  51 }
  52
  53 /**
  54  * Display an attachment to the xlib_drawable of the framebuffer.
  55  */
  56 static boolean
  57 xmesa_st_framebuffer_display(struct st_framebuffer_iface *stfbi,
  58                              enum st_attachment_type statt)
  59 {
  60    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  61    struct pipe_texture *ptex = xstfb->textures[statt];
  62    struct pipe_surface *psurf;
  63
  64    if (!ptex)
  65       return TRUE;
  66
  67    psurf = xstfb->display_surface;
  68    /* (re)allocate the surface for the texture to be displayed */
  69    if (!psurf || psurf->texture != ptex) {
  70       pipe_surface_reference(&xstfb->display_surface, NULL);
  71
  72       psurf = xstfb->screen->get_tex_surface(xstfb->screen,
  73             ptex, 0, 0, 0, PIPE_BUFFER_USAGE_CPU_READ);
  74       if (!psurf)
  75          return FALSE;
  76
  77       xstfb->display_surface = psurf;
  78    }
  79
  80    xstfb->screen->flush_frontbuffer(xstfb->screen, psurf, &xstfb->buffer->ws);
  81
  82    return TRUE;
  83 }
  84
  85 /**
  86  * Copy the contents between the attachments.
  87  */
  88 static void
  89 xmesa_st_framebuffer_copy_textures(struct st_framebuffer_iface *stfbi,
  90                                    enum st_attachment_type src_statt,
  91                                    enum st_attachment_type dst_statt,
  92                                    unsigned x, unsigned y,
  93                                    unsigned width, unsigned height)
  94 {
  95    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
  96    struct pipe_texture *src_ptex = xstfb->textures[src_statt];
  97    struct pipe_texture *dst_ptex = xstfb->textures[dst_statt];
  98    struct pipe_surface *src, *dst;
  99    struct pipe_context *pipe;
 100
 101    if (!src_ptex || !dst_ptex)
 102       return;
 103
 104    pipe = xstfb->display->pipe;
 105    if (!pipe) {
 106       pipe = xstfb->screen->context_create(xstfb->screen, NULL);
 107       if (!pipe)
 108          return;
 109       xstfb->display->pipe = pipe;
 110    }
 111
 112    src = xstfb->screen->get_tex_surface(xstfb->screen,
 113          src_ptex, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_READ);
 114    dst = xstfb->screen->get_tex_surface(xstfb->screen,
 115          dst_ptex, 0, 0, 0, PIPE_BUFFER_USAGE_GPU_WRITE);
 116
 117    if (src && dst)
 118       pipe->surface_copy(pipe, dst, 0, 0, src, 0, 0, src->width, src->height);
 119
 120    pipe_surface_reference(&src, NULL);
 121    pipe_surface_reference(&dst, NULL);
 122 }
 123
 124 /**
 125  * Remove outdated textures and create the requested ones.
 126  */
 127 static void
 128 xmesa_st_framebuffer_validate_textures(struct st_framebuffer_iface *stfbi,
 129                                        unsigned width, unsigned height,
 130                                        unsigned mask)
 131 {
 132    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
 133    struct pipe_texture templ;
 134    unsigned i;
 135
 136    /* remove outdated textures */
 137    if (xstfb->texture_width != width || xstfb->texture_height != height) {
 138       for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
 139          pipe_texture_reference(&xstfb->textures[i], NULL);
 140    }
 141
 142    memset(&templ, 0, sizeof(templ));
 143    templ.target = PIPE_TEXTURE_2D;
 144    templ.width0 = width;
 145    templ.height0 = height;
 146    templ.depth0 = 1;
 147    templ.last_level = 0;
 148
 149    for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
 150       enum pipe_format format;
 151       unsigned tex_usage;
 152
 153       /* the texture already exists or not requested */
 154       if (xstfb->textures[i] || !(mask & (1 << i))) {
 155          /* remember the texture */
 156          if (xstfb->textures[i])
 157             mask |= (1 << i);
 158          continue;
 159       }
 160
 161       switch (i) {
 162       case ST_ATTACHMENT_FRONT_LEFT:
 163       case ST_ATTACHMENT_BACK_LEFT:
 164       case ST_ATTACHMENT_FRONT_RIGHT:
 165       case ST_ATTACHMENT_BACK_RIGHT:
 166          format = xstfb->stvis.color_format;
 167          tex_usage = PIPE_TEXTURE_USAGE_DISPLAY_TARGET |
 168                      PIPE_TEXTURE_USAGE_RENDER_TARGET;
 169          break;
 170       case ST_ATTACHMENT_DEPTH_STENCIL:
 171          format = xstfb->stvis.depth_stencil_format;
 172          tex_usage = PIPE_TEXTURE_USAGE_DEPTH_STENCIL;
 173          break;
 174       default:
 175          format = PIPE_FORMAT_NONE;
 176          break;
 177       }
 178
 179       if (format != PIPE_FORMAT_NONE) {
 180          templ.format = format;
 181          templ.tex_usage = tex_usage;
 182
 183          xstfb->textures[i] =
 184             xstfb->screen->texture_create(xstfb->screen, &templ);
 185       }
 186    }
 187
 188    xstfb->texture_width = width;
 189    xstfb->texture_height = height;
 190    xstfb->texture_mask = mask;
 191 }
 192
 193 static boolean
 194 xmesa_st_framebuffer_validate(struct st_framebuffer_iface *stfbi,
 195                               const enum st_attachment_type *statts,
 196                               unsigned count,
 197                               struct pipe_texture **out)
 198 {
 199    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
 200    unsigned statt_mask, i;
 201
 202    statt_mask = 0x0;
 203    for (i = 0; i < count; i++)
 204       statt_mask |= 1 << statts[i];
 205
 206    /* revalidate textures */
 207    if (xstfb->buffer->width != xstfb->texture_width ||
 208        xstfb->buffer->height != xstfb->texture_height ||
 209        (xstfb->texture_mask & statt_mask) != statt_mask) {
 210       xmesa_st_framebuffer_validate_textures(stfbi,
 211             xstfb->buffer->width, xstfb->buffer->height, statt_mask);
 212    }
 213
 214    for (i = 0; i < count; i++) {
 215       out[i] = NULL;
 216       pipe_texture_reference(&out[i], xstfb->textures[statts[i]]);
 217    }
 218
 219    return TRUE;
 220 }
 221
 222 static boolean
 223 xmesa_st_framebuffer_flush_front(struct st_framebuffer_iface *stfbi,
 224                                  enum st_attachment_type statt)
 225 {
 226    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
 227    boolean ret;
 228
 229    ret = xmesa_st_framebuffer_display(stfbi, statt);
 230    if (ret)
 231       xmesa_check_buffer_size(xstfb->buffer);
 232
 233    return ret;
 234 }
 235
 236 struct st_framebuffer_iface *
 237 xmesa_create_st_framebuffer(XMesaDisplay xmdpy, XMesaBuffer b)
 238 {
 239    struct st_framebuffer_iface *stfbi;
 240    struct xmesa_st_framebuffer *xstfb;
 241
 242    assert(xmdpy->display == b->xm_visual->display);
 243
 244    stfbi = CALLOC_STRUCT(st_framebuffer_iface);
 245    xstfb = CALLOC_STRUCT(xmesa_st_framebuffer);
 246    if (!stfbi || !xstfb) {
 247       if (stfbi)
 248          FREE(stfbi);
 249       if (xstfb)
 250          FREE(xstfb);
 251       return NULL;
 252    }
 253
 254    xstfb->display = xmdpy;
 255    xstfb->buffer = b;
 256    xstfb->screen = xmdpy->screen;
 257    xstfb->stvis = b->xm_visual->stvis;
 258
 259    stfbi->visual = &xstfb->stvis;
 260    stfbi->flush_front = xmesa_st_framebuffer_flush_front;
 261    stfbi->validate = xmesa_st_framebuffer_validate;
 262    stfbi->st_manager_private = (void *) xstfb;
 263
 264    return stfbi;
 265 }
 266
 267 void
 268 xmesa_destroy_st_framebuffer(struct st_framebuffer_iface *stfbi)
 269 {
 270    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
 271    int i;
 272
 273    pipe_surface_reference(&xstfb->display_surface, NULL);
 274
 275    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
 276       pipe_texture_reference(&xstfb->textures[i], NULL);
 277
 278    FREE(xstfb);
 279    FREE(stfbi);
 280 }
 281
 282 void
 283 xmesa_swap_st_framebuffer(struct st_framebuffer_iface *stfbi)
 284 {
 285    struct xmesa_st_framebuffer *xstfb = xmesa_st_framebuffer(stfbi);
 286    boolean ret;
 287
 288    ret = xmesa_st_framebuffer_display(stfbi, ST_ATTACHMENT_BACK_LEFT);
 289    if (ret) {
 290       struct pipe_texture **front, **back, *tmp;
 291
 292       front = &xstfb->textures[ST_ATTACHMENT_FRONT_LEFT];
 293       back = &xstfb->textures[ST_ATTACHMENT_BACK_LEFT];
 294       /* swap textures only if the front texture has been allocated */
 295       if (*front) {
 296          tmp = *front;
 297          *front = *back;
 298          *back = tmp;
 299       }
 300
 301       xmesa_check_buffer_size(xstfb->buffer);
 302    }
 303 }
 304
 305 void
 306 xmesa_copy_st_framebuffer(struct st_framebuffer_iface *stfbi,
 307                           enum st_attachment_type src,
 308                           enum st_attachment_type dst,
 309                           int x, int y, int w, int h)
 310 {
 311    xmesa_st_framebuffer_copy_textures(stfbi, src, dst, x, y, w, h);
 312    if (dst == ST_ATTACHMENT_FRONT_LEFT)
 313       xmesa_st_framebuffer_display(stfbi, dst);
 314 }