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                           enum pipe_cap 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                            enum pipe_cap 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 sample_count,
  95                                     unsigned tex_usage,
  96                                     unsigned geom_flags)
  97 {
  98    struct identity_screen *id_screen = identity_screen(_screen);
  99    struct pipe_screen *screen = id_screen->screen;
 100
 101    return screen->is_format_supported(screen,
 102                                       format,
 103                                       target,
 104                                       sample_count,
 105                                       tex_usage,
 106                                       geom_flags);
 107 }
 108
 109 static struct pipe_context *
 110 identity_screen_context_create(struct pipe_screen *_screen,
 111                                void *priv)
 112 {
 113    struct identity_screen *id_screen = identity_screen(_screen);
 114    struct pipe_screen *screen = id_screen->screen;
 115    struct pipe_context *result;
 116
 117    result = screen->context_create(screen, priv);
 118    if (result)
 119       return identity_context_create(_screen, result);
 120    return NULL;
 121 }
 122
 123 static struct pipe_resource *
 124 identity_screen_resource_create(struct pipe_screen *_screen,
 125                                 const struct pipe_resource *templat)
 126 {
 127    struct identity_screen *id_screen = identity_screen(_screen);
 128    struct pipe_screen *screen = id_screen->screen;
 129    struct pipe_resource *result;
 130
 131    result = screen->resource_create(screen,
 132                                     templat);
 133
 134    if (result)
 135       return identity_resource_create(id_screen, result);
 136    return NULL;
 137 }
 138
 139 static struct pipe_resource *
 140 identity_screen_resource_from_handle(struct pipe_screen *_screen,
 141                                      const struct pipe_resource *templ,
 142                                      struct winsys_handle *handle)
 143 {
 144    struct identity_screen *id_screen = identity_screen(_screen);
 145    struct pipe_screen *screen = id_screen->screen;
 146    struct pipe_resource *result;
 147
 148    /* TODO trace call */
 149
 150    result = screen->resource_from_handle(screen, templ, handle);
 151
 152    result = identity_resource_create(identity_screen(_screen), result);
 153
 154    return result;
 155 }
 156
 157 static boolean
 158 identity_screen_resource_get_handle(struct pipe_screen *_screen,
 159                                     struct pipe_resource *_resource,
 160                                     struct winsys_handle *handle)
 161 {
 162    struct identity_screen *id_screen = identity_screen(_screen);
 163    struct identity_resource *id_resource = identity_resource(_resource);
 164    struct pipe_screen *screen = id_screen->screen;
 165    struct pipe_resource *resource = id_resource->resource;
 166
 167    /* TODO trace call */
 168
 169    return screen->resource_get_handle(screen, resource, handle);
 170 }
 171
 172
 173
 174 static void
 175 identity_screen_resource_destroy(struct pipe_screen *screen,
 176                                  struct pipe_resource *_resource)
 177 {
 178    identity_resource_destroy(identity_resource(_resource));
 179 }
 180
 181 static struct pipe_surface *
 182 identity_screen_get_tex_surface(struct pipe_screen *_screen,
 183                                 struct pipe_resource *_resource,
 184                                 unsigned face,
 185                                 unsigned level,
 186                                 unsigned zslice,
 187                                 unsigned usage)
 188 {
 189    struct identity_screen *id_screen = identity_screen(_screen);
 190    struct identity_resource *id_resource = identity_resource(_resource);
 191    struct pipe_screen *screen = id_screen->screen;
 192    struct pipe_resource *resource = id_resource->resource;
 193    struct pipe_surface *result;
 194
 195    result = screen->get_tex_surface(screen,
 196                                     resource,
 197                                     face,
 198                                     level,
 199                                     zslice,
 200                                     usage);
 201
 202    if (result)
 203       return identity_surface_create(id_resource, result);
 204    return NULL;
 205 }
 206
 207 static void
 208 identity_screen_tex_surface_destroy(struct pipe_surface *_surface)
 209 {
 210    identity_surface_destroy(identity_surface(_surface));
 211 }
 212
 213
 214
 215 static struct pipe_resource *
 216 identity_screen_user_buffer_create(struct pipe_screen *_screen,
 217                                    void *ptr,
 218                                    unsigned bytes,
 219                                    unsigned usage)
 220 {
 221    struct identity_screen *id_screen = identity_screen(_screen);
 222    struct pipe_screen *screen = id_screen->screen;
 223    struct pipe_resource *result;
 224
 225    result = screen->user_buffer_create(screen,
 226                                        ptr,
 227                                        bytes,
 228                                        usage);
 229
 230    if (result)
 231       return identity_resource_create(id_screen, result);
 232    return NULL;
 233 }
 234
 235
 236
 237 static void
 238 identity_screen_flush_frontbuffer(struct pipe_screen *_screen,
 239                                   struct pipe_surface *_surface,
 240                                   void *context_private)
 241 {
 242    struct identity_screen *id_screen = identity_screen(_screen);
 243    struct identity_surface *id_surface = identity_surface(_surface);
 244    struct pipe_screen *screen = id_screen->screen;
 245    struct pipe_surface *surface = id_surface->surface;
 246
 247    screen->flush_frontbuffer(screen,
 248                              surface,
 249                              context_private);
 250 }
 251
 252 static void
 253 identity_screen_fence_reference(struct pipe_screen *_screen,
 254                                 struct pipe_fence_handle **ptr,
 255                                 struct pipe_fence_handle *fence)
 256 {
 257    struct identity_screen *id_screen = identity_screen(_screen);
 258    struct pipe_screen *screen = id_screen->screen;
 259
 260    screen->fence_reference(screen,
 261                            ptr,
 262                            fence);
 263 }
 264
 265 static int
 266 identity_screen_fence_signalled(struct pipe_screen *_screen,
 267                                 struct pipe_fence_handle *fence,
 268                                 unsigned flags)
 269 {
 270    struct identity_screen *id_screen = identity_screen(_screen);
 271    struct pipe_screen *screen = id_screen->screen;
 272
 273    return screen->fence_signalled(screen,
 274                                   fence,
 275                                   flags);
 276 }
 277
 278 static int
 279 identity_screen_fence_finish(struct pipe_screen *_screen,
 280                              struct pipe_fence_handle *fence,
 281                              unsigned flags)
 282 {
 283    struct identity_screen *id_screen = identity_screen(_screen);
 284    struct pipe_screen *screen = id_screen->screen;
 285
 286    return screen->fence_finish(screen,
 287                                fence,
 288                                flags);
 289 }
 290
 291 struct pipe_screen *
 292 identity_screen_create(struct pipe_screen *screen)
 293 {
 294    struct identity_screen *id_screen;
 295
 296    id_screen = CALLOC_STRUCT(identity_screen);
 297    if (!id_screen) {
 298       return NULL;
 299    }
 300
 301    id_screen->base.winsys = NULL;
 302
 303    id_screen->base.destroy = identity_screen_destroy;
 304    id_screen->base.get_name = identity_screen_get_name;
 305    id_screen->base.get_vendor = identity_screen_get_vendor;
 306    id_screen->base.get_param = identity_screen_get_param;
 307    id_screen->base.get_paramf = identity_screen_get_paramf;
 308    id_screen->base.is_format_supported = identity_screen_is_format_supported;
 309    id_screen->base.context_create = identity_screen_context_create;
 310    id_screen->base.resource_create = identity_screen_resource_create;
 311    id_screen->base.resource_from_handle = identity_screen_resource_from_handle;
 312    id_screen->base.resource_get_handle = identity_screen_resource_get_handle;
 313    id_screen->base.resource_destroy = identity_screen_resource_destroy;
 314    id_screen->base.get_tex_surface = identity_screen_get_tex_surface;
 315    id_screen->base.tex_surface_destroy = identity_screen_tex_surface_destroy;
 316    id_screen->base.user_buffer_create = identity_screen_user_buffer_create;
 317    id_screen->base.flush_frontbuffer = identity_screen_flush_frontbuffer;
 318    id_screen->base.fence_reference = identity_screen_fence_reference;
 319    id_screen->base.fence_signalled = identity_screen_fence_signalled;
 320    id_screen->base.fence_finish = identity_screen_fence_finish;
 321
 322    id_screen->screen = screen;
 323
 324    return &id_screen->base;
 325 }