src/gallium/drivers/identity/id_screen.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
  29 #include "pipe/p_screen.h"
  30 #include "pipe/p_state.h"
  31 #include "util/u_memory.h"
  32
  33 #include "id_public.h"
  34 #include "id_screen.h"
  35 #include "id_context.h"
  36 #include "id_objects.h"
  37
  38
  39 static void
  40 identity_screen_destroy(struct pipe_screen *_screen)
  41 {
  42    struct identity_screen *id_screen = identity_screen(_screen);
  43    struct pipe_screen *screen = id_screen->screen;
  44
  45    screen->destroy(screen);
  46
  47    FREE(id_screen);
  48 }
  49
  50 static const char *
  51 identity_screen_get_name(struct pipe_screen *_screen)
  52 {
  53    struct identity_screen *id_screen = identity_screen(_screen);
  54    struct pipe_screen *screen = id_screen->screen;
  55
  56    return screen->get_name(screen);
  57 }
  58
  59 static const char *
  60 identity_screen_get_vendor(struct pipe_screen *_screen)
  61 {
  62    struct identity_screen *id_screen = identity_screen(_screen);
  63    struct pipe_screen *screen = id_screen->screen;
  64
  65    return screen->get_vendor(screen);
  66 }
  67
  68 static int
  69 identity_screen_get_param(struct pipe_screen *_screen,
  70                           int param)
  71 {
  72    struct identity_screen *id_screen = identity_screen(_screen);
  73    struct pipe_screen *screen = id_screen->screen;
  74
  75    return screen->get_param(screen,
  76                             param);
  77 }
  78
  79 static float
  80 identity_screen_get_paramf(struct pipe_screen *_screen,
  81                            int param)
  82 {
  83    struct identity_screen *id_screen = identity_screen(_screen);
  84    struct pipe_screen *screen = id_screen->screen;
  85
  86    return screen->get_paramf(screen,
  87                              param);
  88 }
  89
  90 static boolean
  91 identity_screen_is_format_supported(struct pipe_screen *_screen,
  92                                     enum pipe_format format,
  93                                     enum pipe_texture_target target,
  94                                     unsigned tex_usage,
  95                                     unsigned geom_flags)
  96 {
  97    struct identity_screen *id_screen = identity_screen(_screen);
  98    struct pipe_screen *screen = id_screen->screen;
  99
 100    return screen->is_format_supported(screen,
 101                                       format,
 102                                       target,
 103                                       tex_usage,
 104                                       geom_flags);
 105 }
 106
 107 static struct pipe_context *
 108 identity_screen_context_create(struct pipe_screen *_screen,
 109                                void *priv)
 110 {
 111    struct identity_screen *id_screen = identity_screen(_screen);
 112    struct pipe_screen *screen = id_screen->screen;
 113    struct pipe_context *result;
 114
 115    result = screen->context_create(screen, priv);
 116    if (result)
 117       return identity_context_create(_screen, result);
 118    return NULL;
 119 }
 120
 121 static struct pipe_texture *
 122 identity_screen_texture_create(struct pipe_screen *_screen,
 123                                const struct pipe_texture *templat)
 124 {
 125    struct identity_screen *id_screen = identity_screen(_screen);
 126    struct pipe_screen *screen = id_screen->screen;
 127    struct pipe_texture *result;
 128
 129    result = screen->texture_create(screen,
 130                                    templat);
 131
 132    if (result)
 133       return identity_texture_create(id_screen, result);
 134    return NULL;
 135 }
 136
 137 static struct pipe_texture *
 138 identity_screen_texture_blanket(struct pipe_screen *_screen,
 139                                 const struct pipe_texture *templat,
 140                                 const unsigned *stride,
 141                                 struct pipe_buffer *_buffer)
 142 {
 143    struct identity_screen *id_screen = identity_screen(_screen);
 144    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 145    struct pipe_screen *screen = id_screen->screen;
 146    struct pipe_buffer *buffer = id_buffer->buffer;
 147    struct pipe_texture *result;
 148
 149    result = screen->texture_blanket(screen,
 150                                     templat,
 151                                     stride,
 152                                     buffer);
 153
 154    if (result)
 155       return identity_texture_create(id_screen, result);
 156    return NULL;
 157 }
 158
 159 static void
 160 identity_screen_texture_destroy(struct pipe_texture *_texture)
 161 {
 162    identity_texture_destroy(identity_texture(_texture));
 163 }
 164
 165 static struct pipe_surface *
 166 identity_screen_get_tex_surface(struct pipe_screen *_screen,
 167                                 struct pipe_texture *_texture,
 168                                 unsigned face,
 169                                 unsigned level,
 170                                 unsigned zslice,
 171                                 unsigned usage)
 172 {
 173    struct identity_screen *id_screen = identity_screen(_screen);
 174    struct identity_texture *id_texture = identity_texture(_texture);
 175    struct pipe_screen *screen = id_screen->screen;
 176    struct pipe_texture *texture = id_texture->texture;
 177    struct pipe_surface *result;
 178
 179    result = screen->get_tex_surface(screen,
 180                                     texture,
 181                                     face,
 182                                     level,
 183                                     zslice,
 184                                     usage);
 185
 186    if (result)
 187       return identity_surface_create(id_texture, result);
 188    return NULL;
 189 }
 190
 191 static void
 192 identity_screen_tex_surface_destroy(struct pipe_surface *_surface)
 193 {
 194    identity_surface_destroy(identity_surface(_surface));
 195 }
 196
 197 static struct pipe_transfer *
 198 identity_screen_get_tex_transfer(struct pipe_screen *_screen,
 199                                  struct pipe_texture *_texture,
 200                                  unsigned face,
 201                                  unsigned level,
 202                                  unsigned zslice,
 203                                  enum pipe_transfer_usage usage,
 204                                  unsigned x,
 205                                  unsigned y,
 206                                  unsigned w,
 207                                  unsigned h)
 208 {
 209    struct identity_screen *id_screen = identity_screen(_screen);
 210    struct identity_texture *id_texture = identity_texture(_texture);
 211    struct pipe_screen *screen = id_screen->screen;
 212    struct pipe_texture *texture = id_texture->texture;
 213    struct pipe_transfer *result;
 214
 215    result = screen->get_tex_transfer(screen,
 216                                      texture,
 217                                      face,
 218                                      level,
 219                                      zslice,
 220                                      usage,
 221                                      x,
 222                                      y,
 223                                      w,
 224                                      h);
 225
 226    if (result)
 227       return identity_transfer_create(id_texture, result);
 228    return NULL;
 229 }
 230
 231 static void
 232 identity_screen_tex_transfer_destroy(struct pipe_transfer *_transfer)
 233 {
 234    identity_transfer_destroy(identity_transfer(_transfer));
 235 }
 236
 237 static void *
 238 identity_screen_transfer_map(struct pipe_screen *_screen,
 239                              struct pipe_transfer *_transfer)
 240 {
 241    struct identity_screen *id_screen = identity_screen(_screen);
 242    struct identity_transfer *id_transfer = identity_transfer(_transfer);
 243    struct pipe_screen *screen = id_screen->screen;
 244    struct pipe_transfer *transfer = id_transfer->transfer;
 245
 246    return screen->transfer_map(screen,
 247                                transfer);
 248 }
 249
 250 static void
 251 identity_screen_transfer_unmap(struct pipe_screen *_screen,
 252                                struct pipe_transfer *_transfer)
 253 {
 254    struct identity_screen *id_screen = identity_screen(_screen);
 255    struct identity_transfer *id_transfer = identity_transfer(_transfer);
 256    struct pipe_screen *screen = id_screen->screen;
 257    struct pipe_transfer *transfer = id_transfer->transfer;
 258
 259    screen->transfer_unmap(screen,
 260                           transfer);
 261 }
 262
 263 static struct pipe_buffer *
 264 identity_screen_buffer_create(struct pipe_screen *_screen,
 265                               unsigned alignment,
 266                               unsigned usage,
 267                               unsigned size)
 268 {
 269    struct identity_screen *id_screen = identity_screen(_screen);
 270    struct pipe_screen *screen = id_screen->screen;
 271    struct pipe_buffer *result;
 272
 273    result = screen->buffer_create(screen,
 274                                   alignment,
 275                                   usage,
 276                                   size);
 277
 278    if (result)
 279       return identity_buffer_create(id_screen, result);
 280    return NULL;
 281 }
 282
 283 static struct pipe_buffer *
 284 identity_screen_user_buffer_create(struct pipe_screen *_screen,
 285                                    void *ptr,
 286                                    unsigned bytes)
 287 {
 288    struct identity_screen *id_screen = identity_screen(_screen);
 289    struct pipe_screen *screen = id_screen->screen;
 290    struct pipe_buffer *result;
 291
 292    result = screen->user_buffer_create(screen,
 293                                        ptr,
 294                                        bytes);
 295
 296    if (result)
 297       return identity_buffer_create(id_screen, result);
 298    return NULL;
 299 }
 300
 301 static struct pipe_buffer *
 302 identity_screen_surface_buffer_create(struct pipe_screen *_screen,
 303                                       unsigned width,
 304                                       unsigned height,
 305                                       enum pipe_format format,
 306                                       unsigned usage,
 307                                       unsigned tex_usage,
 308                                       unsigned *stride)
 309 {
 310    struct identity_screen *id_screen = identity_screen(_screen);
 311    struct pipe_screen *screen = id_screen->screen;
 312    struct pipe_buffer *result;
 313
 314    result = screen->surface_buffer_create(screen,
 315                                           width,
 316                                           height,
 317                                           format,
 318                                           usage,
 319                                           tex_usage,
 320                                           stride);
 321
 322    if (result)
 323       return identity_buffer_create(id_screen, result);
 324    return NULL;
 325 }
 326
 327 static void *
 328 identity_screen_buffer_map(struct pipe_screen *_screen,
 329                            struct pipe_buffer *_buffer,
 330                            unsigned usage)
 331 {
 332    struct identity_screen *id_screen = identity_screen(_screen);
 333    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 334    struct pipe_screen *screen = id_screen->screen;
 335    struct pipe_buffer *buffer = id_buffer->buffer;
 336
 337    return screen->buffer_map(screen,
 338                              buffer,
 339                              usage);
 340 }
 341
 342 static void *
 343 identity_screen_buffer_map_range(struct pipe_screen *_screen,
 344                                  struct pipe_buffer *_buffer,
 345                                  unsigned offset,
 346                                  unsigned length,
 347                                  unsigned usage)
 348 {
 349    struct identity_screen *id_screen = identity_screen(_screen);
 350    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 351    struct pipe_screen *screen = id_screen->screen;
 352    struct pipe_buffer *buffer = id_buffer->buffer;
 353
 354    return screen->buffer_map_range(screen,
 355                                    buffer,
 356                                    offset,
 357                                    length,
 358                                    usage);
 359 }
 360
 361 static void
 362 identity_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
 363                                           struct pipe_buffer *_buffer,
 364                                           unsigned offset,
 365                                           unsigned length)
 366 {
 367    struct identity_screen *id_screen = identity_screen(_screen);
 368    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 369    struct pipe_screen *screen = id_screen->screen;
 370    struct pipe_buffer *buffer = id_buffer->buffer;
 371
 372    screen->buffer_flush_mapped_range(screen,
 373                                      buffer,
 374                                      offset,
 375                                      length);
 376 }
 377
 378 static void
 379 identity_screen_buffer_unmap(struct pipe_screen *_screen,
 380                              struct pipe_buffer *_buffer)
 381 {
 382    struct identity_screen *id_screen = identity_screen(_screen);
 383    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 384    struct pipe_screen *screen = id_screen->screen;
 385    struct pipe_buffer *buffer = id_buffer->buffer;
 386
 387    screen->buffer_unmap(screen,
 388                         buffer);
 389 }
 390
 391 static void
 392 identity_screen_buffer_destroy(struct pipe_buffer *_buffer)
 393 {
 394    identity_buffer_destroy(identity_buffer(_buffer));
 395 }
 396
 397 static struct pipe_video_surface *
 398 identity_screen_video_surface_create(struct pipe_screen *_screen,
 399                                      enum pipe_video_chroma_format chroma_format,
 400                                      unsigned width,
 401                                      unsigned height)
 402 {
 403    struct identity_screen *id_screen = identity_screen(_screen);
 404    struct pipe_screen *screen = id_screen->screen;
 405    struct pipe_video_surface *result;
 406
 407    result = screen->video_surface_create(screen,
 408                                          chroma_format,
 409                                          width,
 410                                          height);
 411
 412    if (result) {
 413       return identity_video_surface_create(id_screen, result);
 414    }
 415    return NULL;
 416 }
 417
 418 static void
 419 identity_screen_video_surface_destroy(struct pipe_video_surface *_vsfc)
 420 {
 421    identity_video_surface_destroy(identity_video_surface(_vsfc));
 422 }
 423
 424 static void
 425 identity_screen_flush_frontbuffer(struct pipe_screen *_screen,
 426                                   struct pipe_surface *_surface,
 427                                   void *context_private)
 428 {
 429    struct identity_screen *id_screen = identity_screen(_screen);
 430    struct identity_surface *id_surface = identity_surface(_surface);
 431    struct pipe_screen *screen = id_screen->screen;
 432    struct pipe_surface *surface = id_surface->surface;
 433
 434    screen->flush_frontbuffer(screen,
 435                              surface,
 436                              context_private);
 437 }
 438
 439 static void
 440 identity_screen_fence_reference(struct pipe_screen *_screen,
 441                                 struct pipe_fence_handle **ptr,
 442                                 struct pipe_fence_handle *fence)
 443 {
 444    struct identity_screen *id_screen = identity_screen(_screen);
 445    struct pipe_screen *screen = id_screen->screen;
 446
 447    screen->fence_reference(screen,
 448                            ptr,
 449                            fence);
 450 }
 451
 452 static int
 453 identity_screen_fence_signalled(struct pipe_screen *_screen,
 454                                 struct pipe_fence_handle *fence,
 455                                 unsigned flags)
 456 {
 457    struct identity_screen *id_screen = identity_screen(_screen);
 458    struct pipe_screen *screen = id_screen->screen;
 459
 460    return screen->fence_signalled(screen,
 461                                   fence,
 462                                   flags);
 463 }
 464
 465 static int
 466 identity_screen_fence_finish(struct pipe_screen *_screen,
 467                              struct pipe_fence_handle *fence,
 468                              unsigned flags)
 469 {
 470    struct identity_screen *id_screen = identity_screen(_screen);
 471    struct pipe_screen *screen = id_screen->screen;
 472
 473    return screen->fence_finish(screen,
 474                                fence,
 475                                flags);
 476 }
 477
 478 struct pipe_screen *
 479 identity_screen_create(struct pipe_screen *screen)
 480 {
 481    struct identity_screen *id_screen;
 482
 483    id_screen = CALLOC_STRUCT(identity_screen);
 484    if (!id_screen) {
 485       return NULL;
 486    }
 487
 488    id_screen->base.winsys = NULL;
 489
 490    id_screen->base.destroy = identity_screen_destroy;
 491    id_screen->base.get_name = identity_screen_get_name;
 492    id_screen->base.get_vendor = identity_screen_get_vendor;
 493    id_screen->base.get_param = identity_screen_get_param;
 494    id_screen->base.get_paramf = identity_screen_get_paramf;
 495    id_screen->base.is_format_supported = identity_screen_is_format_supported;
 496    id_screen->base.context_create = identity_screen_context_create;
 497    id_screen->base.texture_create = identity_screen_texture_create;
 498    id_screen->base.texture_blanket = identity_screen_texture_blanket;
 499    id_screen->base.texture_destroy = identity_screen_texture_destroy;
 500    id_screen->base.get_tex_surface = identity_screen_get_tex_surface;
 501    id_screen->base.tex_surface_destroy = identity_screen_tex_surface_destroy;
 502    id_screen->base.get_tex_transfer = identity_screen_get_tex_transfer;
 503    id_screen->base.tex_transfer_destroy = identity_screen_tex_transfer_destroy;
 504    id_screen->base.transfer_map = identity_screen_transfer_map;
 505    id_screen->base.transfer_unmap = identity_screen_transfer_unmap;
 506    id_screen->base.buffer_create = identity_screen_buffer_create;
 507    id_screen->base.user_buffer_create = identity_screen_user_buffer_create;
 508    id_screen->base.surface_buffer_create = identity_screen_surface_buffer_create;
 509    if (screen->buffer_map)
 510       id_screen->base.buffer_map = identity_screen_buffer_map;
 511    if (screen->buffer_map_range)
 512       id_screen->base.buffer_map_range = identity_screen_buffer_map_range;
 513    if (screen->buffer_flush_mapped_range)
 514       id_screen->base.buffer_flush_mapped_range = identity_screen_buffer_flush_mapped_range;
 515    if (screen->buffer_unmap)
 516       id_screen->base.buffer_unmap = identity_screen_buffer_unmap;
 517    id_screen->base.buffer_destroy = identity_screen_buffer_destroy;
 518    if (screen->video_surface_create) {
 519       id_screen->base.video_surface_create = identity_screen_video_surface_create;
 520    }
 521    if (screen->video_surface_destroy) {
 522       id_screen->base.video_surface_destroy = identity_screen_video_surface_destroy;
 523    }
 524    id_screen->base.flush_frontbuffer = identity_screen_flush_frontbuffer;
 525    id_screen->base.fence_reference = identity_screen_fence_reference;
 526    id_screen->base.fence_signalled = identity_screen_fence_signalled;
 527    id_screen->base.fence_finish = identity_screen_fence_finish;
 528
 529    id_screen->screen = screen;
 530
 531    return &id_screen->base;
 532 }