• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  * Author: Keith Whitwell <keithw@vmware.com>
29  * Author: Jakob Bornecrantz <wallbraker@gmail.com>
30  */
31 
32 #include "dri_screen.h"
33 #include "dri_context.h"
34 #include "dri_drawable.h"
35 
36 #include "pipe/p_screen.h"
37 #include "util/u_format.h"
38 #include "util/u_memory.h"
39 #include "util/u_inlines.h"
40 
41 static uint32_t drifb_ID = 0;
42 
43 static void
44 swap_fences_unref(struct dri_drawable *draw);
45 
46 static boolean
dri_st_framebuffer_validate(struct st_context_iface * stctx,struct st_framebuffer_iface * stfbi,const enum st_attachment_type * statts,unsigned count,struct pipe_resource ** out)47 dri_st_framebuffer_validate(struct st_context_iface *stctx,
48                             struct st_framebuffer_iface *stfbi,
49                             const enum st_attachment_type *statts,
50                             unsigned count,
51                             struct pipe_resource **out)
52 {
53    struct dri_context *ctx = (struct dri_context *)stctx->st_manager_private;
54    struct dri_drawable *drawable =
55       (struct dri_drawable *) stfbi->st_manager_private;
56    struct dri_screen *screen = dri_screen(drawable->sPriv);
57    unsigned statt_mask, new_mask;
58    boolean new_stamp;
59    int i;
60    unsigned int lastStamp;
61    struct pipe_resource **textures =
62       drawable->stvis.samples > 1 ? drawable->msaa_textures
63                                   : drawable->textures;
64 
65    statt_mask = 0x0;
66    for (i = 0; i < count; i++)
67       statt_mask |= (1 << statts[i]);
68 
69    /* record newly allocated textures */
70    new_mask = (statt_mask & ~drawable->texture_mask);
71 
72    /*
73     * dPriv->dri2.stamp is the server stamp.  dPriv->lastStamp is the
74     * client stamp.  It has the value of the server stamp when last
75     * checked.
76     */
77    do {
78       lastStamp = drawable->dPriv->lastStamp;
79       new_stamp = (drawable->texture_stamp != lastStamp);
80 
81       if (new_stamp || new_mask || screen->broken_invalidate) {
82          if (new_stamp && drawable->update_drawable_info)
83             drawable->update_drawable_info(drawable);
84 
85          drawable->allocate_textures(ctx, drawable, statts, count);
86 
87          /* add existing textures */
88          for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
89             if (textures[i])
90                statt_mask |= (1 << i);
91          }
92 
93          drawable->texture_stamp = lastStamp;
94          drawable->texture_mask = statt_mask;
95       }
96    } while (lastStamp != drawable->dPriv->lastStamp);
97 
98    if (!out)
99       return TRUE;
100 
101    /* Set the window-system buffers for the state tracker. */
102    for (i = 0; i < count; i++)
103       pipe_resource_reference(&out[i], textures[statts[i]]);
104 
105    return TRUE;
106 }
107 
108 static boolean
dri_st_framebuffer_flush_front(struct st_context_iface * stctx,struct st_framebuffer_iface * stfbi,enum st_attachment_type statt)109 dri_st_framebuffer_flush_front(struct st_context_iface *stctx,
110                                struct st_framebuffer_iface *stfbi,
111                                enum st_attachment_type statt)
112 {
113    struct dri_context *ctx = (struct dri_context *)stctx->st_manager_private;
114    struct dri_drawable *drawable =
115       (struct dri_drawable *) stfbi->st_manager_private;
116 
117    /* XXX remove this and just set the correct one on the framebuffer */
118    drawable->flush_frontbuffer(ctx, drawable, statt);
119 
120    return TRUE;
121 }
122 
123 /**
124  * The state tracker framebuffer interface flush_swapbuffers callback
125  */
126 static boolean
dri_st_framebuffer_flush_swapbuffers(struct st_context_iface * stctx,struct st_framebuffer_iface * stfbi)127 dri_st_framebuffer_flush_swapbuffers(struct st_context_iface *stctx,
128                                      struct st_framebuffer_iface *stfbi)
129 {
130    struct dri_context *ctx = (struct dri_context *)stctx->st_manager_private;
131    struct dri_drawable *drawable =
132       (struct dri_drawable *) stfbi->st_manager_private;
133 
134    if (drawable->flush_swapbuffers)
135       drawable->flush_swapbuffers(ctx, drawable);
136 
137    return TRUE;
138 }
139 
140 /**
141  * This is called when we need to set up GL rendering to a new X window.
142  */
143 boolean
dri_create_buffer(__DRIscreen * sPriv,__DRIdrawable * dPriv,const struct gl_config * visual,boolean isPixmap)144 dri_create_buffer(__DRIscreen * sPriv,
145 		  __DRIdrawable * dPriv,
146 		  const struct gl_config * visual, boolean isPixmap)
147 {
148    struct dri_screen *screen = sPriv->driverPrivate;
149    struct dri_drawable *drawable = NULL;
150 
151    if (isPixmap)
152       goto fail;		       /* not implemented */
153 
154    drawable = CALLOC_STRUCT(dri_drawable);
155    if (drawable == NULL)
156       goto fail;
157 
158    dri_fill_st_visual(&drawable->stvis, screen, visual);
159 
160    /* setup the st_framebuffer_iface */
161    drawable->base.visual = &drawable->stvis;
162    drawable->base.flush_front = dri_st_framebuffer_flush_front;
163    drawable->base.validate = dri_st_framebuffer_validate;
164    drawable->base.flush_swapbuffers = dri_st_framebuffer_flush_swapbuffers;
165    drawable->base.st_manager_private = (void *) drawable;
166 
167    drawable->screen = screen;
168    drawable->sPriv = sPriv;
169    drawable->dPriv = dPriv;
170    drawable->desired_fences = screen->default_throttle_frames;
171    if (drawable->desired_fences > DRI_SWAP_FENCES_MAX)
172       drawable->desired_fences = DRI_SWAP_FENCES_MAX;
173 
174    dPriv->driverPrivate = (void *)drawable;
175    p_atomic_set(&drawable->base.stamp, 1);
176    drawable->base.ID = p_atomic_inc_return(&drifb_ID);
177    drawable->base.state_manager = &screen->base;
178 
179    return GL_TRUE;
180 fail:
181    FREE(drawable);
182    return GL_FALSE;
183 }
184 
185 void
dri_destroy_buffer(__DRIdrawable * dPriv)186 dri_destroy_buffer(__DRIdrawable * dPriv)
187 {
188    struct dri_drawable *drawable = dri_drawable(dPriv);
189    struct dri_screen *screen = drawable->screen;
190    struct st_api *stapi = screen->st_api;
191    int i;
192 
193    pipe_surface_reference(&drawable->drisw_surface, NULL);
194 
195    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
196       pipe_resource_reference(&drawable->textures[i], NULL);
197    for (i = 0; i < ST_ATTACHMENT_COUNT; i++)
198       pipe_resource_reference(&drawable->msaa_textures[i], NULL);
199 
200    swap_fences_unref(drawable);
201 
202    /* Notify the st manager that this drawable is no longer valid */
203    stapi->destroy_drawable(stapi, &drawable->base);
204 
205    FREE(drawable);
206 }
207 
208 /**
209  * Validate the texture at an attachment.  Allocate the texture if it does not
210  * exist.  Used by the TFP extension.
211  */
212 static void
dri_drawable_validate_att(struct dri_context * ctx,struct dri_drawable * drawable,enum st_attachment_type statt)213 dri_drawable_validate_att(struct dri_context *ctx,
214                           struct dri_drawable *drawable,
215                           enum st_attachment_type statt)
216 {
217    enum st_attachment_type statts[ST_ATTACHMENT_COUNT];
218    unsigned i, count = 0;
219 
220    /* check if buffer already exists */
221    if (drawable->texture_mask & (1 << statt))
222       return;
223 
224    /* make sure DRI2 does not destroy existing buffers */
225    for (i = 0; i < ST_ATTACHMENT_COUNT; i++) {
226       if (drawable->texture_mask & (1 << i)) {
227          statts[count++] = i;
228       }
229    }
230    statts[count++] = statt;
231 
232    drawable->texture_stamp = drawable->dPriv->lastStamp - 1;
233 
234    drawable->base.validate(ctx->st, &drawable->base, statts, count, NULL);
235 }
236 
237 /**
238  * These are used for GLX_EXT_texture_from_pixmap
239  */
240 static void
dri_set_tex_buffer2(__DRIcontext * pDRICtx,GLint target,GLint format,__DRIdrawable * dPriv)241 dri_set_tex_buffer2(__DRIcontext *pDRICtx, GLint target,
242                     GLint format, __DRIdrawable *dPriv)
243 {
244    struct dri_context *ctx = dri_context(pDRICtx);
245    struct st_context_iface *st = ctx->st;
246    struct dri_drawable *drawable = dri_drawable(dPriv);
247    struct pipe_resource *pt;
248 
249    if (st->thread_finish)
250       st->thread_finish(st);
251 
252    dri_drawable_validate_att(ctx, drawable, ST_ATTACHMENT_FRONT_LEFT);
253 
254    /* Use the pipe resource associated with the X drawable */
255    pt = drawable->textures[ST_ATTACHMENT_FRONT_LEFT];
256 
257    if (pt) {
258       enum pipe_format internal_format = pt->format;
259 
260       if (format == __DRI_TEXTURE_FORMAT_RGB)  {
261          /* only need to cover the formats recognized by dri_fill_st_visual */
262          switch (internal_format) {
263          case PIPE_FORMAT_B10G10R10A2_UNORM:
264             internal_format = PIPE_FORMAT_B10G10R10X2_UNORM;
265             break;
266          case PIPE_FORMAT_BGRA8888_UNORM:
267             internal_format = PIPE_FORMAT_BGRX8888_UNORM;
268             break;
269          case PIPE_FORMAT_ARGB8888_UNORM:
270             internal_format = PIPE_FORMAT_XRGB8888_UNORM;
271             break;
272          default:
273             break;
274          }
275       }
276 
277       drawable->update_tex_buffer(drawable, ctx, pt);
278 
279       ctx->st->teximage(ctx->st,
280             (target == GL_TEXTURE_2D) ? ST_TEXTURE_2D : ST_TEXTURE_RECT,
281             0, internal_format, pt, FALSE);
282    }
283 }
284 
285 static void
dri_set_tex_buffer(__DRIcontext * pDRICtx,GLint target,__DRIdrawable * dPriv)286 dri_set_tex_buffer(__DRIcontext *pDRICtx, GLint target,
287                    __DRIdrawable *dPriv)
288 {
289    dri_set_tex_buffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv);
290 }
291 
292 const __DRItexBufferExtension driTexBufferExtension = {
293    .base = { __DRI_TEX_BUFFER, 2 },
294 
295    .setTexBuffer       = dri_set_tex_buffer,
296    .setTexBuffer2      = dri_set_tex_buffer2,
297    .releaseTexBuffer   = NULL,
298 };
299 
300 /**
301  * Get the format and binding of an attachment.
302  */
303 void
dri_drawable_get_format(struct dri_drawable * drawable,enum st_attachment_type statt,enum pipe_format * format,unsigned * bind)304 dri_drawable_get_format(struct dri_drawable *drawable,
305                         enum st_attachment_type statt,
306                         enum pipe_format *format,
307                         unsigned *bind)
308 {
309    switch (statt) {
310    case ST_ATTACHMENT_FRONT_LEFT:
311    case ST_ATTACHMENT_BACK_LEFT:
312    case ST_ATTACHMENT_FRONT_RIGHT:
313    case ST_ATTACHMENT_BACK_RIGHT:
314       /* Other pieces of the driver stack get confused and behave incorrectly
315        * when they get an sRGB drawable. st/mesa receives "drawable->stvis"
316        * though other means and handles it correctly, so we don't really need
317        * to use an sRGB format here.
318        */
319       *format = util_format_linear(drawable->stvis.color_format);
320       *bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW;
321       break;
322    case ST_ATTACHMENT_DEPTH_STENCIL:
323       *format = drawable->stvis.depth_stencil_format;
324       *bind = PIPE_BIND_DEPTH_STENCIL; /* XXX sampler? */
325       break;
326    default:
327       *format = PIPE_FORMAT_NONE;
328       *bind = 0;
329       break;
330    }
331 }
332 
333 
334 /**
335  * swap_fences_pop_front - pull a fence from the throttle queue
336  *
337  * If the throttle queue is filled to the desired number of fences,
338  * pull fences off the queue until the number is less than the desired
339  * number of fences, and return the last fence pulled.
340  */
341 static struct pipe_fence_handle *
swap_fences_pop_front(struct dri_drawable * draw)342 swap_fences_pop_front(struct dri_drawable *draw)
343 {
344    struct pipe_screen *screen = draw->screen->base.screen;
345    struct pipe_fence_handle *fence = NULL;
346 
347    if (draw->desired_fences == 0)
348       return NULL;
349 
350    if (draw->cur_fences >= draw->desired_fences) {
351       screen->fence_reference(screen, &fence, draw->swap_fences[draw->tail]);
352       screen->fence_reference(screen, &draw->swap_fences[draw->tail++], NULL);
353       draw->tail &= DRI_SWAP_FENCES_MASK;
354       --draw->cur_fences;
355    }
356    return fence;
357 }
358 
359 
360 /**
361  * swap_fences_push_back - push a fence onto the throttle queue
362  *
363  * push a fence onto the throttle queue and pull fences of the queue
364  * so that the desired number of fences are on the queue.
365  */
366 static void
swap_fences_push_back(struct dri_drawable * draw,struct pipe_fence_handle * fence)367 swap_fences_push_back(struct dri_drawable *draw,
368 		      struct pipe_fence_handle *fence)
369 {
370    struct pipe_screen *screen = draw->screen->base.screen;
371 
372    if (!fence || draw->desired_fences == 0)
373       return;
374 
375    while(draw->cur_fences == draw->desired_fences)
376       swap_fences_pop_front(draw);
377 
378    draw->cur_fences++;
379    screen->fence_reference(screen, &draw->swap_fences[draw->head++],
380 			   fence);
381    draw->head &= DRI_SWAP_FENCES_MASK;
382 }
383 
384 
385 /**
386  * swap_fences_unref - empty the throttle queue
387  *
388  * pulls fences of the throttle queue until it is empty.
389  */
390 static void
swap_fences_unref(struct dri_drawable * draw)391 swap_fences_unref(struct dri_drawable *draw)
392 {
393    struct pipe_screen *screen = draw->screen->base.screen;
394 
395    while(draw->cur_fences) {
396       screen->fence_reference(screen, &draw->swap_fences[draw->tail++], NULL);
397       draw->tail &= DRI_SWAP_FENCES_MASK;
398       --draw->cur_fences;
399    }
400 }
401 
402 void
dri_pipe_blit(struct pipe_context * pipe,struct pipe_resource * dst,struct pipe_resource * src)403 dri_pipe_blit(struct pipe_context *pipe,
404               struct pipe_resource *dst,
405               struct pipe_resource *src)
406 {
407    struct pipe_blit_info blit;
408 
409    if (!dst || !src)
410       return;
411 
412    /* From the GL spec, version 4.2, section 4.1.11 (Additional Multisample
413     *  Fragment Operations):
414     *
415     *      If a framebuffer object is not bound, after all operations have
416     *      been completed on the multisample buffer, the sample values for
417     *      each color in the multisample buffer are combined to produce a
418     *      single color value, and that value is written into the
419     *      corresponding color buffers selected by DrawBuffer or
420     *      DrawBuffers. An implementation may defer the writing of the color
421     *      buffers until a later time, but the state of the framebuffer must
422     *      behave as if the color buffers were updated as each fragment was
423     *      processed. The method of combination is not specified. If the
424     *      framebuffer contains sRGB values, then it is recommended that the
425     *      an average of sample values is computed in a linearized space, as
426     *      for blending (see section 4.1.7).
427     *
428     * In other words, to do a resolve operation in a linear space, we have
429     * to set sRGB formats if the original resources were sRGB, so don't use
430     * util_format_linear.
431     */
432 
433    memset(&blit, 0, sizeof(blit));
434    blit.dst.resource = dst;
435    blit.dst.box.width = dst->width0;
436    blit.dst.box.height = dst->height0;
437    blit.dst.box.depth = 1;
438    blit.dst.format = dst->format;
439    blit.src.resource = src;
440    blit.src.box.width = src->width0;
441    blit.src.box.height = src->height0;
442    blit.src.box.depth = 1;
443    blit.src.format = src->format;
444    blit.mask = PIPE_MASK_RGBA;
445    blit.filter = PIPE_TEX_FILTER_NEAREST;
446 
447    pipe->blit(pipe, &blit);
448 }
449 
450 static void
dri_postprocessing(struct dri_context * ctx,struct dri_drawable * drawable,enum st_attachment_type att)451 dri_postprocessing(struct dri_context *ctx,
452                    struct dri_drawable *drawable,
453                    enum st_attachment_type att)
454 {
455    struct pipe_resource *src = drawable->textures[att];
456    struct pipe_resource *zsbuf = drawable->textures[ST_ATTACHMENT_DEPTH_STENCIL];
457 
458    if (ctx->pp && src)
459       pp_run(ctx->pp, src, src, zsbuf);
460 }
461 
462 /**
463  * DRI2 flush extension, the flush_with_flags function.
464  *
465  * \param context           the context
466  * \param drawable          the drawable to flush
467  * \param flags             a combination of _DRI2_FLUSH_xxx flags
468  * \param throttle_reason   the reason for throttling, 0 = no throttling
469  */
470 void
dri_flush(__DRIcontext * cPriv,__DRIdrawable * dPriv,unsigned flags,enum __DRI2throttleReason reason)471 dri_flush(__DRIcontext *cPriv,
472           __DRIdrawable *dPriv,
473           unsigned flags,
474           enum __DRI2throttleReason reason)
475 {
476    struct dri_context *ctx = dri_context(cPriv);
477    struct dri_drawable *drawable = dri_drawable(dPriv);
478    struct st_context_iface *st;
479    unsigned flush_flags;
480    boolean swap_msaa_buffers = FALSE;
481 
482    if (!ctx) {
483       assert(0);
484       return;
485    }
486 
487    st = ctx->st;
488    if (st->thread_finish)
489       st->thread_finish(st);
490 
491    if (drawable) {
492       /* prevent recursion */
493       if (drawable->flushing)
494          return;
495 
496       drawable->flushing = TRUE;
497    }
498    else {
499       flags &= ~__DRI2_FLUSH_DRAWABLE;
500    }
501 
502    /* Flush the drawable. */
503    if ((flags & __DRI2_FLUSH_DRAWABLE) &&
504        drawable->textures[ST_ATTACHMENT_BACK_LEFT]) {
505       struct pipe_context *pipe = st->pipe;
506 
507       if (drawable->stvis.samples > 1 &&
508           reason == __DRI2_THROTTLE_SWAPBUFFER) {
509          /* Resolve the MSAA back buffer. */
510          dri_pipe_blit(st->pipe,
511                        drawable->textures[ST_ATTACHMENT_BACK_LEFT],
512                        drawable->msaa_textures[ST_ATTACHMENT_BACK_LEFT]);
513 
514          if (drawable->msaa_textures[ST_ATTACHMENT_FRONT_LEFT] &&
515              drawable->msaa_textures[ST_ATTACHMENT_BACK_LEFT]) {
516             swap_msaa_buffers = TRUE;
517          }
518 
519          /* FRONT_LEFT is resolved in drawable->flush_frontbuffer. */
520       }
521 
522       dri_postprocessing(ctx, drawable, ST_ATTACHMENT_BACK_LEFT);
523 
524       if (ctx->hud) {
525          hud_run(ctx->hud, ctx->st->cso_context,
526                  drawable->textures[ST_ATTACHMENT_BACK_LEFT]);
527       }
528 
529       pipe->flush_resource(pipe, drawable->textures[ST_ATTACHMENT_BACK_LEFT]);
530 
531       if (pipe->invalidate_resource &&
532           (flags & __DRI2_FLUSH_INVALIDATE_ANCILLARY)) {
533          if (drawable->textures[ST_ATTACHMENT_DEPTH_STENCIL])
534             pipe->invalidate_resource(pipe, drawable->textures[ST_ATTACHMENT_DEPTH_STENCIL]);
535          if (drawable->msaa_textures[ST_ATTACHMENT_DEPTH_STENCIL])
536             pipe->invalidate_resource(pipe, drawable->msaa_textures[ST_ATTACHMENT_DEPTH_STENCIL]);
537       }
538    }
539 
540    flush_flags = 0;
541    if (flags & __DRI2_FLUSH_CONTEXT)
542       flush_flags |= ST_FLUSH_FRONT;
543    if (reason == __DRI2_THROTTLE_SWAPBUFFER)
544       flush_flags |= ST_FLUSH_END_OF_FRAME;
545 
546    /* Flush the context and throttle if needed. */
547    if (dri_screen(ctx->sPriv)->throttling_enabled &&
548        drawable &&
549        (reason == __DRI2_THROTTLE_SWAPBUFFER ||
550         reason == __DRI2_THROTTLE_FLUSHFRONT)) {
551       /* Throttle.
552        *
553        * This pulls a fence off the throttling queue and waits for it if the
554        * number of fences on the throttling queue has reached the desired
555        * number.
556        *
557        * Then flushes to insert a fence at the current rendering position, and
558        * pushes that fence on the queue. This requires that the st_context_iface
559        * flush method returns a fence even if there are no commands to flush.
560        */
561       struct pipe_screen *screen = drawable->screen->base.screen;
562       struct pipe_fence_handle *fence;
563 
564       fence = swap_fences_pop_front(drawable);
565       if (fence) {
566          (void) screen->fence_finish(screen, NULL, fence, PIPE_TIMEOUT_INFINITE);
567          screen->fence_reference(screen, &fence, NULL);
568       }
569 
570       st->flush(st, flush_flags, &fence);
571 
572       if (fence) {
573          swap_fences_push_back(drawable, fence);
574          screen->fence_reference(screen, &fence, NULL);
575       }
576    }
577    else if (flags & (__DRI2_FLUSH_DRAWABLE | __DRI2_FLUSH_CONTEXT)) {
578       st->flush(st, flush_flags, NULL);
579    }
580 
581    if (drawable) {
582       drawable->flushing = FALSE;
583    }
584 
585    /* Swap the MSAA front and back buffers, so that reading
586     * from the front buffer after SwapBuffers returns what was
587     * in the back buffer.
588     */
589    if (swap_msaa_buffers) {
590       struct pipe_resource *tmp =
591          drawable->msaa_textures[ST_ATTACHMENT_FRONT_LEFT];
592 
593       drawable->msaa_textures[ST_ATTACHMENT_FRONT_LEFT] =
594          drawable->msaa_textures[ST_ATTACHMENT_BACK_LEFT];
595       drawable->msaa_textures[ST_ATTACHMENT_BACK_LEFT] = tmp;
596 
597       /* Now that we have swapped the buffers, this tells the state
598        * tracker to revalidate the framebuffer.
599        */
600       p_atomic_inc(&drawable->base.stamp);
601    }
602 }
603 
604 /**
605  * dri_throttle - A DRI2ThrottleExtension throttling function.
606  */
607 static void
dri_throttle(__DRIcontext * cPriv,__DRIdrawable * dPriv,enum __DRI2throttleReason reason)608 dri_throttle(__DRIcontext *cPriv, __DRIdrawable *dPriv,
609              enum __DRI2throttleReason reason)
610 {
611    dri_flush(cPriv, dPriv, 0, reason);
612 }
613 
614 
615 const __DRI2throttleExtension dri2ThrottleExtension = {
616     .base = { __DRI2_THROTTLE, 1 },
617 
618     .throttle          = dri_throttle,
619 };
620 
621 
622 /* vim: set sw=3 ts=8 sts=3 expandtab: */
623