src/gallium/state_trackers/egl/gdi/native_gdi.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 OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  *
  25  * Authors:
  26  *    Chia-I Wu <olv@lunarg.com>
  27  */
  28
  29 #include <windows.h>
  30
  31 #include "pipe/p_compiler.h"
  32 #include "util/u_memory.h"
  33 #include "util/u_format.h"
  34 #include "util/u_inlines.h"
  35 #include "gdi/gdi_sw_winsys.h"
  36
  37 #include "common/native_helper.h"
  38 #include "common/native.h"
  39
  40 struct gdi_display {
  41    struct native_display base;
  42
  43    HDC hDC;
  44    const struct native_event_handler *event_handler;
  45
  46    struct native_config *configs;
  47    int num_configs;
  48 };
  49
  50 struct gdi_surface {
  51    struct native_surface base;
  52
  53    HWND hWnd;
  54    enum pipe_format color_format;
  55
  56    struct gdi_display *gdpy;
  57
  58    unsigned int server_stamp;
  59    unsigned int client_stamp;
  60
  61    struct resource_surface *rsurf;
  62 };
  63
  64 static INLINE struct gdi_display *
  65 gdi_display(const struct native_display *ndpy)
  66 {
  67    return (struct gdi_display *) ndpy;
  68 }
  69
  70 static INLINE struct gdi_surface *
  71 gdi_surface(const struct native_surface *nsurf)
  72 {
  73    return (struct gdi_surface *) nsurf;
  74 }
  75
  76 /**
  77  * Update the geometry of the surface.  This is a slow functions.
  78  */
  79 static void
  80 gdi_surface_update_geometry(struct native_surface *nsurf)
  81 {
  82    struct gdi_surface *gsurf = gdi_surface(nsurf);
  83    RECT rect;
  84    uint w, h;
  85
  86    GetClientRect(gsurf->hWnd, &rect);
  87    w = rect.right - rect.left;
  88    h = rect.bottom - rect.top;
  89
  90    if (resource_surface_set_size(gsurf->rsurf, w, h))
  91       gsurf->server_stamp++;
  92 }
  93
  94 /**
  95  * Update the buffers of the surface.
  96  */
  97 static boolean
  98 gdi_surface_update_buffers(struct native_surface *nsurf, uint buffer_mask)
  99 {
 100    struct gdi_surface *gsurf = gdi_surface(nsurf);
 101
 102    if (gsurf->client_stamp != gsurf->server_stamp) {
 103       gdi_surface_update_geometry(&gsurf->base);
 104       gsurf->client_stamp = gsurf->server_stamp;
 105    }
 106
 107    return resource_surface_add_resources(gsurf->rsurf, buffer_mask);
 108 }
 109
 110 /**
 111  * Emulate an invalidate event.
 112  */
 113 static void
 114 gdi_surface_invalidate(struct native_surface *nsurf)
 115 {
 116    struct gdi_surface *gsurf = gdi_surface(nsurf);
 117    struct gdi_display *gdpy = gsurf->gdpy;
 118
 119    gsurf->server_stamp++;
 120    gdpy->event_handler->invalid_surface(&gdpy->base,
 121          &gsurf->base, gsurf->server_stamp);
 122 }
 123
 124 static boolean
 125 gdi_surface_flush_frontbuffer(struct native_surface *nsurf)
 126 {
 127    struct gdi_surface *gsurf = gdi_surface(nsurf);
 128    HDC hDC;
 129    boolean ret;
 130
 131    hDC = GetDC(gsurf->hWnd);
 132    ret = resource_surface_present(gsurf->rsurf,
 133          NATIVE_ATTACHMENT_FRONT_LEFT, (void *) hDC);
 134    ReleaseDC(gsurf->hWnd, hDC);
 135
 136    /* force buffers to be updated in next validation call */
 137    gdi_surface_invalidate(&gsurf->base);
 138
 139    return ret;
 140 }
 141
 142 static boolean
 143 gdi_surface_swap_buffers(struct native_surface *nsurf)
 144 {
 145    struct gdi_surface *gsurf = gdi_surface(nsurf);
 146    HDC hDC;
 147    boolean ret;
 148
 149    hDC = GetDC(gsurf->hWnd);
 150    ret = resource_surface_present(gsurf->rsurf,
 151          NATIVE_ATTACHMENT_BACK_LEFT, (void *) hDC);
 152    ReleaseDC(gsurf->hWnd, hDC);
 153
 154    resource_surface_swap_buffers(gsurf->rsurf,
 155          NATIVE_ATTACHMENT_FRONT_LEFT, NATIVE_ATTACHMENT_BACK_LEFT, TRUE);
 156    /* the front/back buffers have been swapped */
 157    gdi_surface_invalidate(&gsurf->base);
 158
 159    return ret;
 160 }
 161
 162 static boolean
 163 gdi_surface_present(struct native_surface *nsurf,
 164                     enum native_attachment natt,
 165                     boolean preserve,
 166                     uint swap_interval)
 167 {
 168    boolean ret;
 169
 170    if (preserve || swap_interval)
 171       return FALSE;
 172
 173    switch (natt) {
 174    case NATIVE_ATTACHMENT_FRONT_LEFT:
 175       ret = gdi_surface_flush_frontbuffer(nsurf);
 176       break;
 177    case NATIVE_ATTACHMENT_BACK_LEFT:
 178       ret = gdi_surface_swap_buffers(nsurf);
 179       break;
 180    default:
 181       ret = FALSE;
 182       break;
 183    }
 184
 185    return ret;
 186 }
 187
 188 static boolean
 189 gdi_surface_validate(struct native_surface *nsurf, uint attachment_mask,
 190                         unsigned int *seq_num, struct pipe_resource **textures,
 191                         int *width, int *height)
 192 {
 193    struct gdi_surface *gsurf = gdi_surface(nsurf);
 194    uint w, h;
 195
 196    if (!gdi_surface_update_buffers(&gsurf->base, attachment_mask))
 197       return FALSE;
 198
 199    if (seq_num)
 200       *seq_num = gsurf->client_stamp;
 201
 202    if (textures)
 203       resource_surface_get_resources(gsurf->rsurf, textures, attachment_mask);
 204
 205    resource_surface_get_size(gsurf->rsurf, &w, &h);
 206    if (width)
 207       *width = w;
 208    if (height)
 209       *height = h;
 210
 211    return TRUE;
 212 }
 213
 214 static void
 215 gdi_surface_wait(struct native_surface *nsurf)
 216 {
 217    /* no-op */
 218 }
 219
 220 static void
 221 gdi_surface_destroy(struct native_surface *nsurf)
 222 {
 223    struct gdi_surface *gsurf = gdi_surface(nsurf);
 224
 225    resource_surface_destroy(gsurf->rsurf);
 226    FREE(gsurf);
 227 }
 228
 229 static struct native_surface *
 230 gdi_display_create_window_surface(struct native_display *ndpy,
 231                                   EGLNativeWindowType win,
 232                                   const struct native_config *nconf)
 233 {
 234    struct gdi_display *gdpy = gdi_display(ndpy);
 235    struct gdi_surface *gsurf;
 236
 237    gsurf = CALLOC_STRUCT(gdi_surface);
 238    if (!gsurf)
 239       return NULL;
 240
 241    gsurf->gdpy = gdpy;
 242    gsurf->color_format = nconf->color_format;
 243    gsurf->hWnd = (HWND) win;
 244
 245    gsurf->rsurf = resource_surface_create(gdpy->base.screen,
 246          gsurf->color_format,
 247          PIPE_BIND_RENDER_TARGET |
 248          PIPE_BIND_SAMPLER_VIEW |
 249          PIPE_BIND_DISPLAY_TARGET |
 250          PIPE_BIND_SCANOUT);
 251    if (!gsurf->rsurf) {
 252       FREE(gsurf);
 253       return NULL;
 254    }
 255
 256    /* initialize the geometry */
 257    gdi_surface_update_geometry(&gsurf->base);
 258
 259    gsurf->base.destroy = gdi_surface_destroy;
 260    gsurf->base.present = gdi_surface_present;
 261    gsurf->base.validate = gdi_surface_validate;
 262    gsurf->base.wait = gdi_surface_wait;
 263
 264    return &gsurf->base;
 265 }
 266
 267 static int
 268 fill_color_formats(struct native_display *ndpy, enum pipe_format formats[8])
 269 {
 270    struct pipe_screen *screen = ndpy->screen;
 271    int i, count = 0;
 272
 273    enum pipe_format candidates[] = {
 274       /* 32-bit */
 275       PIPE_FORMAT_B8G8R8A8_UNORM,
 276       PIPE_FORMAT_A8R8G8B8_UNORM,
 277       /* 24-bit */
 278       PIPE_FORMAT_B8G8R8X8_UNORM,
 279       PIPE_FORMAT_X8R8G8B8_UNORM,
 280       /* 16-bit */
 281       PIPE_FORMAT_B5G6R5_UNORM
 282    };
 283
 284    assert(Elements(candidates) <= 8);
 285
 286    for (i = 0; i < Elements(candidates); i++) {
 287       if (screen->is_format_supported(screen, candidates[i],
 288                PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET))
 289          formats[count++] = candidates[i];
 290    }
 291
 292    return count;
 293 }
 294
 295 static const struct native_config **
 296 gdi_display_get_configs(struct native_display *ndpy, int *num_configs)
 297 {
 298    struct gdi_display *gdpy = gdi_display(ndpy);
 299    const struct native_config **configs;
 300    int i;
 301
 302    /* first time */
 303    if (!gdpy->configs) {
 304       enum pipe_format formats[8];
 305       int i, count;
 306
 307       count = fill_color_formats(&gdpy->base, formats);
 308
 309       gdpy->configs = CALLOC(count, sizeof(*gdpy->configs));
 310       if (!gdpy->configs)
 311          return NULL;
 312
 313       for (i = 0; i < count; i++) {
 314          struct native_config *nconf = &gdpy->configs[i];
 315
 316          nconf->buffer_mask =
 317             (1 << NATIVE_ATTACHMENT_FRONT_LEFT) |
 318             (1 << NATIVE_ATTACHMENT_BACK_LEFT);
 319          nconf->color_format = formats[i];
 320
 321          nconf->window_bit = TRUE;
 322       }
 323
 324       gdpy->num_configs = count;
 325    }
 326
 327    configs = MALLOC(gdpy->num_configs * sizeof(*configs));
 328    if (configs) {
 329       for (i = 0; i < gdpy->num_configs; i++)
 330          configs[i] = (const struct native_config *) &gdpy->configs[i];
 331       if (num_configs)
 332          *num_configs = gdpy->num_configs;
 333    }
 334    return configs;
 335 }
 336
 337 static int
 338 gdi_display_get_param(struct native_display *ndpy,
 339                          enum native_param_type param)
 340 {
 341    int val;
 342
 343    switch (param) {
 344    case NATIVE_PARAM_USE_NATIVE_BUFFER:
 345       /* private buffers are allocated */
 346       val = FALSE;
 347       break;
 348    case NATIVE_PARAM_PRESERVE_BUFFER:
 349    case NATIVE_PARAM_MAX_SWAP_INTERVAL:
 350    default:
 351       val = 0;
 352       break;
 353    }
 354
 355    return val;
 356 }
 357
 358 static void
 359 gdi_display_destroy(struct native_display *ndpy)
 360 {
 361    struct gdi_display *gdpy = gdi_display(ndpy);
 362
 363    if (gdpy->configs)
 364       FREE(gdpy->configs);
 365
 366    ndpy_uninit(ndpy);
 367
 368    FREE(gdpy);
 369 }
 370
 371 static boolean
 372 gdi_display_init_screen(struct native_display *ndpy)
 373 {
 374    struct gdi_display *gdpy = gdi_display(ndpy);
 375    struct sw_winsys *winsys;
 376
 377    winsys = gdi_create_sw_winsys();
 378    if (!winsys)
 379       return FALSE;
 380
 381    gdpy->base.screen = gdpy->event_handler->new_sw_screen(&gdpy->base, winsys);
 382    if (!gdpy->base.screen) {
 383       if (winsys->destroy)
 384          winsys->destroy(winsys);
 385       return FALSE;
 386    }
 387
 388    return TRUE;
 389 }
 390
 391 static struct native_display *
 392 gdi_create_display(HDC hDC, const struct native_event_handler *event_handler)
 393 {
 394    struct gdi_display *gdpy;
 395
 396    gdpy = CALLOC_STRUCT(gdi_display);
 397    if (!gdpy)
 398       return NULL;
 399
 400    gdpy->hDC = hDC;
 401    gdpy->event_handler = event_handler;
 402
 403    gdpy->base.init_screen = gdi_display_init_screen;
 404    gdpy->base.destroy = gdi_display_destroy;
 405    gdpy->base.get_param = gdi_display_get_param;
 406
 407    gdpy->base.get_configs = gdi_display_get_configs;
 408    gdpy->base.create_window_surface = gdi_display_create_window_surface;
 409
 410    return &gdpy->base;
 411 }
 412
 413 static const struct native_event_handler *gdi_event_handler;
 414
 415 static struct native_display *
 416 native_create_display(void *dpy, boolean use_sw)
 417 {
 418    return gdi_create_display((HDC) dpy, gdi_event_handler);
 419 }
 420
 421 static const struct native_platform gdi_platform = {
 422    "GDI", /* name */
 423    native_create_display
 424 };
 425
 426 const struct native_platform *
 427 native_get_gdi_platform(const struct native_event_handler *event_handler)
 428 {
 429    gdi_event_handler = event_handler;
 430    return &gdi_platform;
 431 }