present/present_priv.h

   1 /*
   2  * Copyright © 2013 Keith Packard
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #ifndef _PRESENT_PRIV_H_
  24 #define _PRESENT_PRIV_H_
  25
  26 #include <X11/X.h>
  27 #include "scrnintstr.h"
  28 #include "misc.h"
  29 #include "list.h"
  30 #include "windowstr.h"
  31 #include "dixstruct.h"
  32 #include "present.h"
  33 #include <syncsdk.h>
  34 #include <syncsrv.h>
  35 #include <xfixes.h>
  36 #include <randrstr.h>
  37
  38 extern int present_request;
  39
  40 extern DevPrivateKeyRec present_screen_private_key;
  41
  42 typedef struct present_fence *present_fence_ptr;
  43
  44 typedef struct present_notify present_notify_rec, *present_notify_ptr;
  45
  46 struct present_notify {
  47     struct xorg_list    window_list;
  48     WindowPtr           window;
  49     CARD32              serial;
  50 };
  51
  52 struct present_vblank {
  53     struct xorg_list    window_list;
  54     struct xorg_list    event_queue;
  55     ScreenPtr           screen;
  56     WindowPtr           window;
  57     PixmapPtr           pixmap;
  58     RegionPtr           valid;
  59     RegionPtr           update;
  60     RRCrtcPtr           crtc;
  61     uint32_t            serial;
  62     int16_t             x_off;
  63     int16_t             y_off;
  64     CARD16              kind;
  65     uint64_t            event_id;
  66     uint64_t            target_msc;
  67     uint64_t            msc_offset;
  68     present_fence_ptr   idle_fence;
  69     present_fence_ptr   wait_fence;
  70     present_notify_ptr  notifies;
  71     int                 num_notifies;
  72     Bool                queued;         /* on present_exec_queue */
  73     Bool                flip;           /* planning on using flip */
  74     Bool                sync_flip;      /* do flip synchronous to vblank */
  75     Bool                abort_flip;     /* aborting this flip */
  76 };
  77
  78 typedef struct present_screen_priv {
  79     CloseScreenProcPtr          CloseScreen;
  80     ConfigNotifyProcPtr         ConfigNotify;
  81     DestroyWindowProcPtr        DestroyWindow;
  82     ClipNotifyProcPtr           ClipNotify;
  83
  84     present_vblank_ptr          flip_pending;
  85     uint64_t                    unflip_event_id;
  86
  87     uint32_t                    fake_interval;
  88
  89     /* Currently active flipped pixmap and fence */
  90     RRCrtcPtr                   flip_crtc;
  91     WindowPtr                   flip_window;
  92     uint32_t                    flip_serial;
  93     PixmapPtr                   flip_pixmap;
  94     present_fence_ptr           flip_idle_fence;
  95
  96     present_screen_info_ptr     info;
  97 } present_screen_priv_rec, *present_screen_priv_ptr;
  98
  99 #define wrap(priv,real,mem,func) {\
 100     priv->mem = real->mem; \
 101     real->mem = func; \
 102 }
 103
 104 #define unwrap(priv,real,mem) {\
 105     real->mem = priv->mem; \
 106 }
 107
 108 static inline present_screen_priv_ptr
 109 present_screen_priv(ScreenPtr screen)
 110 {
 111     return (present_screen_priv_ptr)dixLookupPrivate(&(screen)->devPrivates, &present_screen_private_key);
 112 }
 113
 114 /*
 115  * Each window has a list of clients and event masks
 116  */
 117 typedef struct present_event *present_event_ptr;
 118
 119 typedef struct present_event {
 120     present_event_ptr next;
 121     ClientPtr client;
 122     WindowPtr window;
 123     XID id;
 124     int mask;
 125 } present_event_rec;
 126
 127 typedef struct present_window_priv {
 128     present_event_ptr      events;
 129     RRCrtcPtr              crtc;        /* Last reported CRTC from get_ust_msc */
 130     uint64_t               msc_offset;
 131     uint64_t               msc;         /* Last reported MSC from the current crtc */
 132     struct xorg_list       vblank;
 133     struct xorg_list       notifies;
 134 } present_window_priv_rec, *present_window_priv_ptr;
 135
 136 extern DevPrivateKeyRec present_window_private_key;
 137
 138 static inline present_window_priv_ptr
 139 present_window_priv(WindowPtr window)
 140 {
 141     return (present_window_priv_ptr)dixGetPrivate(&(window)->devPrivates, &present_window_private_key);
 142 }
 143
 144 present_window_priv_ptr
 145 present_get_window_priv(WindowPtr window, Bool create);
 146
 147 extern RESTYPE present_event_type;
 148
 149 /*
 150  * present.c
 151  */
 152 int
 153 present_pixmap(WindowPtr window,
 154                PixmapPtr pixmap,
 155                CARD32 serial,
 156                RegionPtr valid,
 157                RegionPtr update,
 158                int16_t x_off,
 159                int16_t y_off,
 160                RRCrtcPtr target_crtc,
 161                SyncFence *wait_fence,
 162                SyncFence *idle_fence,
 163                uint32_t options,
 164                uint64_t target_msc,
 165                uint64_t divisor,
 166                uint64_t remainder,
 167                present_notify_ptr notifies,
 168                int num_notifies);
 169
 170 int
 171 present_notify_msc(WindowPtr window,
 172                    CARD32 serial,
 173                    uint64_t target_msc,
 174                    uint64_t divisor,
 175                    uint64_t remainder);
 176
 177 void
 178 present_abort_vblank(ScreenPtr screen, RRCrtcPtr crtc, uint64_t event_id, uint64_t msc);
 179
 180 void
 181 present_vblank_destroy(present_vblank_ptr vblank);
 182
 183 void
 184 present_flip_destroy(ScreenPtr screen);
 185
 186 void
 187 present_check_flip_window(WindowPtr window);
 188
 189 RRCrtcPtr
 190 present_get_crtc(WindowPtr window);
 191
 192 uint32_t
 193 present_query_capabilities(RRCrtcPtr crtc);
 194
 195 Bool
 196 present_init(void);
 197
 198 /*
 199  * present_event.c
 200  */
 201
 202 void
 203 present_free_events(WindowPtr window);
 204
 205 void
 206 present_send_config_notify(WindowPtr window, int x, int y, int w, int h, int bw, WindowPtr sibling);
 207
 208 void
 209 present_send_complete_notify(WindowPtr window, CARD8 kind, CARD8 mode, CARD32 serial, uint64_t ust, uint64_t msc);
 210
 211 void
 212 present_send_idle_notify(WindowPtr window, CARD32 serial, PixmapPtr pixmap, present_fence_ptr idle_fence);
 213
 214 int
 215 present_select_input(ClientPtr client,
 216                      CARD32 eid,
 217                      WindowPtr window,
 218                      CARD32 event_mask);
 219
 220 Bool
 221 present_event_init(void);
 222
 223 /*
 224  * present_fake.c
 225  */
 226 int
 227 present_fake_get_ust_msc(ScreenPtr screen, uint64_t *ust, uint64_t *msc);
 228
 229 int
 230 present_fake_queue_vblank(ScreenPtr screen, uint64_t event_id, uint64_t msc);
 231
 232 void
 233 present_fake_abort_vblank(ScreenPtr screen, uint64_t event_id, uint64_t msc);
 234
 235 void
 236 present_fake_screen_init(ScreenPtr screen);
 237
 238 void
 239 present_fake_queue_init(void);
 240
 241 /*
 242  * present_fence.c
 243  */
 244 struct present_fence *
 245 present_fence_create(SyncFence *sync_fence);
 246
 247 void
 248 present_fence_destroy(struct present_fence *present_fence);
 249
 250 void
 251 present_fence_set_triggered(struct present_fence *present_fence);
 252
 253 Bool
 254 present_fence_check_triggered(struct present_fence *present_fence);
 255
 256 void
 257 present_fence_set_callback(struct present_fence *present_fence,
 258                            void (*callback)(void *param),
 259                            void *param);
 260
 261 XID
 262 present_fence_id(struct present_fence *present_fence);
 263
 264 /*
 265  * present_notify.c
 266  */
 267 void
 268 present_clear_window_notifies(WindowPtr window);
 269
 270 void
 271 present_free_window_notify(present_notify_ptr notify);
 272
 273 int
 274 present_add_window_notify(present_notify_ptr notify);
 275
 276 int
 277 present_create_notifies(ClientPtr client, int num_notifies, xPresentNotify *x_notifies, present_notify_ptr *p_notifies);
 278
 279 void
 280 present_destroy_notifies(present_notify_ptr notifies, int num_notifies);
 281
 282 /*
 283  * present_redirect.c
 284  */
 285
 286 WindowPtr
 287 present_redirect(ClientPtr client, WindowPtr target);
 288
 289 /*
 290  * present_request.c
 291  */
 292 int
 293 proc_present_dispatch(ClientPtr client);
 294
 295 int
 296 sproc_present_dispatch(ClientPtr client);
 297
 298 /*
 299  * present_screen.c
 300  */
 301
 302 #endif /*  _PRESENT_PRIV_H_ */