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 (at) vmware.com> 29 * Author: Jakob Bornecrantz <wallbraker (at) 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 void 42 swap_fences_unref(struct dri_drawable *draw); 43 44 static boolean 45 dri_st_framebuffer_validate(struct st_framebuffer_iface *stfbi, 46 const enum st_attachment_type *statts, 47 unsigned count, 48 struct pipe_resource **out) 49 { 50 struct dri_drawable *drawable = 51 (struct dri_drawable *) stfbi->st_manager_private; 52 struct dri_screen *screen = dri_screen(drawable->sPriv); 53 unsigned statt_mask, new_mask; 54 boolean new_stamp; 55 int i; 56 unsigned int lastStamp; 57 58 statt_mask = 0x0; 59 for (i = 0; i < count; i++) 60 statt_mask |= (1 << statts[i]); 61 62 /* record newly allocated textures */ 63 new_mask = (statt_mask & ~drawable->texture_mask); 64 65 /* 66 * dPriv->dri2.stamp is the server stamp. dPriv->lastStamp is the 67 * client stamp. It has the value of the server stamp when last 68 * checked. 69 */ 70 do { 71 lastStamp = drawable->dPriv->lastStamp; 72 new_stamp = (drawable->texture_stamp != lastStamp); 73 74 if (new_stamp || new_mask || screen->broken_invalidate) { 75 if (new_stamp && drawable->update_drawable_info) 76 drawable->update_drawable_info(drawable); 77 78 drawable->allocate_textures(drawable, statts, count); 79 80 /* add existing textures */ 81 for (i = 0; i < ST_ATTACHMENT_COUNT; i++) { 82 if (drawable->textures[i]) 83 statt_mask |= (1 << i); 84 } 85 86 drawable->texture_stamp = lastStamp; 87 drawable->texture_mask = statt_mask; 88 } 89 } while (lastStamp != drawable->dPriv->lastStamp); 90 91 if (!out) 92 return TRUE; 93 94 for (i = 0; i < count; i++) { 95 out[i] = NULL; 96 pipe_resource_reference(&out[i], drawable->textures[statts[i]]); 97 } 98 99 return TRUE; 100 } 101 102 static boolean 103 dri_st_framebuffer_flush_front(struct st_framebuffer_iface *stfbi, 104 enum st_attachment_type statt) 105 { 106 struct dri_drawable *drawable = 107 (struct dri_drawable *) stfbi->st_manager_private; 108 109 /* XXX remove this and just set the correct one on the framebuffer */ 110 drawable->flush_frontbuffer(drawable, statt); 111 112 return TRUE; 113 } 114 115 /** 116 * This is called when we need to set up GL rendering to a new X window. 117 */ 118 boolean 119 dri_create_buffer(__DRIscreen * sPriv, 120 __DRIdrawable * dPriv, 121 const struct gl_config * visual, boolean isPixmap) 122 { 123 struct dri_screen *screen = sPriv->driverPrivate; 124 struct dri_drawable *drawable = NULL; 125 126 if (isPixmap) 127 goto fail; /* not implemented */ 128 129 drawable = CALLOC_STRUCT(dri_drawable); 130 if (drawable == NULL) 131 goto fail; 132 133 dri_fill_st_visual(&drawable->stvis, screen, visual); 134 135 /* setup the st_framebuffer_iface */ 136 drawable->base.visual = &drawable->stvis; 137 drawable->base.flush_front = dri_st_framebuffer_flush_front; 138 drawable->base.validate = dri_st_framebuffer_validate; 139 drawable->base.st_manager_private = (void *) drawable; 140 141 drawable->screen = screen; 142 drawable->sPriv = sPriv; 143 drawable->dPriv = dPriv; 144 drawable->desired_fences = screen->default_throttle_frames; 145 if (drawable->desired_fences > DRI_SWAP_FENCES_MAX) 146 drawable->desired_fences = DRI_SWAP_FENCES_MAX; 147 148 dPriv->driverPrivate = (void *)drawable; 149 p_atomic_set(&drawable->base.stamp, 1); 150 151 return GL_TRUE; 152 fail: 153 FREE(drawable); 154 return GL_FALSE; 155 } 156 157 void 158 dri_destroy_buffer(__DRIdrawable * dPriv) 159 { 160 struct dri_drawable *drawable = dri_drawable(dPriv); 161 int i; 162 163 pipe_surface_reference(&drawable->drisw_surface, NULL); 164 165 for (i = 0; i < ST_ATTACHMENT_COUNT; i++) 166 pipe_resource_reference(&drawable->textures[i], NULL); 167 168 swap_fences_unref(drawable); 169 170 FREE(drawable); 171 } 172 173 /** 174 * Validate the texture at an attachment. Allocate the texture if it does not 175 * exist. Used by the TFP extension. 176 */ 177 static void 178 dri_drawable_validate_att(struct dri_drawable *drawable, 179 enum st_attachment_type statt) 180 { 181 enum st_attachment_type statts[ST_ATTACHMENT_COUNT]; 182 unsigned i, count = 0; 183 184 /* check if buffer already exists */ 185 if (drawable->texture_mask & (1 << statt)) 186 return; 187 188 /* make sure DRI2 does not destroy existing buffers */ 189 for (i = 0; i < ST_ATTACHMENT_COUNT; i++) { 190 if (drawable->texture_mask & (1 << i)) { 191 statts[count++] = i; 192 } 193 } 194 statts[count++] = statt; 195 196 drawable->texture_stamp = drawable->dPriv->lastStamp - 1; 197 198 drawable->base.validate(&drawable->base, statts, count, NULL); 199 } 200 201 /** 202 * These are used for GLX_EXT_texture_from_pixmap 203 */ 204 static void 205 dri_set_tex_buffer2(__DRIcontext *pDRICtx, GLint target, 206 GLint format, __DRIdrawable *dPriv) 207 { 208 struct dri_context *ctx = dri_context(pDRICtx); 209 struct dri_drawable *drawable = dri_drawable(dPriv); 210 struct pipe_resource *pt; 211 212 dri_drawable_validate_att(drawable, ST_ATTACHMENT_FRONT_LEFT); 213 214 /* Use the pipe resource associated with the X drawable */ 215 pt = drawable->textures[ST_ATTACHMENT_FRONT_LEFT]; 216 217 if (pt) { 218 enum pipe_format internal_format = pt->format; 219 220 if (format == __DRI_TEXTURE_FORMAT_RGB) { 221 /* only need to cover the formats recognized by dri_fill_st_visual */ 222 switch (internal_format) { 223 case PIPE_FORMAT_B8G8R8A8_UNORM: 224 internal_format = PIPE_FORMAT_B8G8R8X8_UNORM; 225 break; 226 case PIPE_FORMAT_A8R8G8B8_UNORM: 227 internal_format = PIPE_FORMAT_X8R8G8B8_UNORM; 228 break; 229 default: 230 break; 231 } 232 } 233 234 drawable->update_tex_buffer(drawable, ctx, pt); 235 236 ctx->st->teximage(ctx->st, 237 (target == GL_TEXTURE_2D) ? ST_TEXTURE_2D : ST_TEXTURE_RECT, 238 0, internal_format, pt, FALSE); 239 } 240 } 241 242 static void 243 dri_set_tex_buffer(__DRIcontext *pDRICtx, GLint target, 244 __DRIdrawable *dPriv) 245 { 246 dri_set_tex_buffer2(pDRICtx, target, __DRI_TEXTURE_FORMAT_RGBA, dPriv); 247 } 248 249 const __DRItexBufferExtension driTexBufferExtension = { 250 { __DRI_TEX_BUFFER, __DRI_TEX_BUFFER_VERSION }, 251 dri_set_tex_buffer, 252 dri_set_tex_buffer2, 253 NULL, 254 }; 255 256 /** 257 * Get the format and binding of an attachment. 258 */ 259 void 260 dri_drawable_get_format(struct dri_drawable *drawable, 261 enum st_attachment_type statt, 262 enum pipe_format *format, 263 unsigned *bind) 264 { 265 switch (statt) { 266 case ST_ATTACHMENT_FRONT_LEFT: 267 case ST_ATTACHMENT_BACK_LEFT: 268 case ST_ATTACHMENT_FRONT_RIGHT: 269 case ST_ATTACHMENT_BACK_RIGHT: 270 *format = drawable->stvis.color_format; 271 *bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; 272 break; 273 case ST_ATTACHMENT_DEPTH_STENCIL: 274 *format = drawable->stvis.depth_stencil_format; 275 *bind = PIPE_BIND_DEPTH_STENCIL; /* XXX sampler? */ 276 break; 277 default: 278 *format = PIPE_FORMAT_NONE; 279 *bind = 0; 280 break; 281 } 282 } 283 284 285 /** 286 * swap_fences_pop_front - pull a fence from the throttle queue 287 * 288 * If the throttle queue is filled to the desired number of fences, 289 * pull fences off the queue until the number is less than the desired 290 * number of fences, and return the last fence pulled. 291 */ 292 static struct pipe_fence_handle * 293 swap_fences_pop_front(struct dri_drawable *draw) 294 { 295 struct pipe_screen *screen = draw->screen->base.screen; 296 struct pipe_fence_handle *fence = NULL; 297 298 if (draw->desired_fences == 0) 299 return NULL; 300 301 if (draw->cur_fences >= draw->desired_fences) { 302 screen->fence_reference(screen, &fence, draw->swap_fences[draw->tail]); 303 screen->fence_reference(screen, &draw->swap_fences[draw->tail++], NULL); 304 draw->tail &= DRI_SWAP_FENCES_MASK; 305 --draw->cur_fences; 306 } 307 return fence; 308 } 309 310 311 /** 312 * swap_fences_push_back - push a fence onto the throttle queue 313 * 314 * push a fence onto the throttle queue and pull fences of the queue 315 * so that the desired number of fences are on the queue. 316 */ 317 static void 318 swap_fences_push_back(struct dri_drawable *draw, 319 struct pipe_fence_handle *fence) 320 { 321 struct pipe_screen *screen = draw->screen->base.screen; 322 323 if (!fence || draw->desired_fences == 0) 324 return; 325 326 while(draw->cur_fences == draw->desired_fences) 327 swap_fences_pop_front(draw); 328 329 draw->cur_fences++; 330 screen->fence_reference(screen, &draw->swap_fences[draw->head++], 331 fence); 332 draw->head &= DRI_SWAP_FENCES_MASK; 333 } 334 335 336 /** 337 * swap_fences_unref - empty the throttle queue 338 * 339 * pulls fences of the throttle queue until it is empty. 340 */ 341 static void 342 swap_fences_unref(struct dri_drawable *draw) 343 { 344 struct pipe_screen *screen = draw->screen->base.screen; 345 346 while(draw->cur_fences) { 347 screen->fence_reference(screen, &draw->swap_fences[draw->tail++], NULL); 348 draw->tail &= DRI_SWAP_FENCES_MASK; 349 --draw->cur_fences; 350 } 351 } 352 353 354 /** 355 * dri_throttle - A DRI2ThrottleExtension throttling function. 356 * 357 * pulls a fence off the throttling queue and waits for it if the 358 * number of fences on the throttling queue has reached the desired 359 * number. 360 * 361 * Then flushes to insert a fence at the current rendering position, and 362 * pushes that fence on the queue. This requires that the st_context_iface 363 * flush method returns a fence even if there are no commands to flush. 364 */ 365 static void 366 dri_throttle(__DRIcontext *driCtx, __DRIdrawable *dPriv, 367 enum __DRI2throttleReason reason) 368 { 369 struct dri_drawable *draw = dri_drawable(dPriv); 370 struct st_context_iface *ctxi; 371 struct pipe_screen *screen = draw->screen->base.screen; 372 struct pipe_fence_handle *fence; 373 374 if (reason != __DRI2_THROTTLE_SWAPBUFFER && 375 reason != __DRI2_THROTTLE_FLUSHFRONT) 376 return; 377 378 fence = swap_fences_pop_front(draw); 379 if (fence) { 380 (void) screen->fence_finish(screen, fence, PIPE_TIMEOUT_INFINITE); 381 screen->fence_reference(screen, &fence, NULL); 382 } 383 384 if (driCtx == NULL) 385 return; 386 387 ctxi = dri_context(driCtx)->st; 388 ctxi->flush(ctxi, 0, &fence); 389 if (fence) { 390 swap_fences_push_back(draw, fence); 391 screen->fence_reference(screen, &fence, NULL); 392 } 393 } 394 395 396 const __DRI2throttleExtension dri2ThrottleExtension = { 397 .base = { __DRI2_THROTTLE, __DRI2_THROTTLE_VERSION }, 398 .throttle = dri_throttle, 399 }; 400 401 402 /* vim: set sw=3 ts=8 sts=3 expandtab: */ 403
