src/gallium/state_trackers/egl/common/native.h

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.8
   4  *
   5  * Copyright (C) 2009-2010 Chia-I Wu <olv@0xlab.org>
   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
  26 #ifndef _NATIVE_H_
  27 #define _NATIVE_H_
  28
  29 #include "EGL/egl.h"  /* for EGL native types */
  30
  31 #include "pipe/p_compiler.h"
  32 #include "pipe/p_screen.h"
  33 #include "pipe/p_context.h"
  34 #include "pipe/p_state.h"
  35 #include "state_tracker/sw_winsys.h"
  36
  37 #ifdef __cplusplus
  38 extern "C" {
  39 #endif
  40
  41 #include "native_buffer.h"
  42 #include "native_modeset.h"
  43 #include "native_wayland_bufmgr.h"
  44
  45 /**
  46  * Only color buffers are listed.  The others are allocated privately through,
  47  * for example, st_renderbuffer_alloc_storage().
  48  */
  49 enum native_attachment {
  50    NATIVE_ATTACHMENT_FRONT_LEFT,
  51    NATIVE_ATTACHMENT_BACK_LEFT,
  52    NATIVE_ATTACHMENT_FRONT_RIGHT,
  53    NATIVE_ATTACHMENT_BACK_RIGHT,
  54
  55    NUM_NATIVE_ATTACHMENTS
  56 };
  57
  58 enum native_param_type {
  59    /*
  60     * Return TRUE if window/pixmap surfaces use the buffers of the native
  61     * types.
  62     */
  63    NATIVE_PARAM_USE_NATIVE_BUFFER,
  64
  65    /**
  66     * Return TRUE if native_surface::present can preserve the buffer.
  67     */
  68    NATIVE_PARAM_PRESERVE_BUFFER,
  69
  70    /**
  71     * Return the maximum supported swap interval.
  72     */
  73    NATIVE_PARAM_MAX_SWAP_INTERVAL,
  74
  75    /**
  76     * Return TRUE if the display supports premultiplied alpha, regardless of
  77     * the surface color format.
  78     *
  79     * Note that returning TRUE for this parameter will make
  80     * EGL_VG_ALPHA_FORMAT_PRE_BIT to be set for all EGLConfig's with non-zero
  81     * EGL_ALPHA_SIZE.  EGL_VG_ALPHA_FORMAT attribute of a surface will affect
  82     * how the surface is presented.
  83     */
  84    NATIVE_PARAM_PREMULTIPLIED_ALPHA,
  85
  86    /**
  87     * Return TRUE if native_surface::present supports presenting a partial
  88     * surface.
  89     */
  90    NATIVE_PARAM_PRESENT_REGION
  91 };
  92
  93 /**
  94  * Control how a surface presentation should happen.
  95  */
  96 struct native_present_control {
  97    /**< the attachment to present */
  98    enum native_attachment natt;
  99
 100    /**< the contents of the presented attachment should be preserved */
 101    boolean preserve;
 102
 103    /**< wait until the given vsyncs has passed since the last presentation */
 104    uint swap_interval;
 105
 106    /**< pixels use premultiplied alpha */
 107    boolean premultiplied_alpha;
 108
 109    /**< The region to present. y=0=top.
 110         If num_rects is 0, the whole surface is to be presented */
 111    int num_rects;
 112    const int *rects; /* x, y, width, height */
 113 };
 114
 115 struct native_surface {
 116    /**
 117     * Available for caller's use.
 118     */
 119    void *user_data;
 120
 121    void (*destroy)(struct native_surface *nsurf);
 122
 123    /**
 124     * Present the given buffer to the native engine.
 125     */
 126    boolean (*present)(struct native_surface *nsurf,
 127                       const struct native_present_control *ctrl);
 128
 129    /**
 130     * Validate the buffers of the surface.  textures, if not NULL, points to an
 131     * array of size NUM_NATIVE_ATTACHMENTS and the returned textures are owned
 132     * by the caller.  A sequence number is also returned.  The caller can use
 133     * it to check if anything has changed since the last call. Any of the
 134     * pointers may be NULL and it indicates the caller has no interest in those
 135     * values.
 136     *
 137     * If this function is called multiple times with different attachment
 138     * masks, those not listed in the latest call might be destroyed.  This
 139     * behavior might change in the future.
 140     */
 141    boolean (*validate)(struct native_surface *nsurf, uint attachment_mask,
 142                        unsigned int *seq_num, struct pipe_resource **textures,
 143                        int *width, int *height);
 144
 145    /**
 146     * Wait until all native commands affecting the surface has been executed.
 147     */
 148    void (*wait)(struct native_surface *nsurf);
 149 };
 150
 151 /**
 152  * Describe a native display config.
 153  */
 154 struct native_config {
 155    /* available buffers and their format */
 156    uint buffer_mask;
 157    enum pipe_format color_format;
 158
 159    /* supported surface types */
 160    boolean window_bit;
 161    boolean pixmap_bit;
 162    boolean scanout_bit;
 163
 164    int native_visual_id;
 165    int native_visual_type;
 166    int level;
 167    boolean transparent_rgb;
 168    int transparent_rgb_values[3];
 169 };
 170
 171 /**
 172  * A pipe winsys abstracts the OS.  A pipe screen abstracts the graphcis
 173  * hardware.  A native display consists of a pipe winsys, a pipe screen, and
 174  * the native display server.
 175  */
 176 struct native_display {
 177    /**
 178     * The pipe screen of the native display.
 179     */
 180    struct pipe_screen *screen;
 181
 182    /**
 183     * Context used for copy operations.
 184     */
 185    struct pipe_context *pipe;
 186
 187    /**
 188     * Available for caller's use.
 189     */
 190    void *user_data;
 191
 192    /**
 193     * Initialize and create the pipe screen.
 194     */
 195    boolean (*init_screen)(struct native_display *ndpy);
 196
 197    void (*destroy)(struct native_display *ndpy);
 198
 199    /**
 200     * Query the parameters of the native display.
 201     *
 202     * The return value is defined by the parameter.
 203     */
 204    int (*get_param)(struct native_display *ndpy,
 205                     enum native_param_type param);
 206
 207    /**
 208     * Get the supported configs.  The configs are owned by the display, but
 209     * the returned array should be FREE()ed.
 210     */
 211    const struct native_config **(*get_configs)(struct native_display *ndpy,
 212                                                int *num_configs);
 213
 214    /**
 215     * Get the color format of the pixmap.  Required unless no config has
 216     * pixmap_bit set.
 217     */
 218    boolean (*get_pixmap_format)(struct native_display *ndpy,
 219                                 EGLNativePixmapType pix,
 220                                 enum pipe_format *format);
 221
 222    /**
 223     * Copy the contents of the resource to the pixmap's front-left attachment.
 224     * This is used to implement eglCopyBuffers.  Required unless no config has
 225     * pixmap_bit set.
 226     */
 227    boolean (*copy_to_pixmap)(struct native_display *ndpy,
 228                              EGLNativePixmapType pix,
 229                              struct pipe_resource *src);
 230
 231    /**
 232     * Create a window surface.  Required unless no config has window_bit set.
 233     */
 234    struct native_surface *(*create_window_surface)(struct native_display *ndpy,
 235                                                    EGLNativeWindowType win,
 236                                                    const struct native_config *nconf);
 237
 238    /**
 239     * Create a pixmap surface.  The native config may be NULL.  In that case, a
 240     * "best config" will be picked.  Required unless no config has pixmap_bit
 241     * set.
 242     */
 243    struct native_surface *(*create_pixmap_surface)(struct native_display *ndpy,
 244                                                    EGLNativePixmapType pix,
 245                                                    const struct native_config *nconf);
 246
 247    const struct native_display_buffer *buffer;
 248    const struct native_display_modeset *modeset;
 249    const struct native_display_wayland_bufmgr *wayland_bufmgr;
 250 };
 251
 252 /**
 253  * The handler for events that a native display may generate.  The events are
 254  * generated asynchronously and the handler may be called by any thread at any
 255  * time.
 256  */
 257 struct native_event_handler {
 258    /**
 259     * This function is called when a surface needs to be validated.
 260     */
 261    void (*invalid_surface)(struct native_display *ndpy,
 262                            struct native_surface *nsurf,
 263                            unsigned int seq_num);
 264
 265    struct pipe_screen *(*new_drm_screen)(struct native_display *ndpy,
 266                                          const char *name, int fd);
 267    struct pipe_screen *(*new_sw_screen)(struct native_display *ndpy,
 268                                         struct sw_winsys *ws);
 269
 270    struct pipe_resource *(*lookup_egl_image)(struct native_display *ndpy,
 271                                              void *egl_image);
 272 };
 273
 274 /**
 275  * Test whether an attachment is set in the mask.
 276  */
 277 static INLINE boolean
 278 native_attachment_mask_test(uint mask, enum native_attachment att)
 279 {
 280    return !!(mask & (1 << att));
 281 }
 282
 283 /**
 284  * Get the display copy context
 285  */
 286 static INLINE struct pipe_context *
 287 ndpy_get_copy_context(struct native_display *ndpy)
 288 {
 289    if (!ndpy->pipe)
 290       ndpy->pipe = ndpy->screen->context_create(ndpy->screen, NULL);
 291    return ndpy->pipe;
 292 }
 293
 294 /**
 295  * Free display screen and context resources
 296  */
 297 static INLINE void
 298 ndpy_uninit(struct native_display *ndpy)
 299 {
 300    if (ndpy->pipe)
 301       ndpy->pipe->destroy(ndpy->pipe);
 302    if (ndpy->screen)
 303       ndpy->screen->destroy(ndpy->screen);
 304 }
 305
 306 struct native_platform {
 307    const char *name;
 308
 309    /**
 310     * Create the native display and usually establish a connection to the
 311     * display server.
 312     *
 313     * No event should be generated at this stage.
 314     */
 315    struct native_display *(*create_display)(void *dpy, boolean use_sw);
 316 };
 317
 318 const struct native_platform *
 319 native_get_gdi_platform(const struct native_event_handler *event_handler);
 320
 321 const struct native_platform *
 322 native_get_x11_platform(const struct native_event_handler *event_handler);
 323
 324 const struct native_platform *
 325 native_get_wayland_platform(const struct native_event_handler *event_handler);
 326
 327 const struct native_platform *
 328 native_get_drm_platform(const struct native_event_handler *event_handler);
 329
 330 const struct native_platform *
 331 native_get_fbdev_platform(const struct native_event_handler *event_handler);
 332
 333 const struct native_platform *
 334 native_get_null_platform(const struct native_event_handler *event_handler);
 335
 336 const struct native_platform *
 337 native_get_android_platform(const struct native_event_handler *event_handler);
 338
 339 #ifdef __cplusplus
 340 }
 341 #endif
 342
 343 #endif /* _NATIVE_H_ */