| File: | present/present.c |
| Location: | line 175, column 42 |
| Description: | Access to field 'pScreen' results in a dereference of a null pointer (loaded from variable 'crtc') |
| 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 | #ifdef HAVE_XORG_CONFIG_H1 | |||
| 24 | #include <xorg-config.h> | |||
| 25 | #endif | |||
| 26 | ||||
| 27 | #include "present_priv.h" | |||
| 28 | #include <gcstruct.h> | |||
| 29 | #include <misync.h> | |||
| 30 | #include <misyncstr.h> | |||
| 31 | #ifdef MONOTONIC_CLOCK | |||
| 32 | #include <time.h> | |||
| 33 | #endif | |||
| 34 | ||||
| 35 | static uint64_t present_event_id; | |||
| 36 | static struct xorg_list present_exec_queue; | |||
| 37 | static struct xorg_list present_flip_queue; | |||
| 38 | ||||
| 39 | #if 0 | |||
| 40 | #define DebugPresent(x) ErrorF x | |||
| 41 | #else | |||
| 42 | #define DebugPresent(x) | |||
| 43 | #endif | |||
| 44 | ||||
| 45 | static void | |||
| 46 | present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc); | |||
| 47 | ||||
| 48 | /* | |||
| 49 | * Copies the update region from a pixmap to the target drawable | |||
| 50 | */ | |||
| 51 | static void | |||
| 52 | present_copy_region(DrawablePtr drawable, | |||
| 53 | PixmapPtr pixmap, | |||
| 54 | RegionPtr update, | |||
| 55 | int16_t x_off, | |||
| 56 | int16_t y_off) | |||
| 57 | { | |||
| 58 | ScreenPtr screen = drawable->pScreen; | |||
| 59 | GCPtr gc; | |||
| 60 | ||||
| 61 | gc = GetScratchGC(drawable->depth, screen); | |||
| 62 | if (update) { | |||
| 63 | ChangeGCVal changes[2]; | |||
| 64 | ||||
| 65 | changes[0].val = x_off; | |||
| 66 | changes[1].val = y_off; | |||
| 67 | ChangeGC(serverClient, gc, | |||
| 68 | GCClipXOrigin(1L<<17)|GCClipYOrigin(1L<<18), | |||
| 69 | changes); | |||
| 70 | (*gc->funcs->ChangeClip)(gc, CT_REGION2, update, 0); | |||
| 71 | } | |||
| 72 | ValidateGC(drawable, gc); | |||
| 73 | (*gc->ops->CopyArea)(&pixmap->drawable, | |||
| 74 | drawable, | |||
| 75 | gc, | |||
| 76 | 0, 0, | |||
| 77 | pixmap->drawable.width, pixmap->drawable.height, | |||
| 78 | x_off, y_off); | |||
| 79 | if (update) | |||
| 80 | (*gc->funcs->ChangeClip)(gc, CT_NONE0, NULL((void*)0), 0); | |||
| 81 | FreeScratchGC(gc); | |||
| 82 | } | |||
| 83 | ||||
| 84 | static inline PixmapPtr | |||
| 85 | present_flip_pending_pixmap(ScreenPtr screen) | |||
| 86 | { | |||
| 87 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 88 | ||||
| 89 | if (!screen_priv) | |||
| 90 | return NULL((void*)0); | |||
| 91 | ||||
| 92 | if (!screen_priv->flip_pending) | |||
| 93 | return NULL((void*)0); | |||
| 94 | ||||
| 95 | return screen_priv->flip_pending->pixmap; | |||
| 96 | } | |||
| 97 | ||||
| 98 | static Bool | |||
| 99 | present_check_flip(RRCrtcPtr crtc, | |||
| 100 | WindowPtr window, | |||
| 101 | PixmapPtr pixmap, | |||
| 102 | Bool sync_flip, | |||
| 103 | RegionPtr valid, | |||
| 104 | int16_t x_off, | |||
| 105 | int16_t y_off) | |||
| 106 | { | |||
| 107 | ScreenPtr screen = window->drawable.pScreen; | |||
| 108 | PixmapPtr window_pixmap; | |||
| 109 | WindowPtr root = screen->root; | |||
| 110 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 111 | ||||
| 112 | if (!screen_priv) | |||
| 113 | return FALSE0; | |||
| 114 | ||||
| 115 | if (!screen_priv->info) | |||
| 116 | return FALSE0; | |||
| 117 | ||||
| 118 | if (!crtc) | |||
| 119 | return FALSE0; | |||
| 120 | ||||
| 121 | /* Check to see if the driver supports flips at all */ | |||
| 122 | if (!screen_priv->info->flip) | |||
| 123 | return FALSE0; | |||
| 124 | ||||
| 125 | /* Make sure the window hasn't been redirected with Composite */ | |||
| 126 | window_pixmap = screen->GetWindowPixmap(window); | |||
| 127 | if (window_pixmap != screen->GetScreenPixmap(screen) && | |||
| 128 | window_pixmap != screen_priv->flip_pixmap && | |||
| 129 | window_pixmap != present_flip_pending_pixmap(screen)) | |||
| 130 | return FALSE0; | |||
| 131 | ||||
| 132 | /* Check for full-screen window */ | |||
| 133 | if (!RegionEqual(&window->clipList, &root->winSize)) { | |||
| 134 | return FALSE0; | |||
| 135 | } | |||
| 136 | ||||
| 137 | /* Source pixmap must align with window exactly */ | |||
| 138 | if (x_off || y_off) { | |||
| 139 | return FALSE0; | |||
| 140 | } | |||
| 141 | ||||
| 142 | /* Make sure the area marked as valid fills the screen */ | |||
| 143 | if (valid && !RegionEqual(valid, &root->winSize)) { | |||
| 144 | return FALSE0; | |||
| 145 | } | |||
| 146 | ||||
| 147 | /* Does the window match the pixmap exactly? */ | |||
| 148 | if (window->drawable.x != 0 || window->drawable.y != 0 || | |||
| 149 | #ifdef COMPOSITE | |||
| 150 | window->drawable.x != pixmap->screen_x || window->drawable.y != pixmap->screen_y || | |||
| 151 | #endif | |||
| 152 | window->drawable.width != pixmap->drawable.width || | |||
| 153 | window->drawable.height != pixmap->drawable.height) { | |||
| 154 | return FALSE0; | |||
| 155 | } | |||
| 156 | ||||
| 157 | /* Ask the driver for permission */ | |||
| 158 | if (screen_priv->info->check_flip) { | |||
| 159 | if (!(*screen_priv->info->check_flip) (crtc, window, pixmap, sync_flip)) { | |||
| 160 | DebugPresent(("\td %08lx -> %08lx\n", window->drawable.id, pixmap ? pixmap->drawable.id : 0)); | |||
| 161 | return FALSE0; | |||
| 162 | } | |||
| 163 | } | |||
| 164 | ||||
| 165 | return TRUE1; | |||
| 166 | } | |||
| 167 | ||||
| 168 | static Bool | |||
| 169 | present_flip(RRCrtcPtr crtc, | |||
| 170 | uint64_t event_id, | |||
| 171 | uint64_t target_msc, | |||
| 172 | PixmapPtr pixmap, | |||
| 173 | Bool sync_flip) | |||
| 174 | { | |||
| 175 | ScreenPtr screen = crtc->pScreen; | |||
| ||||
| 176 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 177 | ||||
| 178 | return (*screen_priv->info->flip) (crtc, event_id, target_msc, pixmap, sync_flip); | |||
| 179 | } | |||
| 180 | ||||
| 181 | static void | |||
| 182 | present_vblank_notify(present_vblank_ptr vblank, CARD8 kind, CARD8 mode, uint64_t ust, uint64_t crtc_msc) | |||
| 183 | { | |||
| 184 | int n; | |||
| 185 | ||||
| 186 | if (vblank->window) | |||
| 187 | present_send_complete_notify(vblank->window, kind, mode, vblank->serial, ust, crtc_msc - vblank->msc_offset); | |||
| 188 | for (n = 0; n < vblank->num_notifies; n++) { | |||
| 189 | WindowPtr window = vblank->notifies[n].window; | |||
| 190 | CARD32 serial = vblank->notifies[n].serial; | |||
| 191 | ||||
| 192 | if (window) | |||
| 193 | present_send_complete_notify(window, kind, mode, serial, ust, crtc_msc - vblank->msc_offset); | |||
| 194 | } | |||
| 195 | } | |||
| 196 | ||||
| 197 | static void | |||
| 198 | present_pixmap_idle(PixmapPtr pixmap, WindowPtr window, CARD32 serial, struct present_fence *present_fence) | |||
| 199 | { | |||
| 200 | if (present_fence) | |||
| 201 | present_fence_set_triggered(present_fence); | |||
| 202 | if (window) { | |||
| 203 | DebugPresent(("\ti %08lx\n", pixmap ? pixmap->drawable.id : 0)); | |||
| 204 | present_send_idle_notify(window, serial, pixmap, present_fence); | |||
| 205 | } | |||
| 206 | } | |||
| 207 | ||||
| 208 | RRCrtcPtr | |||
| 209 | present_get_crtc(WindowPtr window) | |||
| 210 | { | |||
| 211 | ScreenPtr screen = window->drawable.pScreen; | |||
| 212 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 213 | ||||
| 214 | if (!screen_priv) | |||
| 215 | return NULL((void*)0); | |||
| 216 | ||||
| 217 | if (!screen_priv->info) | |||
| 218 | return NULL((void*)0); | |||
| 219 | ||||
| 220 | return (*screen_priv->info->get_crtc)(window); | |||
| 221 | } | |||
| 222 | ||||
| 223 | uint32_t | |||
| 224 | present_query_capabilities(RRCrtcPtr crtc) | |||
| 225 | { | |||
| 226 | present_screen_priv_ptr screen_priv; | |||
| 227 | ||||
| 228 | if (!crtc) | |||
| 229 | return 0; | |||
| 230 | ||||
| 231 | screen_priv = present_screen_priv(crtc->pScreen); | |||
| 232 | ||||
| 233 | if (!screen_priv) | |||
| 234 | return 0; | |||
| 235 | ||||
| 236 | if (!screen_priv->info) | |||
| 237 | return 0; | |||
| 238 | ||||
| 239 | return screen_priv->info->capabilities; | |||
| 240 | } | |||
| 241 | ||||
| 242 | static int | |||
| 243 | present_get_ust_msc(ScreenPtr screen, RRCrtcPtr crtc, uint64_t *ust, uint64_t *msc) | |||
| 244 | { | |||
| 245 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 246 | ||||
| 247 | if (crtc == NULL((void*)0)) | |||
| 248 | return present_fake_get_ust_msc(screen, ust, msc); | |||
| 249 | else | |||
| 250 | return (*screen_priv->info->get_ust_msc)(crtc, ust, msc); | |||
| 251 | } | |||
| 252 | ||||
| 253 | static void | |||
| 254 | present_flush(WindowPtr window) | |||
| 255 | { | |||
| 256 | ScreenPtr screen = window->drawable.pScreen; | |||
| 257 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 258 | ||||
| 259 | if (!screen_priv) | |||
| 260 | return; | |||
| 261 | ||||
| 262 | if (!screen_priv->info) | |||
| 263 | return; | |||
| 264 | ||||
| 265 | (*screen_priv->info->flush) (window); | |||
| 266 | } | |||
| 267 | ||||
| 268 | static int | |||
| 269 | present_queue_vblank(ScreenPtr screen, | |||
| 270 | RRCrtcPtr crtc, | |||
| 271 | uint64_t event_id, | |||
| 272 | uint64_t msc) | |||
| 273 | { | |||
| 274 | Bool ret; | |||
| 275 | ||||
| 276 | if (crtc == NULL((void*)0)) | |||
| 277 | ret = present_fake_queue_vblank(screen, event_id, msc); | |||
| 278 | else | |||
| 279 | { | |||
| 280 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 281 | ret = (*screen_priv->info->queue_vblank) (crtc, event_id, msc); | |||
| 282 | } | |||
| 283 | return ret; | |||
| 284 | } | |||
| 285 | ||||
| 286 | static uint64_t | |||
| 287 | present_window_to_crtc_msc(WindowPtr window, RRCrtcPtr crtc, uint64_t window_msc, uint64_t new_msc) | |||
| 288 | { | |||
| 289 | present_window_priv_ptr window_priv = present_get_window_priv(window, TRUE1); | |||
| 290 | ||||
| 291 | if (crtc != window_priv->crtc) { | |||
| 292 | uint64_t old_ust, old_msc; | |||
| 293 | ||||
| 294 | if (window_priv->crtc == PresentCrtcNeverSet((RRCrtcPtr) 1)) { | |||
| 295 | window_priv->msc_offset = 0; | |||
| 296 | } else { | |||
| 297 | /* The old CRTC may have been turned off, in which case | |||
| 298 | * we'll just use whatever previous MSC we'd seen from this CRTC | |||
| 299 | */ | |||
| 300 | ||||
| 301 | if (present_get_ust_msc(window->drawable.pScreen, window_priv->crtc, &old_ust, &old_msc) != Success0) | |||
| 302 | old_msc = window_priv->msc; | |||
| 303 | ||||
| 304 | window_priv->msc_offset += new_msc - old_msc; | |||
| 305 | } | |||
| 306 | window_priv->crtc = crtc; | |||
| 307 | } | |||
| 308 | ||||
| 309 | return window_msc + window_priv->msc_offset; | |||
| 310 | } | |||
| 311 | ||||
| 312 | /* | |||
| 313 | * When the wait fence or previous flip is completed, it's time | |||
| 314 | * to re-try the request | |||
| 315 | */ | |||
| 316 | static void | |||
| 317 | present_re_execute(present_vblank_ptr vblank) | |||
| 318 | { | |||
| 319 | uint64_t ust = 0, crtc_msc = 0; | |||
| 320 | ||||
| 321 | if (vblank->crtc) | |||
| 322 | (void) present_get_ust_msc(vblank->screen, vblank->crtc, &ust, &crtc_msc); | |||
| 323 | ||||
| 324 | present_execute(vblank, ust, crtc_msc); | |||
| 325 | } | |||
| 326 | ||||
| 327 | static void | |||
| 328 | present_flip_try_ready(ScreenPtr screen) | |||
| 329 | { | |||
| 330 | present_vblank_ptr vblank, tmp; | |||
| 331 | ||||
| 332 | xorg_list_for_each_entry_safe(vblank, tmp, &present_exec_queue, event_queue)for (vblank = (typeof(*vblank) *)((char *)((&present_exec_queue )->next) - __builtin_offsetof(typeof(*vblank), event_queue )), tmp = (typeof(*vblank) *)((char *)(vblank->event_queue .next) - __builtin_offsetof(typeof(*vblank), event_queue)); & vblank->event_queue != (&present_exec_queue); vblank = tmp, tmp = (typeof(*tmp) *)((char *)(vblank->event_queue. next) - __builtin_offsetof(typeof(*tmp), event_queue))) { | |||
| 333 | if (vblank->flip_ready) { | |||
| 334 | present_re_execute(vblank); | |||
| 335 | return; | |||
| 336 | } | |||
| 337 | } | |||
| 338 | } | |||
| 339 | ||||
| 340 | static void | |||
| 341 | present_flip_idle(ScreenPtr screen) | |||
| 342 | { | |||
| 343 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 344 | ||||
| 345 | if (screen_priv->flip_pixmap) { | |||
| 346 | present_pixmap_idle(screen_priv->flip_pixmap, screen_priv->flip_window, | |||
| 347 | screen_priv->flip_serial, screen_priv->flip_idle_fence); | |||
| 348 | if (screen_priv->flip_idle_fence) | |||
| 349 | present_fence_destroy(screen_priv->flip_idle_fence); | |||
| 350 | dixDestroyPixmap(screen_priv->flip_pixmap, screen_priv->flip_pixmap->drawable.id); | |||
| 351 | screen_priv->flip_crtc = NULL((void*)0); | |||
| 352 | screen_priv->flip_window = NULL((void*)0); | |||
| 353 | screen_priv->flip_serial = 0; | |||
| 354 | screen_priv->flip_pixmap = NULL((void*)0); | |||
| 355 | screen_priv->flip_idle_fence = NULL((void*)0); | |||
| 356 | } | |||
| 357 | } | |||
| 358 | ||||
| 359 | struct pixmap_visit { | |||
| 360 | PixmapPtr old; | |||
| 361 | PixmapPtr new; | |||
| 362 | }; | |||
| 363 | ||||
| 364 | static int | |||
| 365 | present_set_tree_pixmap_visit(WindowPtr window, void *data) | |||
| 366 | { | |||
| 367 | struct pixmap_visit *visit = data; | |||
| 368 | ScreenPtr screen = window->drawable.pScreen; | |||
| 369 | ||||
| 370 | if ((*screen->GetWindowPixmap)(window) != visit->old) | |||
| 371 | return WT_DONTWALKCHILDREN2; | |||
| 372 | (*screen->SetWindowPixmap)(window, visit->new); | |||
| 373 | return WT_WALKCHILDREN1; | |||
| 374 | } | |||
| 375 | ||||
| 376 | static void | |||
| 377 | present_set_tree_pixmap(WindowPtr window, PixmapPtr pixmap) | |||
| 378 | { | |||
| 379 | struct pixmap_visit visit; | |||
| 380 | ScreenPtr screen = window->drawable.pScreen; | |||
| 381 | ||||
| 382 | visit.old = (*screen->GetWindowPixmap)(window); | |||
| 383 | visit.new = pixmap; | |||
| 384 | if (visit.old == visit.new) | |||
| 385 | return; | |||
| 386 | TraverseTree(window, present_set_tree_pixmap_visit, &visit); | |||
| 387 | } | |||
| 388 | ||||
| 389 | static void | |||
| 390 | present_set_abort_flip(ScreenPtr screen) | |||
| 391 | { | |||
| 392 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 393 | ||||
| 394 | /* Switch back to using the screen pixmap now to avoid | |||
| 395 | * 2D applications drawing to the wrong pixmap. | |||
| 396 | */ | |||
| 397 | ||||
| 398 | if (screen_priv->flip_window) | |||
| 399 | present_set_tree_pixmap(screen_priv->flip_window, | |||
| 400 | (*screen->GetScreenPixmap)(screen)); | |||
| 401 | ||||
| 402 | if (screen->root) | |||
| 403 | present_set_tree_pixmap(screen->root, (*screen->GetScreenPixmap)(screen)); | |||
| 404 | ||||
| 405 | screen_priv->flip_pending->abort_flip = TRUE1; | |||
| 406 | } | |||
| 407 | ||||
| 408 | static void | |||
| 409 | present_unflip(ScreenPtr screen) | |||
| 410 | { | |||
| 411 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 412 | PixmapPtr pixmap = (*screen->GetScreenPixmap)(screen); | |||
| 413 | ||||
| 414 | assert (!screen_priv->unflip_event_id)(__builtin_expect(!(!screen_priv->unflip_event_id), 0) ? __assert_rtn (__func__, "present.c", 414, "!screen_priv->unflip_event_id" ) : (void)0); | |||
| 415 | assert (!screen_priv->flip_pending)(__builtin_expect(!(!screen_priv->flip_pending), 0) ? __assert_rtn (__func__, "present.c", 415, "!screen_priv->flip_pending") : (void)0); | |||
| 416 | ||||
| 417 | if (screen_priv->flip_window) | |||
| 418 | present_set_tree_pixmap(screen_priv->flip_window, pixmap); | |||
| 419 | ||||
| 420 | present_set_tree_pixmap(screen->root, pixmap); | |||
| 421 | ||||
| 422 | /* Update the screen pixmap with the current flip pixmap contents | |||
| 423 | */ | |||
| 424 | if (screen_priv->flip_pixmap && screen_priv->flip_window) { | |||
| 425 | present_copy_region(&pixmap->drawable, | |||
| 426 | screen_priv->flip_pixmap, | |||
| 427 | NULL((void*)0), 0, 0); | |||
| 428 | } | |||
| 429 | screen_priv->unflip_event_id = ++present_event_id; | |||
| 430 | DebugPresent(("u %lld\n", screen_priv->unflip_event_id)); | |||
| 431 | (*screen_priv->info->unflip) (screen, screen_priv->unflip_event_id); | |||
| 432 | } | |||
| 433 | ||||
| 434 | static void | |||
| 435 | present_flip_notify(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc) | |||
| 436 | { | |||
| 437 | ScreenPtr screen = vblank->screen; | |||
| 438 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 439 | ||||
| 440 | DebugPresent(("\tn %lld %p %8lld: %08lx -> %08lx\n", | |||
| 441 | vblank->event_id, vblank, vblank->target_msc, | |||
| 442 | vblank->pixmap ? vblank->pixmap->drawable.id : 0, | |||
| 443 | vblank->window ? vblank->window->drawable.id : 0)); | |||
| 444 | ||||
| 445 | assert (vblank == screen_priv->flip_pending)(__builtin_expect(!(vblank == screen_priv->flip_pending), 0 ) ? __assert_rtn(__func__, "present.c", 445, "vblank == screen_priv->flip_pending" ) : (void)0); | |||
| 446 | ||||
| 447 | present_flip_idle(screen); | |||
| 448 | ||||
| 449 | xorg_list_del(&vblank->event_queue); | |||
| 450 | ||||
| 451 | /* Transfer reference for pixmap and fence from vblank to screen_priv */ | |||
| 452 | screen_priv->flip_crtc = vblank->crtc; | |||
| 453 | screen_priv->flip_window = vblank->window; | |||
| 454 | screen_priv->flip_serial = vblank->serial; | |||
| 455 | screen_priv->flip_pixmap = vblank->pixmap; | |||
| 456 | screen_priv->flip_idle_fence = vblank->idle_fence; | |||
| 457 | ||||
| 458 | vblank->pixmap = NULL((void*)0); | |||
| 459 | vblank->idle_fence = NULL((void*)0); | |||
| 460 | ||||
| 461 | screen_priv->flip_pending = NULL((void*)0); | |||
| 462 | ||||
| 463 | if (vblank->abort_flip) | |||
| 464 | present_unflip(screen); | |||
| 465 | ||||
| 466 | present_vblank_notify(vblank, PresentCompleteKindPixmap0, PresentCompleteModeFlip1, ust, crtc_msc); | |||
| 467 | present_vblank_destroy(vblank); | |||
| 468 | ||||
| 469 | present_flip_try_ready(screen); | |||
| 470 | } | |||
| 471 | ||||
| 472 | void | |||
| 473 | present_event_notify(uint64_t event_id, uint64_t ust, uint64_t msc) | |||
| 474 | { | |||
| 475 | present_vblank_ptr vblank, tmp; | |||
| 476 | int s; | |||
| 477 | ||||
| 478 | if (!event_id) | |||
| 479 | return; | |||
| 480 | DebugPresent(("\te %lld ust %lld msc %lld\n", event_id, ust, msc)); | |||
| 481 | xorg_list_for_each_entry_safe(vblank, tmp, &present_exec_queue, event_queue)for (vblank = (typeof(*vblank) *)((char *)((&present_exec_queue )->next) - __builtin_offsetof(typeof(*vblank), event_queue )), tmp = (typeof(*vblank) *)((char *)(vblank->event_queue .next) - __builtin_offsetof(typeof(*vblank), event_queue)); & vblank->event_queue != (&present_exec_queue); vblank = tmp, tmp = (typeof(*tmp) *)((char *)(vblank->event_queue. next) - __builtin_offsetof(typeof(*tmp), event_queue))) { | |||
| 482 | if (vblank->event_id == event_id) { | |||
| 483 | present_execute(vblank, ust, msc); | |||
| 484 | return; | |||
| 485 | } | |||
| 486 | } | |||
| 487 | xorg_list_for_each_entry_safe(vblank, tmp, &present_flip_queue, event_queue)for (vblank = (typeof(*vblank) *)((char *)((&present_flip_queue )->next) - __builtin_offsetof(typeof(*vblank), event_queue )), tmp = (typeof(*vblank) *)((char *)(vblank->event_queue .next) - __builtin_offsetof(typeof(*vblank), event_queue)); & vblank->event_queue != (&present_flip_queue); vblank = tmp, tmp = (typeof(*tmp) *)((char *)(vblank->event_queue. next) - __builtin_offsetof(typeof(*tmp), event_queue))) { | |||
| 488 | if (vblank->event_id == event_id) { | |||
| 489 | present_flip_notify(vblank, ust, msc); | |||
| 490 | return; | |||
| 491 | } | |||
| 492 | } | |||
| 493 | ||||
| 494 | for (s = 0; s < screenInfo.numScreens; s++) { | |||
| 495 | ScreenPtr screen = screenInfo.screens[s]; | |||
| 496 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 497 | ||||
| 498 | if (event_id == screen_priv->unflip_event_id) { | |||
| 499 | DebugPresent(("\tun %lld\n", event_id)); | |||
| 500 | screen_priv->unflip_event_id = 0; | |||
| 501 | present_flip_idle(screen); | |||
| 502 | present_flip_try_ready(screen); | |||
| 503 | return; | |||
| 504 | } | |||
| 505 | } | |||
| 506 | } | |||
| 507 | ||||
| 508 | /* | |||
| 509 | * 'window' is being reconfigured. Check to see if it is involved | |||
| 510 | * in flipping and clean up as necessary | |||
| 511 | */ | |||
| 512 | void | |||
| 513 | present_check_flip_window (WindowPtr window) | |||
| 514 | { | |||
| 515 | ScreenPtr screen = window->drawable.pScreen; | |||
| 516 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 517 | present_window_priv_ptr window_priv = present_window_priv(window); | |||
| 518 | present_vblank_ptr flip_pending = screen_priv->flip_pending; | |||
| 519 | present_vblank_ptr vblank; | |||
| 520 | ||||
| 521 | /* If this window hasn't ever been used with Present, it can't be | |||
| 522 | * flipping | |||
| 523 | */ | |||
| 524 | if (!window_priv) | |||
| 525 | return; | |||
| 526 | ||||
| 527 | if (screen_priv->unflip_event_id) | |||
| 528 | return; | |||
| 529 | ||||
| 530 | if (flip_pending) { | |||
| 531 | /* | |||
| 532 | * Check pending flip | |||
| 533 | */ | |||
| 534 | if (flip_pending->window == window) { | |||
| 535 | if (!present_check_flip(flip_pending->crtc, window, flip_pending->pixmap, | |||
| 536 | flip_pending->sync_flip, NULL((void*)0), 0, 0)) | |||
| 537 | present_set_abort_flip(screen); | |||
| 538 | } | |||
| 539 | } else { | |||
| 540 | /* | |||
| 541 | * Check current flip | |||
| 542 | */ | |||
| 543 | if (window == screen_priv->flip_window) { | |||
| 544 | if (!present_check_flip(screen_priv->flip_crtc, window, screen_priv->flip_pixmap, FALSE0, NULL((void*)0), 0, 0)) | |||
| 545 | present_unflip(screen); | |||
| 546 | } | |||
| 547 | } | |||
| 548 | ||||
| 549 | /* Now check any queued vblanks */ | |||
| 550 | xorg_list_for_each_entry(vblank, &window_priv->vblank, window_list)for (vblank = (typeof(*vblank) *)((char *)((&window_priv-> vblank)->next) - __builtin_offsetof(typeof(*vblank), window_list )); &vblank->window_list != (&window_priv->vblank ); vblank = (typeof(*vblank) *)((char *)(vblank->window_list .next) - __builtin_offsetof(typeof(*vblank), window_list))) { | |||
| 551 | if (vblank->queued && vblank->flip && !present_check_flip(vblank->crtc, window, vblank->pixmap, FALSE0, NULL((void*)0), 0, 0)) | |||
| 552 | vblank->flip = FALSE0; | |||
| 553 | } | |||
| 554 | } | |||
| 555 | ||||
| 556 | /* | |||
| 557 | * Called when the wait fence is triggered; just gets the current msc/ust and | |||
| 558 | * calls present_execute again. That will re-check the fence and pend the | |||
| 559 | * request again if it's still not actually ready | |||
| 560 | */ | |||
| 561 | static void | |||
| 562 | present_wait_fence_triggered(void *param) | |||
| 563 | { | |||
| 564 | present_vblank_ptr vblank = param; | |||
| 565 | present_re_execute(vblank); | |||
| ||||
| 566 | } | |||
| 567 | ||||
| 568 | /* | |||
| 569 | * Once the required MSC has been reached, execute the pending request. | |||
| 570 | * | |||
| 571 | * For requests to actually present something, either blt contents to | |||
| 572 | * the screen or queue a frame buffer swap. | |||
| 573 | * | |||
| 574 | * For requests to just get the current MSC/UST combo, skip that part and | |||
| 575 | * go straight to event delivery | |||
| 576 | */ | |||
| 577 | ||||
| 578 | static void | |||
| 579 | present_execute(present_vblank_ptr vblank, uint64_t ust, uint64_t crtc_msc) | |||
| 580 | { | |||
| 581 | WindowPtr window = vblank->window; | |||
| 582 | ScreenPtr screen = window->drawable.pScreen; | |||
| 583 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 584 | uint8_t mode; | |||
| 585 | ||||
| 586 | if (vblank->wait_fence) { | |||
| 587 | if (!present_fence_check_triggered(vblank->wait_fence)) { | |||
| 588 | present_fence_set_callback(vblank->wait_fence, present_wait_fence_triggered, vblank); | |||
| 589 | return; | |||
| 590 | } | |||
| 591 | } | |||
| 592 | ||||
| 593 | if (vblank->flip && vblank->pixmap && vblank->window) { | |||
| 594 | if (screen_priv->flip_pending || screen_priv->unflip_event_id) { | |||
| 595 | DebugPresent(("\tr %lld %p (pending %p unflip %lld)\n", | |||
| 596 | vblank->event_id, vblank, | |||
| 597 | screen_priv->flip_pending, screen_priv->unflip_event_id)); | |||
| 598 | vblank->flip_ready = TRUE1; | |||
| 599 | return; | |||
| 600 | } | |||
| 601 | } | |||
| 602 | ||||
| 603 | xorg_list_del(&vblank->event_queue); | |||
| 604 | xorg_list_del(&vblank->window_list); | |||
| 605 | vblank->queued = FALSE0; | |||
| 606 | ||||
| 607 | if (vblank->pixmap && vblank->window) { | |||
| 608 | ||||
| 609 | if (vblank->flip) { | |||
| 610 | ||||
| 611 | DebugPresent(("\tf %lld %p %8lld: %08lx -> %08lx\n", | |||
| 612 | vblank->event_id, vblank, crtc_msc, | |||
| 613 | vblank->pixmap->drawable.id, vblank->window->drawable.id)); | |||
| 614 | ||||
| 615 | /* Prepare to flip by placing it in the flip queue and | |||
| 616 | * and sticking it into the flip_pending field | |||
| 617 | */ | |||
| 618 | screen_priv->flip_pending = vblank; | |||
| 619 | ||||
| 620 | xorg_list_add(&vblank->event_queue, &present_flip_queue); | |||
| 621 | /* Try to flip | |||
| 622 | */ | |||
| 623 | if (present_flip(vblank->crtc, vblank->event_id, vblank->target_msc, vblank->pixmap, vblank->sync_flip)) { | |||
| 624 | RegionPtr damage; | |||
| 625 | ||||
| 626 | /* Fix window pixmaps: | |||
| 627 | * 1) Restore previous flip window pixmap | |||
| 628 | * 2) Set current flip window pixmap to the new pixmap | |||
| 629 | */ | |||
| 630 | if (screen_priv->flip_window && screen_priv->flip_window != window) | |||
| 631 | present_set_tree_pixmap(screen_priv->flip_window, | |||
| 632 | (*screen->GetScreenPixmap)(screen)); | |||
| 633 | present_set_tree_pixmap(vblank->window, vblank->pixmap); | |||
| 634 | present_set_tree_pixmap(screen->root, vblank->pixmap); | |||
| 635 | ||||
| 636 | /* Report update region as damaged | |||
| 637 | */ | |||
| 638 | if (vblank->update) { | |||
| 639 | damage = vblank->update; | |||
| 640 | RegionIntersect(damage, damage, &window->clipList); | |||
| 641 | } else | |||
| 642 | damage = &window->clipList; | |||
| 643 | ||||
| 644 | DamageDamageRegion(&vblank->window->drawable, damage); | |||
| 645 | return; | |||
| 646 | } | |||
| 647 | ||||
| 648 | xorg_list_del(&vblank->event_queue); | |||
| 649 | /* Oops, flip failed. Clear the flip_pending field | |||
| 650 | */ | |||
| 651 | screen_priv->flip_pending = NULL((void*)0); | |||
| 652 | vblank->flip = FALSE0; | |||
| 653 | } | |||
| 654 | DebugPresent(("\tc %p %8lld: %08lx -> %08lx\n", vblank, crtc_msc, vblank->pixmap->drawable.id, vblank->window->drawable.id)); | |||
| 655 | if (screen_priv->flip_pending) { | |||
| 656 | ||||
| 657 | /* Check pending flip | |||
| 658 | */ | |||
| 659 | if (window == screen_priv->flip_pending->window) | |||
| 660 | present_set_abort_flip(screen); | |||
| 661 | } else if (!screen_priv->unflip_event_id) { | |||
| 662 | ||||
| 663 | /* Check current flip | |||
| 664 | */ | |||
| 665 | if (window == screen_priv->flip_window) | |||
| 666 | present_unflip(screen); | |||
| 667 | } | |||
| 668 | present_copy_region(&window->drawable, vblank->pixmap, vblank->update, vblank->x_off, vblank->y_off); | |||
| 669 | ||||
| 670 | /* present_copy_region sticks the region into a scratch GC, | |||
| 671 | * which is then freed, freeing the region | |||
| 672 | */ | |||
| 673 | vblank->update = NULL((void*)0); | |||
| 674 | present_flush(window); | |||
| 675 | ||||
| 676 | present_pixmap_idle(vblank->pixmap, vblank->window, vblank->serial, vblank->idle_fence); | |||
| 677 | } | |||
| 678 | ||||
| 679 | /* Compute correct CompleteMode | |||
| 680 | */ | |||
| 681 | if (vblank->kind == PresentCompleteKindPixmap0) { | |||
| 682 | if (vblank->pixmap && vblank->window) | |||
| 683 | mode = PresentCompleteModeCopy0; | |||
| 684 | else | |||
| 685 | mode = PresentCompleteModeSkip2; | |||
| 686 | } | |||
| 687 | else | |||
| 688 | mode = PresentCompleteModeCopy0; | |||
| 689 | ||||
| 690 | ||||
| 691 | present_vblank_notify(vblank, vblank->kind, mode, ust, crtc_msc); | |||
| 692 | present_vblank_destroy(vblank); | |||
| 693 | } | |||
| 694 | ||||
| 695 | int | |||
| 696 | present_pixmap(WindowPtr window, | |||
| 697 | PixmapPtr pixmap, | |||
| 698 | CARD32 serial, | |||
| 699 | RegionPtr valid, | |||
| 700 | RegionPtr update, | |||
| 701 | int16_t x_off, | |||
| 702 | int16_t y_off, | |||
| 703 | RRCrtcPtr target_crtc, | |||
| 704 | SyncFence *wait_fence, | |||
| 705 | SyncFence *idle_fence, | |||
| 706 | uint32_t options, | |||
| 707 | uint64_t window_msc, | |||
| 708 | uint64_t divisor, | |||
| 709 | uint64_t remainder, | |||
| 710 | present_notify_ptr notifies, | |||
| 711 | int num_notifies) | |||
| 712 | { | |||
| 713 | uint64_t ust = 0; | |||
| 714 | uint64_t target_msc; | |||
| 715 | uint64_t crtc_msc = 0; | |||
| 716 | int ret; | |||
| 717 | present_vblank_ptr vblank, tmp; | |||
| 718 | ScreenPtr screen = window->drawable.pScreen; | |||
| 719 | present_window_priv_ptr window_priv = present_get_window_priv(window, TRUE1); | |||
| 720 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 721 | ||||
| 722 | if (!window_priv) | |||
| 723 | return BadAlloc11; | |||
| 724 | ||||
| 725 | if (!screen_priv || !screen_priv->info) | |||
| 726 | target_crtc = NULL((void*)0); | |||
| 727 | else if (!target_crtc) { | |||
| 728 | /* Update the CRTC if we have a pixmap or we don't have a CRTC | |||
| 729 | */ | |||
| 730 | if (!pixmap) | |||
| 731 | target_crtc = window_priv->crtc; | |||
| 732 | ||||
| 733 | if (!target_crtc || target_crtc == PresentCrtcNeverSet((RRCrtcPtr) 1)) | |||
| 734 | target_crtc = present_get_crtc(window); | |||
| 735 | } | |||
| 736 | ||||
| 737 | ret = present_get_ust_msc(screen, target_crtc, &ust, &crtc_msc); | |||
| 738 | ||||
| 739 | target_msc = present_window_to_crtc_msc(window, target_crtc, window_msc, crtc_msc); | |||
| 740 | ||||
| 741 | if (ret == Success0) { | |||
| 742 | /* Stash the current MSC away in case we need it later | |||
| 743 | */ | |||
| 744 | window_priv->msc = crtc_msc; | |||
| 745 | } | |||
| 746 | ||||
| 747 | /* Adjust target_msc to match modulus | |||
| 748 | */ | |||
| 749 | if (crtc_msc >= target_msc) { | |||
| 750 | if (divisor != 0) { | |||
| 751 | target_msc = crtc_msc - (crtc_msc % divisor) + remainder; | |||
| 752 | if (options & PresentOptionAsync(1 << 0)) { | |||
| 753 | if (target_msc < crtc_msc) | |||
| 754 | target_msc += divisor; | |||
| 755 | } else { | |||
| 756 | if (target_msc <= crtc_msc) | |||
| 757 | target_msc += divisor; | |||
| 758 | } | |||
| 759 | } else { | |||
| 760 | target_msc = crtc_msc; | |||
| 761 | if (!(options & PresentOptionAsync(1 << 0))) | |||
| 762 | target_msc++; | |||
| 763 | } | |||
| 764 | } | |||
| 765 | ||||
| 766 | /* | |||
| 767 | * Look for a matching presentation already on the list and | |||
| 768 | * don't bother doing the previous one if this one will overwrite it | |||
| 769 | * in the same frame | |||
| 770 | */ | |||
| 771 | ||||
| 772 | if (!update && pixmap) { | |||
| 773 | xorg_list_for_each_entry_safe(vblank, tmp, &window_priv->vblank, window_list)for (vblank = (typeof(*vblank) *)((char *)((&window_priv-> vblank)->next) - __builtin_offsetof(typeof(*vblank), window_list )), tmp = (typeof(*vblank) *)((char *)(vblank->window_list .next) - __builtin_offsetof(typeof(*vblank), window_list)); & vblank->window_list != (&window_priv->vblank); vblank = tmp, tmp = (typeof(*tmp) *)((char *)(vblank->window_list .next) - __builtin_offsetof(typeof(*tmp), window_list))) { | |||
| 774 | ||||
| 775 | if (!vblank->pixmap) | |||
| 776 | continue; | |||
| 777 | ||||
| 778 | if (!vblank->queued) | |||
| 779 | continue; | |||
| 780 | ||||
| 781 | if (vblank->crtc != target_crtc || vblank->target_msc != target_msc) | |||
| 782 | continue; | |||
| 783 | ||||
| 784 | DebugPresent(("\tx %lld %p %8lld: %08lx -> %08lx (crtc %p)\n", | |||
| 785 | vblank->event_id, vblank, vblank->target_msc, | |||
| 786 | vblank->pixmap->drawable.id, vblank->window->drawable.id, | |||
| 787 | vblank->crtc)); | |||
| 788 | ||||
| 789 | present_pixmap_idle(vblank->pixmap, vblank->window, vblank->serial, vblank->idle_fence); | |||
| 790 | present_fence_destroy(vblank->idle_fence); | |||
| 791 | dixDestroyPixmap(vblank->pixmap, vblank->pixmap->drawable.id); | |||
| 792 | ||||
| 793 | vblank->pixmap = NULL((void*)0); | |||
| 794 | vblank->idle_fence = NULL((void*)0); | |||
| 795 | vblank->flip = FALSE0; | |||
| 796 | if (vblank->flip_ready) | |||
| 797 | present_re_execute(vblank); | |||
| 798 | } | |||
| 799 | } | |||
| 800 | ||||
| 801 | vblank = calloc (1, sizeof (present_vblank_rec)); | |||
| 802 | if (!vblank) | |||
| 803 | return BadAlloc11; | |||
| 804 | ||||
| 805 | xorg_list_append(&vblank->window_list, &window_priv->vblank); | |||
| 806 | xorg_list_init(&vblank->event_queue); | |||
| 807 | ||||
| 808 | vblank->screen = screen; | |||
| 809 | vblank->window = window; | |||
| 810 | vblank->pixmap = pixmap; | |||
| 811 | vblank->event_id = ++present_event_id; | |||
| 812 | if (pixmap) { | |||
| 813 | vblank->kind = PresentCompleteKindPixmap0; | |||
| 814 | pixmap->refcnt++; | |||
| 815 | } else | |||
| 816 | vblank->kind = PresentCompleteKindNotifyMSC1; | |||
| 817 | ||||
| 818 | vblank->serial = serial; | |||
| 819 | ||||
| 820 | if (valid) { | |||
| 821 | vblank->valid = RegionDuplicate(valid); | |||
| 822 | if (!vblank->valid) | |||
| 823 | goto no_mem; | |||
| 824 | } | |||
| 825 | if (update) { | |||
| 826 | vblank->update = RegionDuplicate(update); | |||
| 827 | if (!vblank->update) | |||
| 828 | goto no_mem; | |||
| 829 | } | |||
| 830 | ||||
| 831 | vblank->x_off = x_off; | |||
| 832 | vblank->y_off = y_off; | |||
| 833 | vblank->target_msc = target_msc; | |||
| 834 | vblank->crtc = target_crtc; | |||
| 835 | vblank->msc_offset = window_priv->msc_offset; | |||
| 836 | vblank->notifies = notifies; | |||
| 837 | vblank->num_notifies = num_notifies; | |||
| 838 | ||||
| 839 | if (!(options & PresentOptionAsync(1 << 0))) | |||
| 840 | vblank->sync_flip = TRUE1; | |||
| 841 | ||||
| 842 | if (!(options & PresentOptionCopy(1 << 1)) && | |||
| 843 | !((options & PresentOptionAsync(1 << 0)) && | |||
| 844 | (!screen_priv->info || | |||
| 845 | !(screen_priv->info->capabilities & PresentCapabilityAsync1))) && | |||
| 846 | pixmap != NULL((void*)0) && | |||
| 847 | present_check_flip (target_crtc, window, pixmap, vblank->sync_flip, valid, x_off, y_off)) | |||
| 848 | { | |||
| 849 | vblank->flip = TRUE1; | |||
| 850 | if (vblank->sync_flip) | |||
| 851 | target_msc--; | |||
| 852 | } | |||
| 853 | ||||
| 854 | if (wait_fence) { | |||
| 855 | vblank->wait_fence = present_fence_create(wait_fence); | |||
| 856 | if (!vblank->wait_fence) | |||
| 857 | goto no_mem; | |||
| 858 | } | |||
| 859 | ||||
| 860 | if (idle_fence) { | |||
| 861 | vblank->idle_fence = present_fence_create(idle_fence); | |||
| 862 | if (!vblank->idle_fence) | |||
| 863 | goto no_mem; | |||
| 864 | } | |||
| 865 | ||||
| 866 | if (pixmap) | |||
| 867 | DebugPresent(("q %lld %p %8lld: %08lx -> %08lx (crtc %p) flip %d vsync %d serial %d\n", | |||
| 868 | vblank->event_id, vblank, target_msc, | |||
| 869 | vblank->pixmap->drawable.id, vblank->window->drawable.id, | |||
| 870 | target_crtc, vblank->flip, vblank->sync_flip, vblank->serial)); | |||
| 871 | ||||
| 872 | xorg_list_add(&vblank->event_queue, &present_exec_queue); | |||
| 873 | vblank->queued = TRUE1; | |||
| 874 | if ((pixmap && target_msc >= crtc_msc) || (!pixmap && target_msc > crtc_msc)) { | |||
| 875 | ret = present_queue_vblank(screen, target_crtc, vblank->event_id, target_msc); | |||
| 876 | if (ret == Success0) | |||
| 877 | return Success0; | |||
| 878 | ||||
| 879 | DebugPresent(("present_queue_vblank failed\n")); | |||
| 880 | } | |||
| 881 | ||||
| 882 | present_execute(vblank, ust, crtc_msc); | |||
| 883 | ||||
| 884 | return Success0; | |||
| 885 | ||||
| 886 | no_mem: | |||
| 887 | ret = BadAlloc11; | |||
| 888 | vblank->notifies = NULL((void*)0); | |||
| 889 | present_vblank_destroy(vblank); | |||
| 890 | return ret; | |||
| 891 | } | |||
| 892 | ||||
| 893 | void | |||
| 894 | present_abort_vblank(ScreenPtr screen, RRCrtcPtr crtc, uint64_t event_id, uint64_t msc) | |||
| 895 | { | |||
| 896 | present_vblank_ptr vblank, tmp; | |||
| 897 | ||||
| 898 | if (crtc == NULL((void*)0)) | |||
| 899 | present_fake_abort_vblank(screen, event_id, msc); | |||
| 900 | else | |||
| 901 | { | |||
| 902 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 903 | ||||
| 904 | (*screen_priv->info->abort_vblank) (crtc, event_id, msc); | |||
| 905 | } | |||
| 906 | ||||
| 907 | xorg_list_for_each_entry_safe(vblank, tmp, &present_exec_queue, event_queue)for (vblank = (typeof(*vblank) *)((char *)((&present_exec_queue )->next) - __builtin_offsetof(typeof(*vblank), event_queue )), tmp = (typeof(*vblank) *)((char *)(vblank->event_queue .next) - __builtin_offsetof(typeof(*vblank), event_queue)); & vblank->event_queue != (&present_exec_queue); vblank = tmp, tmp = (typeof(*tmp) *)((char *)(vblank->event_queue. next) - __builtin_offsetof(typeof(*tmp), event_queue))) { | |||
| 908 | if (vblank->event_id == event_id) { | |||
| 909 | xorg_list_del(&vblank->event_queue); | |||
| 910 | vblank->queued = FALSE0; | |||
| 911 | return; | |||
| 912 | } | |||
| 913 | } | |||
| 914 | xorg_list_for_each_entry_safe(vblank, tmp, &present_flip_queue, event_queue)for (vblank = (typeof(*vblank) *)((char *)((&present_flip_queue )->next) - __builtin_offsetof(typeof(*vblank), event_queue )), tmp = (typeof(*vblank) *)((char *)(vblank->event_queue .next) - __builtin_offsetof(typeof(*vblank), event_queue)); & vblank->event_queue != (&present_flip_queue); vblank = tmp, tmp = (typeof(*tmp) *)((char *)(vblank->event_queue. next) - __builtin_offsetof(typeof(*tmp), event_queue))) { | |||
| 915 | if (vblank->event_id == event_id) { | |||
| 916 | xorg_list_del(&vblank->event_queue); | |||
| 917 | return; | |||
| 918 | } | |||
| 919 | } | |||
| 920 | } | |||
| 921 | ||||
| 922 | int | |||
| 923 | present_notify_msc(WindowPtr window, | |||
| 924 | CARD32 serial, | |||
| 925 | uint64_t target_msc, | |||
| 926 | uint64_t divisor, | |||
| 927 | uint64_t remainder) | |||
| 928 | { | |||
| 929 | return present_pixmap(window, | |||
| 930 | NULL((void*)0), | |||
| 931 | serial, | |||
| 932 | NULL((void*)0), NULL((void*)0), | |||
| 933 | 0, 0, | |||
| 934 | NULL((void*)0), | |||
| 935 | NULL((void*)0), NULL((void*)0), | |||
| 936 | divisor == 0 ? PresentOptionAsync(1 << 0) : 0, | |||
| 937 | target_msc, divisor, remainder, NULL((void*)0), 0); | |||
| 938 | } | |||
| 939 | ||||
| 940 | void | |||
| 941 | present_flip_destroy(ScreenPtr screen) | |||
| 942 | { | |||
| 943 | present_screen_priv_ptr screen_priv = present_screen_priv(screen); | |||
| 944 | ||||
| 945 | /* Reset window pixmaps back to the screen pixmap */ | |||
| 946 | if (screen_priv->flip_pending) | |||
| 947 | present_set_abort_flip(screen); | |||
| 948 | ||||
| 949 | /* Drop reference to any pending flip or unflip pixmaps. */ | |||
| 950 | present_flip_idle(screen); | |||
| 951 | } | |||
| 952 | ||||
| 953 | void | |||
| 954 | present_vblank_destroy(present_vblank_ptr vblank) | |||
| 955 | { | |||
| 956 | /* Remove vblank from window and screen lists */ | |||
| 957 | xorg_list_del(&vblank->window_list); | |||
| 958 | ||||
| 959 | DebugPresent(("\td %lld %p %8lld: %08lx -> %08lx\n", | |||
| 960 | vblank->event_id, vblank, vblank->target_msc, | |||
| 961 | vblank->pixmap ? vblank->pixmap->drawable.id : 0, | |||
| 962 | vblank->window ? vblank->window->drawable.id : 0)); | |||
| 963 | ||||
| 964 | /* Drop pixmap reference */ | |||
| 965 | if (vblank->pixmap) | |||
| 966 | dixDestroyPixmap(vblank->pixmap, vblank->pixmap->drawable.id); | |||
| 967 | ||||
| 968 | /* Free regions */ | |||
| 969 | if (vblank->valid) | |||
| 970 | RegionDestroy(vblank->valid); | |||
| 971 | if (vblank->update) | |||
| 972 | RegionDestroy(vblank->update); | |||
| 973 | ||||
| 974 | if (vblank->wait_fence) | |||
| 975 | present_fence_destroy(vblank->wait_fence); | |||
| 976 | ||||
| 977 | if (vblank->idle_fence) | |||
| 978 | present_fence_destroy(vblank->idle_fence); | |||
| 979 | ||||
| 980 | if (vblank->notifies) | |||
| 981 | present_destroy_notifies(vblank->notifies, vblank->num_notifies); | |||
| 982 | ||||
| 983 | free(vblank); | |||
| 984 | } | |||
| 985 | ||||
| 986 | Bool | |||
| 987 | present_init(void) | |||
| 988 | { | |||
| 989 | xorg_list_init(&present_exec_queue); | |||
| 990 | xorg_list_init(&present_flip_queue); | |||
| 991 | present_fake_queue_init(); | |||
| 992 | return TRUE1; | |||
| 993 | } |