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_from_handle(struct pipe_screen *_screen,
 139                                     const struct pipe_texture *templ,
 140                                     struct winsys_handle *handle)
 141 {
 142    struct identity_screen *id_screen = identity_screen(_screen);
 143    struct pipe_screen *screen = id_screen->screen;
 144    struct pipe_texture *result;
 145
 146    /* TODO trace call */
 147
 148    result = screen->texture_from_handle(screen, templ, handle);
 149
 150    result = identity_texture_create(identity_screen(_screen), result);
 151
 152    return result;
 153 }
 154
 155 static boolean
 156 identity_screen_texture_get_handle(struct pipe_screen *_screen,
 157                                    struct pipe_texture *_texture,
 158                                    struct winsys_handle *handle)
 159 {
 160    struct identity_screen *id_screen = identity_screen(_screen);
 161    struct identity_texture *id_texture = identity_texture(_texture);
 162    struct pipe_screen *screen = id_screen->screen;
 163    struct pipe_texture *texture = id_texture->texture;
 164
 165    /* TODO trace call */
 166
 167    return screen->texture_get_handle(screen, texture, handle);
 168 }
 169
 170
 171
 172 static void
 173 identity_screen_texture_destroy(struct pipe_texture *_texture)
 174 {
 175    identity_texture_destroy(identity_texture(_texture));
 176 }
 177
 178 static struct pipe_surface *
 179 identity_screen_get_tex_surface(struct pipe_screen *_screen,
 180                                 struct pipe_texture *_texture,
 181                                 unsigned face,
 182                                 unsigned level,
 183                                 unsigned zslice,
 184                                 unsigned usage)
 185 {
 186    struct identity_screen *id_screen = identity_screen(_screen);
 187    struct identity_texture *id_texture = identity_texture(_texture);
 188    struct pipe_screen *screen = id_screen->screen;
 189    struct pipe_texture *texture = id_texture->texture;
 190    struct pipe_surface *result;
 191
 192    result = screen->get_tex_surface(screen,
 193                                     texture,
 194                                     face,
 195                                     level,
 196                                     zslice,
 197                                     usage);
 198
 199    if (result)
 200       return identity_surface_create(id_texture, result);
 201    return NULL;
 202 }
 203
 204 static void
 205 identity_screen_tex_surface_destroy(struct pipe_surface *_surface)
 206 {
 207    identity_surface_destroy(identity_surface(_surface));
 208 }
 209
 210
 211 static struct pipe_buffer *
 212 identity_screen_buffer_create(struct pipe_screen *_screen,
 213                               unsigned alignment,
 214                               unsigned usage,
 215                               unsigned size)
 216 {
 217    struct identity_screen *id_screen = identity_screen(_screen);
 218    struct pipe_screen *screen = id_screen->screen;
 219    struct pipe_buffer *result;
 220
 221    result = screen->buffer_create(screen,
 222                                   alignment,
 223                                   usage,
 224                                   size);
 225
 226    if (result)
 227       return identity_buffer_create(id_screen, result);
 228    return NULL;
 229 }
 230
 231 static struct pipe_buffer *
 232 identity_screen_user_buffer_create(struct pipe_screen *_screen,
 233                                    void *ptr,
 234                                    unsigned bytes)
 235 {
 236    struct identity_screen *id_screen = identity_screen(_screen);
 237    struct pipe_screen *screen = id_screen->screen;
 238    struct pipe_buffer *result;
 239
 240    result = screen->user_buffer_create(screen,
 241                                        ptr,
 242                                        bytes);
 243
 244    if (result)
 245       return identity_buffer_create(id_screen, result);
 246    return NULL;
 247 }
 248
 249
 250 static void *
 251 identity_screen_buffer_map(struct pipe_screen *_screen,
 252                            struct pipe_buffer *_buffer,
 253                            unsigned usage)
 254 {
 255    struct identity_screen *id_screen = identity_screen(_screen);
 256    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 257    struct pipe_screen *screen = id_screen->screen;
 258    struct pipe_buffer *buffer = id_buffer->buffer;
 259
 260    return screen->buffer_map(screen,
 261                              buffer,
 262                              usage);
 263 }
 264
 265 static void *
 266 identity_screen_buffer_map_range(struct pipe_screen *_screen,
 267                                  struct pipe_buffer *_buffer,
 268                                  unsigned offset,
 269                                  unsigned length,
 270                                  unsigned usage)
 271 {
 272    struct identity_screen *id_screen = identity_screen(_screen);
 273    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 274    struct pipe_screen *screen = id_screen->screen;
 275    struct pipe_buffer *buffer = id_buffer->buffer;
 276
 277    return screen->buffer_map_range(screen,
 278                                    buffer,
 279                                    offset,
 280                                    length,
 281                                    usage);
 282 }
 283
 284 static void
 285 identity_screen_buffer_flush_mapped_range(struct pipe_screen *_screen,
 286                                           struct pipe_buffer *_buffer,
 287                                           unsigned offset,
 288                                           unsigned length)
 289 {
 290    struct identity_screen *id_screen = identity_screen(_screen);
 291    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 292    struct pipe_screen *screen = id_screen->screen;
 293    struct pipe_buffer *buffer = id_buffer->buffer;
 294
 295    screen->buffer_flush_mapped_range(screen,
 296                                      buffer,
 297                                      offset,
 298                                      length);
 299 }
 300
 301 static void
 302 identity_screen_buffer_unmap(struct pipe_screen *_screen,
 303                              struct pipe_buffer *_buffer)
 304 {
 305    struct identity_screen *id_screen = identity_screen(_screen);
 306    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 307    struct pipe_screen *screen = id_screen->screen;
 308    struct pipe_buffer *buffer = id_buffer->buffer;
 309
 310    screen->buffer_unmap(screen,
 311                         buffer);
 312 }
 313
 314 static void
 315 identity_screen_buffer_destroy(struct pipe_buffer *_buffer)
 316 {
 317    identity_buffer_destroy(identity_buffer(_buffer));
 318 }
 319
 320 static struct pipe_video_surface *
 321 identity_screen_video_surface_create(struct pipe_screen *_screen,
 322                                      enum pipe_video_chroma_format chroma_format,
 323                                      unsigned width,
 324                                      unsigned height)
 325 {
 326    struct identity_screen *id_screen = identity_screen(_screen);
 327    struct pipe_screen *screen = id_screen->screen;
 328    struct pipe_video_surface *result;
 329
 330    result = screen->video_surface_create(screen,
 331                                          chroma_format,
 332                                          width,
 333                                          height);
 334
 335    if (result) {
 336       return identity_video_surface_create(id_screen, result);
 337    }
 338    return NULL;
 339 }
 340
 341 static void
 342 identity_screen_video_surface_destroy(struct pipe_video_surface *_vsfc)
 343 {
 344    identity_video_surface_destroy(identity_video_surface(_vsfc));
 345 }
 346
 347 static void
 348 identity_screen_flush_frontbuffer(struct pipe_screen *_screen,
 349                                   struct pipe_surface *_surface,
 350                                   void *context_private)
 351 {
 352    struct identity_screen *id_screen = identity_screen(_screen);
 353    struct identity_surface *id_surface = identity_surface(_surface);
 354    struct pipe_screen *screen = id_screen->screen;
 355    struct pipe_surface *surface = id_surface->surface;
 356
 357    screen->flush_frontbuffer(screen,
 358                              surface,
 359                              context_private);
 360 }
 361
 362 static void
 363 identity_screen_fence_reference(struct pipe_screen *_screen,
 364                                 struct pipe_fence_handle **ptr,
 365                                 struct pipe_fence_handle *fence)
 366 {
 367    struct identity_screen *id_screen = identity_screen(_screen);
 368    struct pipe_screen *screen = id_screen->screen;
 369
 370    screen->fence_reference(screen,
 371                            ptr,
 372                            fence);
 373 }
 374
 375 static int
 376 identity_screen_fence_signalled(struct pipe_screen *_screen,
 377                                 struct pipe_fence_handle *fence,
 378                                 unsigned flags)
 379 {
 380    struct identity_screen *id_screen = identity_screen(_screen);
 381    struct pipe_screen *screen = id_screen->screen;
 382
 383    return screen->fence_signalled(screen,
 384                                   fence,
 385                                   flags);
 386 }
 387
 388 static int
 389 identity_screen_fence_finish(struct pipe_screen *_screen,
 390                              struct pipe_fence_handle *fence,
 391                              unsigned flags)
 392 {
 393    struct identity_screen *id_screen = identity_screen(_screen);
 394    struct pipe_screen *screen = id_screen->screen;
 395
 396    return screen->fence_finish(screen,
 397                                fence,
 398                                flags);
 399 }
 400
 401 struct pipe_screen *
 402 identity_screen_create(struct pipe_screen *screen)
 403 {
 404    struct identity_screen *id_screen;
 405
 406    id_screen = CALLOC_STRUCT(identity_screen);
 407    if (!id_screen) {
 408       return NULL;
 409    }
 410
 411    id_screen->base.winsys = NULL;
 412
 413    id_screen->base.destroy = identity_screen_destroy;
 414    id_screen->base.get_name = identity_screen_get_name;
 415    id_screen->base.get_vendor = identity_screen_get_vendor;
 416    id_screen->base.get_param = identity_screen_get_param;
 417    id_screen->base.get_paramf = identity_screen_get_paramf;
 418    id_screen->base.is_format_supported = identity_screen_is_format_supported;
 419    id_screen->base.context_create = identity_screen_context_create;
 420    id_screen->base.texture_create = identity_screen_texture_create;
 421    id_screen->base.texture_from_handle = identity_screen_texture_from_handle;
 422    id_screen->base.texture_get_handle = identity_screen_texture_get_handle;
 423    id_screen->base.texture_destroy = identity_screen_texture_destroy;
 424    id_screen->base.get_tex_surface = identity_screen_get_tex_surface;
 425    id_screen->base.tex_surface_destroy = identity_screen_tex_surface_destroy;
 426    id_screen->base.buffer_create = identity_screen_buffer_create;
 427    id_screen->base.user_buffer_create = identity_screen_user_buffer_create;
 428    if (screen->buffer_map)
 429       id_screen->base.buffer_map = identity_screen_buffer_map;
 430    if (screen->buffer_map_range)
 431       id_screen->base.buffer_map_range = identity_screen_buffer_map_range;
 432    if (screen->buffer_flush_mapped_range)
 433       id_screen->base.buffer_flush_mapped_range = identity_screen_buffer_flush_mapped_range;
 434    if (screen->buffer_unmap)
 435       id_screen->base.buffer_unmap = identity_screen_buffer_unmap;
 436    id_screen->base.buffer_destroy = identity_screen_buffer_destroy;
 437    if (screen->video_surface_create) {
 438       id_screen->base.video_surface_create = identity_screen_video_surface_create;
 439    }
 440    if (screen->video_surface_destroy) {
 441       id_screen->base.video_surface_destroy = identity_screen_video_surface_destroy;
 442    }
 443    id_screen->base.flush_frontbuffer = identity_screen_flush_frontbuffer;
 444    id_screen->base.fence_reference = identity_screen_fence_reference;
 445    id_screen->base.fence_signalled = identity_screen_fence_signalled;
 446    id_screen->base.fence_finish = identity_screen_fence_finish;
 447
 448    id_screen->screen = screen;
 449
 450    return &id_screen->base;
 451 }