2 Copyright 2003 VMware, Inc.
3 Copyright (C) Intel Corp. 2006. All Rights Reserved.
4 Intel funded Tungsten Graphics to
5 develop this 3D driver.
7 Permission is hereby granted, free of charge, to any person obtaining
8 a copy of this software and associated documentation files (the
9 "Software"), to deal in the Software without restriction, including
10 without limitation the rights to use, copy, modify, merge, publish,
11 distribute, sublicense, and/or sell copies of the Software, and to
12 permit persons to whom the Software is furnished to do so, subject to
13 the following conditions:
15 The above copyright notice and this permission notice (including the
16 next paragraph) shall be included in all copies or substantial
17 portions of the Software.
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
20 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
21 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
22 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
23 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
24 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
25 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 **********************************************************************/
30 * Keith Whitwell <keithw@vmware.com>
34 #include "main/api_exec.h"
35 #include "main/context.h"
36 #include "main/fbobject.h"
37 #include "main/imports.h"
38 #include "main/macros.h"
39 #include "main/points.h"
40 #include "main/version.h"
41 #include "main/vtxfmt.h"
43 #include "vbo/vbo_context.h"
45 #include "drivers/common/driverfuncs.h"
46 #include "drivers/common/meta.h"
49 #include "brw_context.h"
50 #include "brw_defines.h"
52 #include "brw_state.h"
54 #include "intel_batchbuffer.h"
55 #include "intel_buffer_objects.h"
56 #include "intel_buffers.h"
57 #include "intel_fbo.h"
58 #include "intel_mipmap_tree.h"
59 #include "intel_pixel.h"
60 #include "intel_regions.h"
61 #include "intel_tex.h"
62 #include "intel_tex_obj.h"
64 #include "swrast_setup/swrast_setup.h"
66 #include "tnl/t_pipeline.h"
67 #include "glsl/ralloc.h"
69 /***************************************
70 * Mesa's Driver Functions
71 ***************************************/
74 brw_query_samples_for_format(struct gl_context
*ctx
, GLenum target
,
75 GLenum internalFormat
, int samples
[16])
77 struct brw_context
*brw
= brw_context(ctx
);
97 const char *const brw_vendor_string
= "Intel Open Source Technology Center";
100 brw_get_renderer_string(unsigned deviceID
)
103 static char buffer
[128];
107 #define CHIPSET(id, symbol, str) case id: chipset = str; break;
108 #include "pci_ids/i965_pci_ids.h"
110 chipset
= "Unknown Intel Chipset";
114 (void) driGetRendererString(buffer
, chipset
, 0);
118 static const GLubyte
*
119 intelGetString(struct gl_context
* ctx
, GLenum name
)
121 const struct brw_context
*const brw
= brw_context(ctx
);
125 return (GLubyte
*) brw_vendor_string
;
129 (GLubyte
*) brw_get_renderer_string(brw
->intelScreen
->deviceID
);
137 intel_viewport(struct gl_context
*ctx
)
139 struct brw_context
*brw
= brw_context(ctx
);
140 __DRIcontext
*driContext
= brw
->driContext
;
142 if (_mesa_is_winsys_fbo(ctx
->DrawBuffer
)) {
143 dri2InvalidateDrawable(driContext
->driDrawablePriv
);
144 dri2InvalidateDrawable(driContext
->driReadablePriv
);
149 intelInvalidateState(struct gl_context
* ctx
, GLuint new_state
)
151 struct brw_context
*brw
= brw_context(ctx
);
153 if (ctx
->swrast_context
)
154 _swrast_InvalidateState(ctx
, new_state
);
155 _vbo_InvalidateState(ctx
, new_state
);
157 brw
->NewGLState
|= new_state
;
160 #define flushFront(screen) ((screen)->image.loader ? (screen)->image.loader->flushFrontBuffer : (screen)->dri2.loader->flushFrontBuffer)
163 intel_flush_front(struct gl_context
*ctx
)
165 struct brw_context
*brw
= brw_context(ctx
);
166 __DRIcontext
*driContext
= brw
->driContext
;
167 __DRIdrawable
*driDrawable
= driContext
->driDrawablePriv
;
168 __DRIscreen
*const screen
= brw
->intelScreen
->driScrnPriv
;
170 if (brw
->front_buffer_dirty
&& _mesa_is_winsys_fbo(ctx
->DrawBuffer
)) {
171 if (flushFront(screen
) && driDrawable
&&
172 driDrawable
->loaderPrivate
) {
174 /* Resolve before flushing FAKE_FRONT_LEFT to FRONT_LEFT.
176 * This potentially resolves both front and back buffer. It
177 * is unnecessary to resolve the back, but harms nothing except
178 * performance. And no one cares about front-buffer render
181 intel_resolve_for_dri2_flush(brw
, driDrawable
);
182 intel_batchbuffer_flush(brw
);
184 flushFront(screen
)(driDrawable
, driDrawable
->loaderPrivate
);
186 /* We set the dirty bit in intel_prepare_render() if we're
187 * front buffer rendering once we get there.
189 brw
->front_buffer_dirty
= false;
195 intel_glFlush(struct gl_context
*ctx
)
197 struct brw_context
*brw
= brw_context(ctx
);
199 intel_batchbuffer_flush(brw
);
200 intel_flush_front(ctx
);
201 if (brw
->is_front_buffer_rendering
)
202 brw
->need_throttle
= true;
206 intelFinish(struct gl_context
* ctx
)
208 struct brw_context
*brw
= brw_context(ctx
);
212 if (brw
->batch
.last_bo
)
213 drm_intel_bo_wait_rendering(brw
->batch
.last_bo
);
217 brw_init_driver_functions(struct brw_context
*brw
,
218 struct dd_function_table
*functions
)
220 _mesa_init_driver_functions(functions
);
222 /* GLX uses DRI2 invalidate events to handle window resizing.
223 * Unfortunately, EGL does not - libEGL is written in XCB (not Xlib),
224 * which doesn't provide a mechanism for snooping the event queues.
226 * So EGL still relies on viewport hacks to handle window resizing.
227 * This should go away with DRI3000.
229 if (!brw
->driContext
->driScreenPriv
->dri2
.useInvalidate
)
230 functions
->Viewport
= intel_viewport
;
232 functions
->Flush
= intel_glFlush
;
233 functions
->Finish
= intelFinish
;
234 functions
->GetString
= intelGetString
;
235 functions
->UpdateState
= intelInvalidateState
;
237 intelInitTextureFuncs(functions
);
238 intelInitTextureImageFuncs(functions
);
239 intelInitTextureSubImageFuncs(functions
);
240 intelInitTextureCopyImageFuncs(functions
);
241 intelInitClearFuncs(functions
);
242 intelInitBufferFuncs(functions
);
243 intelInitPixelFuncs(functions
);
244 intelInitBufferObjectFuncs(functions
);
245 intel_init_syncobj_functions(functions
);
246 brw_init_object_purgeable_functions(functions
);
248 brwInitFragProgFuncs( functions
);
249 brw_init_common_queryobj_functions(functions
);
251 gen6_init_queryobj_functions(functions
);
253 gen4_init_queryobj_functions(functions
);
255 functions
->QuerySamplesForFormat
= brw_query_samples_for_format
;
257 functions
->NewTransformFeedback
= brw_new_transform_feedback
;
258 functions
->DeleteTransformFeedback
= brw_delete_transform_feedback
;
259 functions
->GetTransformFeedbackVertexCount
=
260 brw_get_transform_feedback_vertex_count
;
262 functions
->BeginTransformFeedback
= gen7_begin_transform_feedback
;
263 functions
->EndTransformFeedback
= gen7_end_transform_feedback
;
264 functions
->PauseTransformFeedback
= gen7_pause_transform_feedback
;
265 functions
->ResumeTransformFeedback
= gen7_resume_transform_feedback
;
267 functions
->BeginTransformFeedback
= brw_begin_transform_feedback
;
268 functions
->EndTransformFeedback
= brw_end_transform_feedback
;
272 functions
->GetSamplePosition
= gen6_get_sample_position
;
276 brw_initialize_context_constants(struct brw_context
*brw
)
278 struct gl_context
*ctx
= &brw
->ctx
;
280 ctx
->Const
.QueryCounterBits
.Timestamp
= 36;
282 ctx
->Const
.StripTextureBorder
= true;
284 ctx
->Const
.MaxDualSourceDrawBuffers
= 1;
285 ctx
->Const
.MaxDrawBuffers
= BRW_MAX_DRAW_BUFFERS
;
286 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxTextureImageUnits
= BRW_MAX_TEX_UNIT
;
287 ctx
->Const
.MaxTextureCoordUnits
= 8; /* Mesa limit */
288 ctx
->Const
.MaxTextureUnits
=
289 MIN2(ctx
->Const
.MaxTextureCoordUnits
,
290 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxTextureImageUnits
);
291 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxTextureImageUnits
= BRW_MAX_TEX_UNIT
;
293 ctx
->Const
.Program
[MESA_SHADER_GEOMETRY
].MaxTextureImageUnits
= BRW_MAX_TEX_UNIT
;
295 ctx
->Const
.Program
[MESA_SHADER_GEOMETRY
].MaxTextureImageUnits
= 0;
296 ctx
->Const
.MaxCombinedTextureImageUnits
=
297 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxTextureImageUnits
+
298 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxTextureImageUnits
+
299 ctx
->Const
.Program
[MESA_SHADER_GEOMETRY
].MaxTextureImageUnits
;
301 ctx
->Const
.MaxTextureLevels
= 14; /* 8192 */
302 if (ctx
->Const
.MaxTextureLevels
> MAX_TEXTURE_LEVELS
)
303 ctx
->Const
.MaxTextureLevels
= MAX_TEXTURE_LEVELS
;
304 ctx
->Const
.Max3DTextureLevels
= 9;
305 ctx
->Const
.MaxCubeTextureLevels
= 12;
308 ctx
->Const
.MaxArrayTextureLayers
= 2048;
310 ctx
->Const
.MaxArrayTextureLayers
= 512;
312 ctx
->Const
.MaxTextureRectSize
= 1 << 12;
314 ctx
->Const
.MaxTextureMaxAnisotropy
= 16.0;
316 ctx
->Const
.MaxRenderbufferSize
= 8192;
318 /* Hardware only supports a limited number of transform feedback buffers.
319 * So we need to override the Mesa default (which is based only on software
322 ctx
->Const
.MaxTransformFeedbackBuffers
= BRW_MAX_SOL_BUFFERS
;
324 /* On Gen6, in the worst case, we use up one binding table entry per
325 * transform feedback component (see comments above the definition of
326 * BRW_MAX_SOL_BINDINGS, in brw_context.h), so we need to advertise a value
327 * for MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS equal to
328 * BRW_MAX_SOL_BINDINGS.
330 * In "separate components" mode, we need to divide this value by
331 * BRW_MAX_SOL_BUFFERS, so that the total number of binding table entries
332 * used up by all buffers will not exceed BRW_MAX_SOL_BINDINGS.
334 ctx
->Const
.MaxTransformFeedbackInterleavedComponents
= BRW_MAX_SOL_BINDINGS
;
335 ctx
->Const
.MaxTransformFeedbackSeparateComponents
=
336 BRW_MAX_SOL_BINDINGS
/ BRW_MAX_SOL_BUFFERS
;
338 ctx
->Const
.AlwaysUseGetTransformFeedbackVertexCount
= true;
341 const int *msaa_modes
= intel_supported_msaa_modes(brw
->intelScreen
);
342 const int clamp_max_samples
=
343 driQueryOptioni(&brw
->optionCache
, "clamp_max_samples");
345 if (clamp_max_samples
< 0) {
346 max_samples
= msaa_modes
[0];
348 /* Select the largest supported MSAA mode that does not exceed
352 for (int i
= 0; msaa_modes
[i
] != 0; ++i
) {
353 if (msaa_modes
[i
] <= clamp_max_samples
) {
354 max_samples
= msaa_modes
[i
];
360 ctx
->Const
.MaxSamples
= max_samples
;
361 ctx
->Const
.MaxColorTextureSamples
= max_samples
;
362 ctx
->Const
.MaxDepthTextureSamples
= max_samples
;
363 ctx
->Const
.MaxIntegerSamples
= max_samples
;
366 ctx
->Const
.MaxProgramTextureGatherComponents
= 4;
368 ctx
->Const
.MinLineWidth
= 1.0;
369 ctx
->Const
.MinLineWidthAA
= 1.0;
370 ctx
->Const
.MaxLineWidth
= 5.0;
371 ctx
->Const
.MaxLineWidthAA
= 5.0;
372 ctx
->Const
.LineWidthGranularity
= 0.5;
374 ctx
->Const
.MinPointSize
= 1.0;
375 ctx
->Const
.MinPointSizeAA
= 1.0;
376 ctx
->Const
.MaxPointSize
= 255.0;
377 ctx
->Const
.MaxPointSizeAA
= 255.0;
378 ctx
->Const
.PointSizeGranularity
= 1.0;
380 if (brw
->gen
>= 5 || brw
->is_g4x
)
381 ctx
->Const
.MaxClipPlanes
= 8;
383 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeInstructions
= 16 * 1024;
384 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxAluInstructions
= 0;
385 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxTexInstructions
= 0;
386 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxTexIndirections
= 0;
387 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeAluInstructions
= 0;
388 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeTexInstructions
= 0;
389 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeTexIndirections
= 0;
390 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeAttribs
= 16;
391 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeTemps
= 256;
392 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeAddressRegs
= 1;
393 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeParameters
= 1024;
394 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxEnvParams
=
395 MIN2(ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxNativeParameters
,
396 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxEnvParams
);
398 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeInstructions
= 1024;
399 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeAluInstructions
= 1024;
400 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeTexInstructions
= 1024;
401 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeTexIndirections
= 1024;
402 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeAttribs
= 12;
403 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeTemps
= 256;
404 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeAddressRegs
= 0;
405 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeParameters
= 1024;
406 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxEnvParams
=
407 MIN2(ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxNativeParameters
,
408 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxEnvParams
);
410 /* Fragment shaders use real, 32-bit twos-complement integers for all
413 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].LowInt
.RangeMin
= 31;
414 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].LowInt
.RangeMax
= 30;
415 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].LowInt
.Precision
= 0;
416 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].HighInt
= ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].LowInt
;
417 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MediumInt
= ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].LowInt
;
420 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxAtomicCounters
= MAX_ATOMIC_COUNTERS
;
421 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxAtomicCounters
= MAX_ATOMIC_COUNTERS
;
422 ctx
->Const
.Program
[MESA_SHADER_GEOMETRY
].MaxAtomicCounters
= MAX_ATOMIC_COUNTERS
;
423 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxAtomicBuffers
= BRW_MAX_ABO
;
424 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxAtomicBuffers
= BRW_MAX_ABO
;
425 ctx
->Const
.Program
[MESA_SHADER_GEOMETRY
].MaxAtomicBuffers
= BRW_MAX_ABO
;
426 ctx
->Const
.MaxCombinedAtomicBuffers
= 3 * BRW_MAX_ABO
;
429 /* Gen6 converts quads to polygon in beginning of 3D pipeline,
430 * but we're not sure how it's actually done for vertex order,
431 * that affect provoking vertex decision. Always use last vertex
432 * convention for quad primitive which works as expected for now.
435 ctx
->Const
.QuadsFollowProvokingVertexConvention
= false;
437 ctx
->Const
.NativeIntegers
= true;
438 ctx
->Const
.UniformBooleanTrue
= 1;
440 /* From the gen4 PRM, volume 4 page 127:
442 * "For SURFTYPE_BUFFER non-rendertarget surfaces, this field specifies
443 * the base address of the first element of the surface, computed in
444 * software by adding the surface base address to the byte offset of
445 * the element in the buffer."
447 * However, unaligned accesses are slower, so enforce buffer alignment.
449 ctx
->Const
.UniformBufferOffsetAlignment
= 16;
450 ctx
->Const
.TextureBufferOffsetAlignment
= 16;
453 ctx
->Const
.MaxVarying
= 32;
454 ctx
->Const
.Program
[MESA_SHADER_VERTEX
].MaxOutputComponents
= 128;
455 ctx
->Const
.Program
[MESA_SHADER_GEOMETRY
].MaxInputComponents
= 64;
456 ctx
->Const
.Program
[MESA_SHADER_GEOMETRY
].MaxOutputComponents
= 128;
457 ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
].MaxInputComponents
= 128;
460 /* We want the GLSL compiler to emit code that uses condition codes */
461 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
462 ctx
->ShaderCompilerOptions
[i
].MaxIfDepth
= brw
->gen
< 6 ? 16 : UINT_MAX
;
463 ctx
->ShaderCompilerOptions
[i
].EmitCondCodes
= true;
464 ctx
->ShaderCompilerOptions
[i
].EmitNoNoise
= true;
465 ctx
->ShaderCompilerOptions
[i
].EmitNoMainReturn
= true;
466 ctx
->ShaderCompilerOptions
[i
].EmitNoIndirectInput
= true;
467 ctx
->ShaderCompilerOptions
[i
].EmitNoIndirectOutput
= true;
469 ctx
->ShaderCompilerOptions
[i
].EmitNoIndirectUniform
=
470 (i
== MESA_SHADER_FRAGMENT
);
471 ctx
->ShaderCompilerOptions
[i
].EmitNoIndirectTemp
=
472 (i
== MESA_SHADER_FRAGMENT
);
473 ctx
->ShaderCompilerOptions
[i
].LowerClipDistance
= true;
476 ctx
->ShaderCompilerOptions
[MESA_SHADER_VERTEX
].OptimizeForAOS
= true;
477 ctx
->ShaderCompilerOptions
[MESA_SHADER_GEOMETRY
].OptimizeForAOS
= true;
479 /* ARB_viewport_array */
480 if (brw
->gen
>= 7 && ctx
->API
== API_OPENGL_CORE
) {
481 ctx
->Const
.MaxViewports
= GEN7_NUM_VIEWPORTS
;
482 ctx
->Const
.ViewportSubpixelBits
= 0;
484 /* Cast to float before negating becuase MaxViewportWidth is unsigned.
486 ctx
->Const
.ViewportBounds
.Min
= -(float)ctx
->Const
.MaxViewportWidth
;
487 ctx
->Const
.ViewportBounds
.Max
= ctx
->Const
.MaxViewportWidth
;
492 * Process driconf (drirc) options, setting appropriate context flags.
494 * intelInitExtensions still pokes at optionCache directly, in order to
495 * avoid advertising various extensions. No flags are set, so it makes
496 * sense to continue doing that there.
499 brw_process_driconf_options(struct brw_context
*brw
)
501 struct gl_context
*ctx
= &brw
->ctx
;
503 driOptionCache
*options
= &brw
->optionCache
;
504 driParseConfigFiles(options
, &brw
->intelScreen
->optionCache
,
505 brw
->driContext
->driScreenPriv
->myNum
, "i965");
507 int bo_reuse_mode
= driQueryOptioni(options
, "bo_reuse");
508 switch (bo_reuse_mode
) {
509 case DRI_CONF_BO_REUSE_DISABLED
:
511 case DRI_CONF_BO_REUSE_ALL
:
512 intel_bufmgr_gem_enable_reuse(brw
->bufmgr
);
516 if (!driQueryOptionb(options
, "hiz")) {
517 brw
->has_hiz
= false;
518 /* On gen6, you can only do separate stencil with HIZ. */
520 brw
->has_separate_stencil
= false;
523 if (driQueryOptionb(options
, "always_flush_batch")) {
524 fprintf(stderr
, "flushing batchbuffer before/after each draw call\n");
525 brw
->always_flush_batch
= true;
528 if (driQueryOptionb(options
, "always_flush_cache")) {
529 fprintf(stderr
, "flushing GPU caches before/after each draw call\n");
530 brw
->always_flush_cache
= true;
533 if (driQueryOptionb(options
, "disable_throttling")) {
534 fprintf(stderr
, "disabling flush throttling\n");
535 brw
->disable_throttling
= true;
538 brw
->disable_derivative_optimization
=
539 driQueryOptionb(&brw
->optionCache
, "disable_derivative_optimization");
541 brw
->precompile
= driQueryOptionb(&brw
->optionCache
, "shader_precompile");
543 ctx
->Const
.ForceGLSLExtensionsWarn
=
544 driQueryOptionb(options
, "force_glsl_extensions_warn");
546 ctx
->Const
.DisableGLSLLineContinuations
=
547 driQueryOptionb(options
, "disable_glsl_line_continuations");
551 brwCreateContext(gl_api api
,
552 const struct gl_config
*mesaVis
,
553 __DRIcontext
*driContextPriv
,
554 unsigned major_version
,
555 unsigned minor_version
,
558 unsigned *dri_ctx_error
,
559 void *sharedContextPrivate
)
561 __DRIscreen
*sPriv
= driContextPriv
->driScreenPriv
;
562 struct gl_context
*shareCtx
= (struct gl_context
*) sharedContextPrivate
;
563 struct intel_screen
*screen
= sPriv
->driverPrivate
;
564 const struct brw_device_info
*devinfo
= screen
->devinfo
;
565 struct dd_function_table functions
;
566 struct gl_config visual
;
568 /* Only allow the __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS flag if the kernel
569 * provides us with context reset notifications.
571 uint32_t allowed_flags
= __DRI_CTX_FLAG_DEBUG
572 | __DRI_CTX_FLAG_FORWARD_COMPATIBLE
;
574 if (screen
->has_context_reset_notification
)
575 allowed_flags
|= __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS
;
577 if (flags
& ~allowed_flags
) {
578 *dri_ctx_error
= __DRI_CTX_ERROR_UNKNOWN_FLAG
;
582 struct brw_context
*brw
= rzalloc(NULL
, struct brw_context
);
584 printf("%s: failed to alloc context\n", __FUNCTION__
);
585 *dri_ctx_error
= __DRI_CTX_ERROR_NO_MEMORY
;
589 driContextPriv
->driverPrivate
= brw
;
590 brw
->driContext
= driContextPriv
;
591 brw
->intelScreen
= screen
;
592 brw
->bufmgr
= screen
->bufmgr
;
594 brw
->gen
= devinfo
->gen
;
595 brw
->gt
= devinfo
->gt
;
596 brw
->is_g4x
= devinfo
->is_g4x
;
597 brw
->is_baytrail
= devinfo
->is_baytrail
;
598 brw
->is_haswell
= devinfo
->is_haswell
;
599 brw
->has_llc
= devinfo
->has_llc
;
600 brw
->has_hiz
= devinfo
->has_hiz_and_separate_stencil
&& brw
->gen
< 8;
601 brw
->has_separate_stencil
= devinfo
->has_hiz_and_separate_stencil
;
602 brw
->has_pln
= devinfo
->has_pln
;
603 brw
->has_compr4
= devinfo
->has_compr4
;
604 brw
->has_surface_tile_offset
= devinfo
->has_surface_tile_offset
;
605 brw
->has_negative_rhw_bug
= devinfo
->has_negative_rhw_bug
;
606 brw
->needs_unlit_centroid_workaround
=
607 devinfo
->needs_unlit_centroid_workaround
;
609 brw
->must_use_separate_stencil
= screen
->hw_must_use_separate_stencil
;
610 brw
->has_swizzling
= screen
->hw_has_swizzling
;
613 gen7_init_vtable_surface_functions(brw
);
614 gen7_init_vtable_sampler_functions(brw
);
615 brw
->vtbl
.emit_depth_stencil_hiz
= gen7_emit_depth_stencil_hiz
;
617 gen4_init_vtable_surface_functions(brw
);
618 gen4_init_vtable_sampler_functions(brw
);
619 brw
->vtbl
.emit_depth_stencil_hiz
= brw_emit_depth_stencil_hiz
;
622 brw_init_driver_functions(brw
, &functions
);
625 functions
.GetGraphicsResetStatus
= brw_get_graphics_reset_status
;
627 struct gl_context
*ctx
= &brw
->ctx
;
629 if (mesaVis
== NULL
) {
630 memset(&visual
, 0, sizeof visual
);
634 if (!_mesa_initialize_context(ctx
, api
, mesaVis
, shareCtx
, &functions
)) {
635 *dri_ctx_error
= __DRI_CTX_ERROR_NO_MEMORY
;
636 printf("%s: failed to init mesa context\n", __FUNCTION__
);
637 intelDestroyContext(driContextPriv
);
641 driContextSetFlags(ctx
, flags
);
643 /* Initialize the software rasterizer and helper modules.
645 * As of GL 3.1 core, the gen4+ driver doesn't need the swrast context for
646 * software fallbacks (which we have to support on legacy GL to do weird
647 * glDrawPixels(), glBitmap(), and other functions).
649 if (api
!= API_OPENGL_CORE
&& api
!= API_OPENGLES2
) {
650 _swrast_CreateContext(ctx
);
653 _vbo_CreateContext(ctx
);
654 if (ctx
->swrast_context
) {
655 _tnl_CreateContext(ctx
);
656 TNL_CONTEXT(ctx
)->Driver
.RunPipeline
= _tnl_run_pipeline
;
657 _swsetup_CreateContext(ctx
);
659 /* Configure swrast to match hardware characteristics: */
660 _swrast_allow_pixel_fog(ctx
, false);
661 _swrast_allow_vertex_fog(ctx
, true);
664 _mesa_meta_init(ctx
);
666 brw_process_driconf_options(brw
);
667 brw_process_intel_debug_variable(brw
);
668 brw_initialize_context_constants(brw
);
670 ctx
->Const
.ResetStrategy
= notify_reset
671 ? GL_LOSE_CONTEXT_ON_RESET_ARB
: GL_NO_RESET_NOTIFICATION_ARB
;
673 /* Reinitialize the context point state. It depends on ctx->Const values. */
674 _mesa_init_point(ctx
);
676 intel_batchbuffer_init(brw
);
680 intelInitExtensions(ctx
);
685 /* Create a new hardware context. Using a hardware context means that
686 * our GPU state will be saved/restored on context switch, allowing us
687 * to assume that the GPU is in the same state we left it in.
689 * This is required for transform feedback buffer offsets, query objects,
690 * and also allows us to reduce how much state we have to emit.
692 brw
->hw_ctx
= drm_intel_gem_context_create(brw
->bufmgr
);
695 fprintf(stderr
, "Gen6+ requires Kernel 3.6 or later.\n");
696 intelDestroyContext(driContextPriv
);
701 brw_init_surface_formats(brw
);
703 if (brw
->is_g4x
|| brw
->gen
>= 5) {
704 brw
->CMD_VF_STATISTICS
= GM45_3DSTATE_VF_STATISTICS
;
705 brw
->CMD_PIPELINE_SELECT
= CMD_PIPELINE_SELECT_GM45
;
707 brw
->CMD_VF_STATISTICS
= GEN4_3DSTATE_VF_STATISTICS
;
708 brw
->CMD_PIPELINE_SELECT
= CMD_PIPELINE_SELECT_965
;
711 brw
->max_vs_threads
= devinfo
->max_vs_threads
;
712 brw
->max_gs_threads
= devinfo
->max_gs_threads
;
713 brw
->max_wm_threads
= devinfo
->max_wm_threads
;
714 brw
->urb
.size
= devinfo
->urb
.size
;
715 brw
->urb
.min_vs_entries
= devinfo
->urb
.min_vs_entries
;
716 brw
->urb
.max_vs_entries
= devinfo
->urb
.max_vs_entries
;
717 brw
->urb
.max_gs_entries
= devinfo
->urb
.max_gs_entries
;
719 /* Estimate the size of the mappable aperture into the GTT. There's an
720 * ioctl to get the whole GTT size, but not one to get the mappable subset.
721 * It turns out it's basically always 256MB, though some ancient hardware
724 uint32_t gtt_size
= 256 * 1024 * 1024;
726 /* We don't want to map two objects such that a memcpy between them would
727 * just fault one mapping in and then the other over and over forever. So
728 * we would need to divide the GTT size by 2. Additionally, some GTT is
729 * taken up by things like the framebuffer and the ringbuffer and such, so
730 * be more conservative.
732 brw
->max_gtt_map_object_size
= gtt_size
/ 4;
735 brw
->urb
.gen6_gs_previously_active
= false;
737 brw
->prim_restart
.in_progress
= false;
738 brw
->prim_restart
.enable_cut_index
= false;
739 brw
->gs
.enabled
= false;
742 brw
->curbe
.last_buf
= calloc(1, 4096);
743 brw
->curbe
.next_buf
= calloc(1, 4096);
746 ctx
->VertexProgram
._MaintainTnlProgram
= true;
747 ctx
->FragmentProgram
._MaintainTexEnvProgram
= true;
749 brw_draw_init( brw
);
751 if ((flags
& __DRI_CTX_FLAG_DEBUG
) != 0) {
752 /* Turn on some extra GL_ARB_debug_output generation. */
753 brw
->perf_debug
= true;
756 if ((flags
& __DRI_CTX_FLAG_ROBUST_BUFFER_ACCESS
) != 0)
757 ctx
->Const
.ContextFlags
|= GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB
;
759 brw_fs_alloc_reg_sets(brw
);
760 brw_vec4_alloc_reg_set(brw
);
762 if (INTEL_DEBUG
& DEBUG_SHADER_TIME
)
763 brw_init_shader_time(brw
);
765 _mesa_compute_version(ctx
);
767 _mesa_initialize_dispatch_tables(ctx
);
768 _mesa_initialize_vbo_vtxfmt(ctx
);
770 if (ctx
->Extensions
.AMD_performance_monitor
) {
771 brw_init_performance_monitors(brw
);
778 intelDestroyContext(__DRIcontext
* driContextPriv
)
780 struct brw_context
*brw
=
781 (struct brw_context
*) driContextPriv
->driverPrivate
;
782 struct gl_context
*ctx
= &brw
->ctx
;
784 assert(brw
); /* should never be null */
788 /* Dump a final BMP in case the application doesn't call SwapBuffers */
789 if (INTEL_DEBUG
& DEBUG_AUB
) {
790 intel_batchbuffer_flush(brw
);
791 aub_dump_bmp(&brw
->ctx
);
794 _mesa_meta_free(&brw
->ctx
);
796 if (INTEL_DEBUG
& DEBUG_SHADER_TIME
) {
797 /* Force a report. */
798 brw
->shader_time
.report_time
= 0;
800 brw_collect_and_report_shader_time(brw
);
801 brw_destroy_shader_time(brw
);
804 brw_destroy_state(brw
);
805 brw_draw_destroy(brw
);
807 drm_intel_bo_unreference(brw
->curbe
.curbe_bo
);
808 drm_intel_bo_unreference(brw
->vs
.base
.const_bo
);
809 drm_intel_bo_unreference(brw
->wm
.base
.const_bo
);
811 free(brw
->curbe
.last_buf
);
812 free(brw
->curbe
.next_buf
);
814 drm_intel_gem_context_destroy(brw
->hw_ctx
);
816 if (ctx
->swrast_context
) {
817 _swsetup_DestroyContext(&brw
->ctx
);
818 _tnl_DestroyContext(&brw
->ctx
);
820 _vbo_DestroyContext(&brw
->ctx
);
822 if (ctx
->swrast_context
)
823 _swrast_DestroyContext(&brw
->ctx
);
825 intel_batchbuffer_free(brw
);
827 drm_intel_bo_unreference(brw
->first_post_swapbuffers_batch
);
828 brw
->first_post_swapbuffers_batch
= NULL
;
830 driDestroyOptionCache(&brw
->optionCache
);
832 /* free the Mesa context */
833 _mesa_free_context_data(&brw
->ctx
);
836 driContextPriv
->driverPrivate
= NULL
;
840 intelUnbindContext(__DRIcontext
* driContextPriv
)
842 /* Unset current context and dispath table */
843 _mesa_make_current(NULL
, NULL
, NULL
);
849 * Fixes up the context for GLES23 with our default-to-sRGB-capable behavior
850 * on window system framebuffers.
852 * Desktop GL is fairly reasonable in its handling of sRGB: You can ask if
853 * your renderbuffer can do sRGB encode, and you can flip a switch that does
854 * sRGB encode if the renderbuffer can handle it. You can ask specifically
855 * for a visual where you're guaranteed to be capable, but it turns out that
856 * everyone just makes all their ARGB8888 visuals capable and doesn't offer
857 * incapable ones, becuase there's no difference between the two in resources
858 * used. Applications thus get built that accidentally rely on the default
859 * visual choice being sRGB, so we make ours sRGB capable. Everything sounds
862 * But for GLES2/3, they decided that it was silly to not turn on sRGB encode
863 * for sRGB renderbuffers you made with the GL_EXT_texture_sRGB equivalent.
864 * So they removed the enable knob and made it "if the renderbuffer is sRGB
865 * capable, do sRGB encode". Then, for your window system renderbuffers, you
866 * can ask for sRGB visuals and get sRGB encode, or not ask for sRGB visuals
867 * and get no sRGB encode (assuming that both kinds of visual are available).
868 * Thus our choice to support sRGB by default on our visuals for desktop would
869 * result in broken rendering of GLES apps that aren't expecting sRGB encode.
871 * Unfortunately, renderbuffer setup happens before a context is created. So
872 * in intel_screen.c we always set up sRGB, and here, if you're a GLES2/3
873 * context (without an sRGB visual, though we don't have sRGB visuals exposed
874 * yet), we go turn that back off before anyone finds out.
877 intel_gles3_srgb_workaround(struct brw_context
*brw
,
878 struct gl_framebuffer
*fb
)
880 struct gl_context
*ctx
= &brw
->ctx
;
882 if (_mesa_is_desktop_gl(ctx
) || !fb
->Visual
.sRGBCapable
)
885 /* Some day when we support the sRGB capable bit on visuals available for
886 * GLES, we'll need to respect that and not disable things here.
888 fb
->Visual
.sRGBCapable
= false;
889 for (int i
= 0; i
< BUFFER_COUNT
; i
++) {
890 if (fb
->Attachment
[i
].Renderbuffer
&&
891 fb
->Attachment
[i
].Renderbuffer
->Format
== MESA_FORMAT_SARGB8
) {
892 fb
->Attachment
[i
].Renderbuffer
->Format
= MESA_FORMAT_ARGB8888
;
898 intelMakeCurrent(__DRIcontext
* driContextPriv
,
899 __DRIdrawable
* driDrawPriv
,
900 __DRIdrawable
* driReadPriv
)
902 struct brw_context
*brw
;
903 GET_CURRENT_CONTEXT(curCtx
);
906 brw
= (struct brw_context
*) driContextPriv
->driverPrivate
;
910 /* According to the glXMakeCurrent() man page: "Pending commands to
911 * the previous context, if any, are flushed before it is released."
912 * But only flush if we're actually changing contexts.
914 if (brw_context(curCtx
) && brw_context(curCtx
) != brw
) {
918 if (driContextPriv
) {
919 struct gl_context
*ctx
= &brw
->ctx
;
920 struct gl_framebuffer
*fb
, *readFb
;
922 if (driDrawPriv
== NULL
&& driReadPriv
== NULL
) {
923 fb
= _mesa_get_incomplete_framebuffer();
924 readFb
= _mesa_get_incomplete_framebuffer();
926 fb
= driDrawPriv
->driverPrivate
;
927 readFb
= driReadPriv
->driverPrivate
;
928 driContextPriv
->dri2
.draw_stamp
= driDrawPriv
->dri2
.stamp
- 1;
929 driContextPriv
->dri2
.read_stamp
= driReadPriv
->dri2
.stamp
- 1;
932 /* The sRGB workaround changes the renderbuffer's format. We must change
933 * the format before the renderbuffer's miptree get's allocated, otherwise
934 * the formats of the renderbuffer and its miptree will differ.
936 intel_gles3_srgb_workaround(brw
, fb
);
937 intel_gles3_srgb_workaround(brw
, readFb
);
939 /* If the context viewport hasn't been initialized, force a call out to
940 * the loader to get buffers so we have a drawable size for the initial
942 if (!brw
->ctx
.ViewportInitialized
)
943 intel_prepare_render(brw
);
945 _mesa_make_current(ctx
, fb
, readFb
);
947 _mesa_make_current(NULL
, NULL
, NULL
);
954 intel_resolve_for_dri2_flush(struct brw_context
*brw
,
955 __DRIdrawable
*drawable
)
958 /* MSAA and fast color clear are not supported, so don't waste time
959 * checking whether a resolve is needed.
964 struct gl_framebuffer
*fb
= drawable
->driverPrivate
;
965 struct intel_renderbuffer
*rb
;
967 /* Usually, only the back buffer will need to be downsampled. However,
968 * the front buffer will also need it if the user has rendered into it.
970 static const gl_buffer_index buffers
[2] = {
975 for (int i
= 0; i
< 2; ++i
) {
976 rb
= intel_get_renderbuffer(fb
, buffers
[i
]);
977 if (rb
== NULL
|| rb
->mt
== NULL
)
979 if (rb
->mt
->num_samples
<= 1)
980 intel_miptree_resolve_color(brw
, rb
->mt
);
982 intel_miptree_downsample(brw
, rb
->mt
);
987 intel_bits_per_pixel(const struct intel_renderbuffer
*rb
)
989 return _mesa_get_format_bytes(intel_rb_format(rb
)) * 8;
993 intel_query_dri2_buffers(struct brw_context
*brw
,
994 __DRIdrawable
*drawable
,
995 __DRIbuffer
**buffers
,
999 intel_process_dri2_buffer(struct brw_context
*brw
,
1000 __DRIdrawable
*drawable
,
1001 __DRIbuffer
*buffer
,
1002 struct intel_renderbuffer
*rb
,
1003 const char *buffer_name
);
1006 intel_update_image_buffers(struct brw_context
*brw
, __DRIdrawable
*drawable
);
1009 intel_update_dri2_buffers(struct brw_context
*brw
, __DRIdrawable
*drawable
)
1011 struct gl_framebuffer
*fb
= drawable
->driverPrivate
;
1012 struct intel_renderbuffer
*rb
;
1013 __DRIbuffer
*buffers
= NULL
;
1015 const char *region_name
;
1017 /* Set this up front, so that in case our buffers get invalidated
1018 * while we're getting new buffers, we don't clobber the stamp and
1019 * thus ignore the invalidate. */
1020 drawable
->lastStamp
= drawable
->dri2
.stamp
;
1022 if (unlikely(INTEL_DEBUG
& DEBUG_DRI
))
1023 fprintf(stderr
, "enter %s, drawable %p\n", __func__
, drawable
);
1025 intel_query_dri2_buffers(brw
, drawable
, &buffers
, &count
);
1027 if (buffers
== NULL
)
1030 for (i
= 0; i
< count
; i
++) {
1031 switch (buffers
[i
].attachment
) {
1032 case __DRI_BUFFER_FRONT_LEFT
:
1033 rb
= intel_get_renderbuffer(fb
, BUFFER_FRONT_LEFT
);
1034 region_name
= "dri2 front buffer";
1037 case __DRI_BUFFER_FAKE_FRONT_LEFT
:
1038 rb
= intel_get_renderbuffer(fb
, BUFFER_FRONT_LEFT
);
1039 region_name
= "dri2 fake front buffer";
1042 case __DRI_BUFFER_BACK_LEFT
:
1043 rb
= intel_get_renderbuffer(fb
, BUFFER_BACK_LEFT
);
1044 region_name
= "dri2 back buffer";
1047 case __DRI_BUFFER_DEPTH
:
1048 case __DRI_BUFFER_HIZ
:
1049 case __DRI_BUFFER_DEPTH_STENCIL
:
1050 case __DRI_BUFFER_STENCIL
:
1051 case __DRI_BUFFER_ACCUM
:
1054 "unhandled buffer attach event, attachment type %d\n",
1055 buffers
[i
].attachment
);
1059 intel_process_dri2_buffer(brw
, drawable
, &buffers
[i
], rb
, region_name
);
1065 intel_update_renderbuffers(__DRIcontext
*context
, __DRIdrawable
*drawable
)
1067 struct brw_context
*brw
= context
->driverPrivate
;
1068 __DRIscreen
*screen
= brw
->intelScreen
->driScrnPriv
;
1070 /* Set this up front, so that in case our buffers get invalidated
1071 * while we're getting new buffers, we don't clobber the stamp and
1072 * thus ignore the invalidate. */
1073 drawable
->lastStamp
= drawable
->dri2
.stamp
;
1075 if (unlikely(INTEL_DEBUG
& DEBUG_DRI
))
1076 fprintf(stderr
, "enter %s, drawable %p\n", __func__
, drawable
);
1078 if (screen
->image
.loader
)
1079 intel_update_image_buffers(brw
, drawable
);
1081 intel_update_dri2_buffers(brw
, drawable
);
1083 driUpdateFramebufferSize(&brw
->ctx
, drawable
);
1087 * intel_prepare_render should be called anywhere that curent read/drawbuffer
1088 * state is required.
1091 intel_prepare_render(struct brw_context
*brw
)
1093 __DRIcontext
*driContext
= brw
->driContext
;
1094 __DRIdrawable
*drawable
;
1096 drawable
= driContext
->driDrawablePriv
;
1097 if (drawable
&& drawable
->dri2
.stamp
!= driContext
->dri2
.draw_stamp
) {
1098 if (drawable
->lastStamp
!= drawable
->dri2
.stamp
)
1099 intel_update_renderbuffers(driContext
, drawable
);
1100 driContext
->dri2
.draw_stamp
= drawable
->dri2
.stamp
;
1103 drawable
= driContext
->driReadablePriv
;
1104 if (drawable
&& drawable
->dri2
.stamp
!= driContext
->dri2
.read_stamp
) {
1105 if (drawable
->lastStamp
!= drawable
->dri2
.stamp
)
1106 intel_update_renderbuffers(driContext
, drawable
);
1107 driContext
->dri2
.read_stamp
= drawable
->dri2
.stamp
;
1110 /* If we're currently rendering to the front buffer, the rendering
1111 * that will happen next will probably dirty the front buffer. So
1112 * mark it as dirty here.
1114 if (brw
->is_front_buffer_rendering
)
1115 brw
->front_buffer_dirty
= true;
1117 /* Wait for the swapbuffers before the one we just emitted, so we
1118 * don't get too many swaps outstanding for apps that are GPU-heavy
1119 * but not CPU-heavy.
1121 * We're using intelDRI2Flush (called from the loader before
1122 * swapbuffer) and glFlush (for front buffer rendering) as the
1123 * indicator that a frame is done and then throttle when we get
1124 * here as we prepare to render the next frame. At this point for
1125 * round trips for swap/copy and getting new buffers are done and
1126 * we'll spend less time waiting on the GPU.
1128 * Unfortunately, we don't have a handle to the batch containing
1129 * the swap, and getting our hands on that doesn't seem worth it,
1130 * so we just us the first batch we emitted after the last swap.
1132 if (brw
->need_throttle
&& brw
->first_post_swapbuffers_batch
) {
1133 if (!brw
->disable_throttling
)
1134 drm_intel_bo_wait_rendering(brw
->first_post_swapbuffers_batch
);
1135 drm_intel_bo_unreference(brw
->first_post_swapbuffers_batch
);
1136 brw
->first_post_swapbuffers_batch
= NULL
;
1137 brw
->need_throttle
= false;
1142 * \brief Query DRI2 to obtain a DRIdrawable's buffers.
1144 * To determine which DRI buffers to request, examine the renderbuffers
1145 * attached to the drawable's framebuffer. Then request the buffers with
1146 * DRI2GetBuffers() or DRI2GetBuffersWithFormat().
1148 * This is called from intel_update_renderbuffers().
1150 * \param drawable Drawable whose buffers are queried.
1151 * \param buffers [out] List of buffers returned by DRI2 query.
1152 * \param buffer_count [out] Number of buffers returned.
1154 * \see intel_update_renderbuffers()
1155 * \see DRI2GetBuffers()
1156 * \see DRI2GetBuffersWithFormat()
1159 intel_query_dri2_buffers(struct brw_context
*brw
,
1160 __DRIdrawable
*drawable
,
1161 __DRIbuffer
**buffers
,
1164 __DRIscreen
*screen
= brw
->intelScreen
->driScrnPriv
;
1165 struct gl_framebuffer
*fb
= drawable
->driverPrivate
;
1167 unsigned attachments
[8];
1169 struct intel_renderbuffer
*front_rb
;
1170 struct intel_renderbuffer
*back_rb
;
1172 front_rb
= intel_get_renderbuffer(fb
, BUFFER_FRONT_LEFT
);
1173 back_rb
= intel_get_renderbuffer(fb
, BUFFER_BACK_LEFT
);
1175 memset(attachments
, 0, sizeof(attachments
));
1176 if ((brw
->is_front_buffer_rendering
||
1177 brw
->is_front_buffer_reading
||
1178 !back_rb
) && front_rb
) {
1179 /* If a fake front buffer is in use, then querying for
1180 * __DRI_BUFFER_FRONT_LEFT will cause the server to copy the image from
1181 * the real front buffer to the fake front buffer. So before doing the
1182 * query, we need to make sure all the pending drawing has landed in the
1183 * real front buffer.
1185 intel_batchbuffer_flush(brw
);
1186 intel_flush_front(&brw
->ctx
);
1188 attachments
[i
++] = __DRI_BUFFER_FRONT_LEFT
;
1189 attachments
[i
++] = intel_bits_per_pixel(front_rb
);
1190 } else if (front_rb
&& brw
->front_buffer_dirty
) {
1191 /* We have pending front buffer rendering, but we aren't querying for a
1192 * front buffer. If the front buffer we have is a fake front buffer,
1193 * the X server is going to throw it away when it processes the query.
1194 * So before doing the query, make sure all the pending drawing has
1195 * landed in the real front buffer.
1197 intel_batchbuffer_flush(brw
);
1198 intel_flush_front(&brw
->ctx
);
1202 attachments
[i
++] = __DRI_BUFFER_BACK_LEFT
;
1203 attachments
[i
++] = intel_bits_per_pixel(back_rb
);
1206 assert(i
<= ARRAY_SIZE(attachments
));
1208 *buffers
= screen
->dri2
.loader
->getBuffersWithFormat(drawable
,
1213 drawable
->loaderPrivate
);
1217 * \brief Assign a DRI buffer's DRM region to a renderbuffer.
1219 * This is called from intel_update_renderbuffers().
1222 * DRI buffers whose attachment point is DRI2BufferStencil or
1223 * DRI2BufferDepthStencil are handled as special cases.
1225 * \param buffer_name is a human readable name, such as "dri2 front buffer",
1226 * that is passed to intel_region_alloc_for_handle().
1228 * \see intel_update_renderbuffers()
1229 * \see intel_region_alloc_for_handle()
1232 intel_process_dri2_buffer(struct brw_context
*brw
,
1233 __DRIdrawable
*drawable
,
1234 __DRIbuffer
*buffer
,
1235 struct intel_renderbuffer
*rb
,
1236 const char *buffer_name
)
1238 struct intel_region
*region
= NULL
;
1243 unsigned num_samples
= rb
->Base
.Base
.NumSamples
;
1245 /* We try to avoid closing and reopening the same BO name, because the first
1246 * use of a mapping of the buffer involves a bunch of page faulting which is
1247 * moderately expensive.
1249 if (num_samples
== 0) {
1252 rb
->mt
->region
->name
== buffer
->name
)
1256 rb
->mt
->singlesample_mt
&&
1257 rb
->mt
->singlesample_mt
->region
&&
1258 rb
->mt
->singlesample_mt
->region
->name
== buffer
->name
)
1262 if (unlikely(INTEL_DEBUG
& DEBUG_DRI
)) {
1264 "attaching buffer %d, at %d, cpp %d, pitch %d\n",
1265 buffer
->name
, buffer
->attachment
,
1266 buffer
->cpp
, buffer
->pitch
);
1269 intel_miptree_release(&rb
->mt
);
1270 region
= intel_region_alloc_for_handle(brw
->intelScreen
,
1280 rb
->mt
= intel_miptree_create_for_dri2_buffer(brw
,
1282 intel_rb_format(rb
),
1285 intel_region_release(®ion
);
1289 * \brief Query DRI image loader to obtain a DRIdrawable's buffers.
1291 * To determine which DRI buffers to request, examine the renderbuffers
1292 * attached to the drawable's framebuffer. Then request the buffers from
1295 * This is called from intel_update_renderbuffers().
1297 * \param drawable Drawable whose buffers are queried.
1298 * \param buffers [out] List of buffers returned by DRI2 query.
1299 * \param buffer_count [out] Number of buffers returned.
1301 * \see intel_update_renderbuffers()
1305 intel_update_image_buffer(struct brw_context
*intel
,
1306 __DRIdrawable
*drawable
,
1307 struct intel_renderbuffer
*rb
,
1309 enum __DRIimageBufferMask buffer_type
)
1311 struct intel_region
*region
= buffer
->region
;
1316 unsigned num_samples
= rb
->Base
.Base
.NumSamples
;
1318 /* Check and see if we're already bound to the right
1321 if (num_samples
== 0) {
1324 rb
->mt
->region
->bo
== region
->bo
)
1328 rb
->mt
->singlesample_mt
&&
1329 rb
->mt
->singlesample_mt
->region
&&
1330 rb
->mt
->singlesample_mt
->region
->bo
== region
->bo
)
1334 intel_miptree_release(&rb
->mt
);
1335 rb
->mt
= intel_miptree_create_for_image_buffer(intel
,
1337 intel_rb_format(rb
),
1343 intel_update_image_buffers(struct brw_context
*brw
, __DRIdrawable
*drawable
)
1345 struct gl_framebuffer
*fb
= drawable
->driverPrivate
;
1346 __DRIscreen
*screen
= brw
->intelScreen
->driScrnPriv
;
1347 struct intel_renderbuffer
*front_rb
;
1348 struct intel_renderbuffer
*back_rb
;
1349 struct __DRIimageList images
;
1350 unsigned int format
;
1351 uint32_t buffer_mask
= 0;
1353 front_rb
= intel_get_renderbuffer(fb
, BUFFER_FRONT_LEFT
);
1354 back_rb
= intel_get_renderbuffer(fb
, BUFFER_BACK_LEFT
);
1357 format
= intel_rb_format(back_rb
);
1359 format
= intel_rb_format(front_rb
);
1363 if ((brw
->is_front_buffer_rendering
|| brw
->is_front_buffer_reading
|| !back_rb
) && front_rb
)
1364 buffer_mask
|= __DRI_IMAGE_BUFFER_FRONT
;
1367 buffer_mask
|= __DRI_IMAGE_BUFFER_BACK
;
1369 (*screen
->image
.loader
->getBuffers
) (drawable
,
1370 driGLFormatToImageFormat(format
),
1371 &drawable
->dri2
.stamp
,
1372 drawable
->loaderPrivate
,
1376 if (images
.image_mask
& __DRI_IMAGE_BUFFER_FRONT
) {
1377 drawable
->w
= images
.front
->width
;
1378 drawable
->h
= images
.front
->height
;
1379 intel_update_image_buffer(brw
,
1383 __DRI_IMAGE_BUFFER_FRONT
);
1385 if (images
.image_mask
& __DRI_IMAGE_BUFFER_BACK
) {
1386 drawable
->w
= images
.back
->width
;
1387 drawable
->h
= images
.back
->height
;
1388 intel_update_image_buffer(brw
,
1392 __DRI_IMAGE_BUFFER_BACK
);