src/gallium/winsys/sw/wrapper/wrapper_sw_winsys.c

   1 /**********************************************************
   2  * Copyright 2010 VMware, Inc.  All rights reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person
   5  * obtaining a copy of this software and associated documentation
   6  * files (the "Software"), to deal in the Software without
   7  * restriction, including without limitation the rights to use, copy,
   8  * modify, merge, publish, distribute, sublicense, and/or sell copies
   9  * of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  **********************************************************/
  25
  26
  27 #include "wrapper_sw_winsys.h"
  28
  29 #include "pipe/p_format.h"
  30 #include "pipe/p_state.h"
  31
  32 #include "state_tracker/sw_winsys.h"
  33
  34 #include "util/u_memory.h"
  35 #include "util/u_inlines.h"
  36
  37 /*
  38  * This code wraps a pipe_screen and exposes a sw_winsys interface for use
  39  * with software resterizers. This code is used by the DRM based winsys to
  40  * allow access to the drm driver.
  41  *
  42  * We must borrow the whole stack because only the pipe screen knows how
  43  * to decode the content of a buffer. Or how to create a buffer that
  44  * can still be used by drivers using real hardware (as the case is
  45  * with software st/xorg but hw st/dri).
  46  *
  47  * We also need a pipe context for the transfers.
  48  */
  49
  50 struct wrapper_sw_winsys
  51 {
  52    struct sw_winsys base;
  53    struct pipe_screen *screen;
  54    struct pipe_context *pipe;
  55    enum pipe_texture_target target;
  56 };
  57
  58 struct wrapper_sw_displaytarget
  59 {
  60    struct wrapper_sw_winsys *winsys;
  61    struct pipe_resource *tex;
  62    struct pipe_transfer *transfer;
  63
  64    unsigned map_count;
  65    unsigned stride; /**< because we get stride at create */
  66    void *ptr;
  67 };
  68
  69 static INLINE struct wrapper_sw_winsys *
  70 wrapper_sw_winsys(struct sw_winsys *ws)
  71 {
  72    return (struct wrapper_sw_winsys *)ws;
  73 }
  74
  75 static INLINE struct wrapper_sw_displaytarget *
  76 wrapper_sw_displaytarget(struct sw_displaytarget *dt)
  77 {
  78    return (struct wrapper_sw_displaytarget *)dt;
  79 }
  80
  81
  82 /*
  83  * Functions
  84  */
  85
  86
  87 static boolean
  88 wsw_dt_get_stride(struct wrapper_sw_displaytarget *wdt, unsigned *stride)
  89 {
  90    struct pipe_context *pipe = wdt->winsys->pipe;
  91    struct pipe_resource *tex = wdt->tex;
  92    struct pipe_transfer *tr;
  93
  94    tr = pipe_get_transfer(pipe, tex, 0, 0,
  95                           PIPE_TRANSFER_READ_WRITE,
  96                           0, 0, wdt->tex->width0, wdt->tex->height0);
  97    if (!tr)
  98       return FALSE;
  99
 100    *stride = tr->stride;
 101    wdt->stride = tr->stride;
 102
 103    pipe->transfer_destroy(pipe, tr);
 104
 105    return TRUE;
 106 }
 107
 108 static struct sw_displaytarget *
 109 wsw_dt_wrap_texture(struct wrapper_sw_winsys *wsw,
 110                     struct pipe_resource *tex, unsigned *stride)
 111 {
 112    struct wrapper_sw_displaytarget *wdt = CALLOC_STRUCT(wrapper_sw_displaytarget);
 113    if (!wdt)
 114       goto err_unref;
 115
 116    wdt->tex = tex;
 117    wdt->winsys = wsw;
 118
 119    if (!wsw_dt_get_stride(wdt, stride))
 120       goto err_free;
 121
 122    return (struct sw_displaytarget *)wdt;
 123
 124 err_free:
 125    FREE(wdt);
 126 err_unref:
 127    pipe_resource_reference(&tex, NULL);
 128    return NULL;
 129 }
 130
 131 static struct sw_displaytarget *
 132 wsw_dt_create(struct sw_winsys *ws,
 133               unsigned bind,
 134               enum pipe_format format,
 135               unsigned width, unsigned height,
 136               unsigned alignment,
 137               unsigned *stride)
 138 {
 139    struct wrapper_sw_winsys *wsw = wrapper_sw_winsys(ws);
 140    struct pipe_resource templ;
 141    struct pipe_resource *tex;
 142
 143    /*
 144     * XXX Why don't we just get the template.
 145     */
 146    memset(&templ, 0, sizeof(templ));
 147    templ.target = wsw->target;
 148    templ.width0 = width;
 149    templ.height0 = height;
 150    templ.depth0 = 1;
 151    templ.array_size = 1;
 152    templ.format = format;
 153    templ.bind = bind;
 154
 155    /* XXX alignment: we can't do anything about this */
 156
 157    tex = wsw->screen->resource_create(wsw->screen, &templ);
 158    if (!tex)
 159       return NULL;
 160
 161    return wsw_dt_wrap_texture(wsw, tex, stride);
 162 }
 163
 164 static struct sw_displaytarget *
 165 wsw_dt_from_handle(struct sw_winsys *ws,
 166                    const struct pipe_resource *templ,
 167                    struct winsys_handle *whandle,
 168                    unsigned *stride)
 169 {
 170    struct wrapper_sw_winsys *wsw = wrapper_sw_winsys(ws);
 171    struct pipe_resource *tex;
 172
 173    tex = wsw->screen->resource_from_handle(wsw->screen, templ, whandle);
 174    if (!tex)
 175       return NULL;
 176
 177    return wsw_dt_wrap_texture(wsw, tex, stride);
 178 }
 179
 180 static boolean
 181 wsw_dt_get_handle(struct sw_winsys *ws,
 182                   struct sw_displaytarget *dt,
 183                   struct winsys_handle *whandle)
 184 {
 185    struct wrapper_sw_winsys *wsw = wrapper_sw_winsys(ws);
 186    struct wrapper_sw_displaytarget *wdt = wrapper_sw_displaytarget(dt);
 187    struct pipe_resource *tex = wdt->tex;
 188
 189    return wsw->screen->resource_get_handle(wsw->screen, tex, whandle);
 190 }
 191
 192 static void *
 193 wsw_dt_map(struct sw_winsys *ws,
 194            struct sw_displaytarget *dt,
 195            unsigned flags)
 196 {
 197    struct wrapper_sw_displaytarget *wdt = wrapper_sw_displaytarget(dt);
 198    struct pipe_context *pipe = wdt->winsys->pipe;
 199    struct pipe_resource *tex = wdt->tex;
 200    struct pipe_transfer *tr;
 201    void *ptr;
 202
 203    if (!wdt->map_count) {
 204
 205       assert(!wdt->transfer);
 206
 207       tr = pipe_get_transfer(pipe, tex, 0, 0,
 208                              PIPE_TRANSFER_READ_WRITE,
 209                              0, 0, wdt->tex->width0, wdt->tex->height0);
 210       if (!tr)
 211          return NULL;
 212
 213       ptr = pipe->transfer_map(pipe, tr);
 214       if (!ptr)
 215         goto err;
 216
 217       wdt->transfer = tr;
 218       wdt->ptr = ptr;
 219
 220       /* XXX Handle this case */
 221       assert(tr->stride == wdt->stride);
 222    }
 223
 224    wdt->map_count++;
 225
 226    return wdt->ptr;
 227
 228 err:
 229    pipe->transfer_destroy(pipe, tr);
 230    return NULL;
 231 }
 232
 233 static void
 234 wsw_dt_unmap(struct sw_winsys *ws,
 235              struct sw_displaytarget *dt)
 236 {
 237    struct wrapper_sw_displaytarget *wdt = wrapper_sw_displaytarget(dt);
 238    struct pipe_context *pipe = wdt->winsys->pipe;
 239
 240    assert(wdt->transfer);
 241
 242    wdt->map_count--;
 243
 244    if (wdt->map_count)
 245       return;
 246
 247    pipe->transfer_unmap(pipe, wdt->transfer);
 248    pipe->transfer_destroy(pipe, wdt->transfer);
 249    pipe->flush(pipe, NULL);
 250    wdt->transfer = NULL;
 251 }
 252
 253 static void
 254 wsw_dt_destroy(struct sw_winsys *ws,
 255                struct sw_displaytarget *dt)
 256 {
 257    struct wrapper_sw_displaytarget *wdt = wrapper_sw_displaytarget(dt);
 258
 259    pipe_resource_reference(&wdt->tex, NULL);
 260
 261    FREE(wdt);
 262 }
 263
 264 static void
 265 wsw_destroy(struct sw_winsys *ws)
 266 {
 267    struct wrapper_sw_winsys *wsw = wrapper_sw_winsys(ws);
 268
 269    wsw->pipe->destroy(wsw->pipe);
 270    wsw->screen->destroy(wsw->screen);
 271
 272    FREE(wsw);
 273 }
 274
 275 struct sw_winsys *
 276 wrapper_sw_winsys_wrap_pipe_screen(struct pipe_screen *screen)
 277 {
 278    struct wrapper_sw_winsys *wsw = CALLOC_STRUCT(wrapper_sw_winsys);
 279
 280    if (!wsw)
 281       goto err;
 282
 283    wsw->base.displaytarget_create = wsw_dt_create;
 284    wsw->base.displaytarget_from_handle = wsw_dt_from_handle;
 285    wsw->base.displaytarget_get_handle = wsw_dt_get_handle;
 286    wsw->base.displaytarget_map = wsw_dt_map;
 287    wsw->base.displaytarget_unmap = wsw_dt_unmap;
 288    wsw->base.displaytarget_destroy = wsw_dt_destroy;
 289    wsw->base.destroy = wsw_destroy;
 290
 291    wsw->screen = screen;
 292    wsw->pipe = screen->context_create(screen, NULL);
 293    if (!wsw->pipe)
 294       goto err_free;
 295
 296    if(screen->get_param(screen, PIPE_CAP_NPOT_TEXTURES))
 297       wsw->target = PIPE_TEXTURE_2D;
 298    else
 299       wsw->target = PIPE_TEXTURE_RECT;
 300
 301    return &wsw->base;
 302
 303 err_free:
 304    FREE(wsw);
 305 err:
 306    return NULL;
 307 }
 308
 309 struct pipe_screen *
 310 wrapper_sw_winsys_dewrap_pipe_screen(struct sw_winsys *ws)
 311 {
 312    struct wrapper_sw_winsys *wsw = wrapper_sw_winsys(ws);
 313    struct pipe_screen *screen = wsw->screen;
 314
 315    wsw->pipe->destroy(wsw->pipe);
 316    /* don't destroy the screen its needed later on */
 317
 318    FREE(wsw);
 319    return screen;
 320 }