1 /**************************************************************************
3 * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
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:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
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 TUNGSTEN GRAPHICS 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.
26 **************************************************************************/
33 #include "intel_fbo.h"
34 #include "intel_screen.h"
35 #include "intel_span.h"
36 #include "intel_regions.h"
37 #include "intel_ioctl.h"
38 #include "intel_tex.h"
40 #include "swrast/swrast.h"
43 * Deal with tiled surfaces
47 /* These are pre-965 tile swizzling functions -- power of two widths */
48 static uintptr_t x_tile_swizzle_pow2 (uintptr_t addr
, int n
)
51 uintptr_t base_mask
= (((~0) << (n
+ 4)) | 0xff);
52 uintptr_t x_mask
= ((~0) << 12) & ~base_mask
;
54 a
= ((a
& base_mask
) |
55 ((a
>> (n
-8)) & 0x7) |
57 _mesa_printf ("x_swizzle %08x (base %x yrow %x tile#x %x xsword %x byte %x) %08x\n",
60 (addr
>> (n
+ 1)) & 0x7,
61 (addr
>> 9) & ((1 << (n
-8)) - 1),
68 static uintptr_t y_tile_swizzle_pow2 (uintptr_t addr
, int n
)
70 uintptr_t a
= (uintptr_t) addr
;
71 uintptr_t base_mask
= (((~0) << (n
+ 6)) | 0xf);
72 uintptr_t x_mask
= ((~0) << 9) & ~base_mask
;
74 a
= ((a
& base_mask
) |
75 ((a
>> (n
-3)) & 0x1f) |
77 _mesa_printf ("y_swizzle %08x (base %x yrow %x tile#x %x xoword %x byte %x) %08x\n",
80 (addr
>> (n
+ 1)) & 0x01f,
81 (addr
>> 7) & ((1 << (n
-6)) - 1),
89 static GLubyte
*x_tile_swizzle(struct intel_renderbuffer
*irb
, struct intel_context
*intel
,
92 GLubyte
*buf
= (GLubyte
*) irb
->pfMap
;
95 int x_tile_off
, y_tile_off
;
96 int x_tile_number
, y_tile_number
;
97 int tile_off
, tile_base
;
99 tile_stride
= (irb
->pfPitch
* irb
->region
->cpp
) << 3;
104 xbyte
= x
* irb
->region
->cpp
;
106 x_tile_off
= xbyte
& 0x1ff;
110 /* The documentation says that X tile layout is arranged in 8 512-byte
111 * lines of pixel data. However, that doesn't appear to be the case
112 * on GM965, tested by drawing a 128x8 quad in no_rast mode. For lines
113 * 1,2,4, and 7 of each tile, each consecutive pair of 64-byte spans
114 * has the locations of those spans swapped.
116 switch (y_tile_off
) {
128 x_tile_number
= xbyte
>> 9;
129 y_tile_number
= y
>> 3;
131 tile_off
= (y_tile_off
<< 9) + x_tile_off
;
132 tile_base
= (x_tile_number
<< 12) + y_tile_number
* tile_stride
;
135 printf("(%d,%d) -> %d + %d = %d (pitch = %d, tstride = %d)\n",
136 x
, y
, tile_off
, tile_base
,
137 tile_off
+ tile_base
,
138 irb
->pfPitch
, tile_stride
);
141 return buf
+ tile_base
+ tile_off
;
144 static GLubyte
*y_tile_swizzle(struct intel_renderbuffer
*irb
, struct intel_context
*intel
,
147 GLubyte
*buf
= (GLubyte
*) irb
->pfMap
;
150 int x_tile_off
, y_tile_off
;
151 int x_tile_number
, y_tile_number
;
152 int tile_off
, tile_base
;
154 tile_stride
= (irb
->pfPitch
* irb
->region
->cpp
) << 3;
159 xbyte
= x
* irb
->region
->cpp
;
161 x_tile_off
= xbyte
& 0x7f;
162 y_tile_off
= y
& 0x1f;
164 x_tile_number
= xbyte
>> 7;
165 y_tile_number
= y
>> 5;
167 tile_off
= ((x_tile_off
& ~0xf) << 5) + (y_tile_off
<< 4) + (x_tile_off
& 0xf);
168 tile_base
= (x_tile_number
<< 12) + y_tile_number
* tile_stride
;
170 return buf
+ tile_base
+ tile_off
;
174 break intelWriteRGBASpan_ARGB8888
181 struct intel_context *intel = intel_context(ctx); \
182 struct intel_renderbuffer *irb = intel_renderbuffer(rb); \
183 const GLint yScale = irb->RenderToTexture ? 1 : -1; \
184 const GLint yBias = irb->RenderToTexture ? 0 : irb->Base.Height - 1; \
185 GLubyte *buf = (GLubyte *) irb->pfMap \
186 + (intel->drawY * irb->pfPitch + intel->drawX) * irb->region->cpp;\
189 (void) p; (void) buf;
191 /* XXX FBO: this is identical to the macro in spantmp2.h except we get
192 * the cliprect info from the context, not the driDrawable.
193 * Move this into spantmp2.h someday.
195 #define HW_CLIPLOOP() \
197 int _nc = intel->numClipRects; \
199 int minx = intel->pClipRects[_nc].x1 - intel->drawX; \
200 int miny = intel->pClipRects[_nc].y1 - intel->drawY; \
201 int maxx = intel->pClipRects[_nc].x2 - intel->drawX; \
202 int maxy = intel->pClipRects[_nc].y2 - intel->drawY;
208 #define Y_FLIP(_y) ((_y) * yScale + yBias)
210 /* XXX with GEM, these need to tell the kernel */
215 /* 16 bit, RGB565 color spanline and pixel functions
217 #define SPANTMP_PIXEL_FMT GL_RGB
218 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_5_6_5
220 #define TAG(x) intel##x##_RGB565
221 #define TAG2(x,y) intel##x##_RGB565##y
222 #define GET_PTR(X,Y) (buf + ((Y) * irb->pfPitch + (X)) * 2)
223 #include "spantmp2.h"
225 /* 32 bit, ARGB8888 color spanline and pixel functions
227 #define SPANTMP_PIXEL_FMT GL_BGRA
228 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
230 #define TAG(x) intel##x##_ARGB8888
231 #define TAG2(x,y) intel##x##_ARGB8888##y
232 #define GET_PTR(X,Y) (buf + ((Y) * irb->pfPitch + (X)) * 4)
233 #include "spantmp2.h"
235 /* 16 bit RGB565 color tile spanline and pixel functions
238 #define SPANTMP_PIXEL_FMT GL_RGB
239 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_5_6_5
241 #define TAG(x) intel_XTile_##x##_RGB565
242 #define TAG2(x,y) intel_XTile_##x##_RGB565##y
243 #define GET_PTR(X,Y) x_tile_swizzle(irb, intel, X, Y)
244 #include "spantmp2.h"
246 #define SPANTMP_PIXEL_FMT GL_RGB
247 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_SHORT_5_6_5
249 #define TAG(x) intel_YTile_##x##_RGB565
250 #define TAG2(x,y) intel_YTile_##x##_RGB565##y
251 #define GET_PTR(X,Y) y_tile_swizzle(irb, intel, X, Y)
252 #include "spantmp2.h"
254 /* 32 bit ARGB888 color tile spanline and pixel functions
257 #define SPANTMP_PIXEL_FMT GL_BGRA
258 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
260 #define TAG(x) intel_XTile_##x##_ARGB8888
261 #define TAG2(x,y) intel_XTile_##x##_ARGB8888##y
262 #define GET_PTR(X,Y) x_tile_swizzle(irb, intel, X, Y)
263 #include "spantmp2.h"
265 #define SPANTMP_PIXEL_FMT GL_BGRA
266 #define SPANTMP_PIXEL_TYPE GL_UNSIGNED_INT_8_8_8_8_REV
268 #define TAG(x) intel_YTile_##x##_ARGB8888
269 #define TAG2(x,y) intel_YTile_##x##_ARGB8888##y
270 #define GET_PTR(X,Y) y_tile_swizzle(irb, intel, X, Y)
271 #include "spantmp2.h"
273 #define LOCAL_DEPTH_VARS \
274 struct intel_context *intel = intel_context(ctx); \
275 struct intel_renderbuffer *irb = intel_renderbuffer(rb); \
276 const GLuint pitch = irb->pfPitch/***XXX region->pitch*/; /* in pixels */ \
277 const GLint yScale = irb->RenderToTexture ? 1 : -1; \
278 const GLint yBias = irb->RenderToTexture ? 0 : irb->Base.Height - 1; \
279 char *buf = (char *) irb->pfMap/*XXX use region->map*/ + \
280 (intel->drawY * pitch + intel->drawX) * irb->region->cpp; (void) buf;
283 #define LOCAL_STENCIL_VARS LOCAL_DEPTH_VARS
286 ** 16-bit depthbuffer functions.
288 #define WRITE_DEPTH( _x, _y, d ) \
289 ((GLushort *)buf)[(_x) + (_y) * pitch] = d;
291 #define READ_DEPTH( d, _x, _y ) \
292 d = ((GLushort *)buf)[(_x) + (_y) * pitch];
295 #define TAG(x) intel##x##_z16
296 #include "depthtmp.h"
300 ** 16-bit x tile depthbuffer functions.
302 #define WRITE_DEPTH( _x, _y, d ) \
303 (*((GLushort *)x_tile_swizzle (irb, intel, _x, _y)) = d)
305 #define READ_DEPTH( d, _x, _y ) \
306 d = *((GLushort *)x_tile_swizzle (irb, intel, _x, _y))
309 #define TAG(x) intel_XTile_##x##_z16
310 #include "depthtmp.h"
313 ** 16-bit y tile depthbuffer functions.
315 #define WRITE_DEPTH( _x, _y, d ) \
316 (*((GLushort *)y_tile_swizzle (irb, intel, _x, _y)) = d)
318 #define READ_DEPTH( d, _x, _y ) \
319 (d = *((GLushort *)y_tile_swizzle (irb, intel, _x, _y)))
322 #define TAG(x) intel_YTile_##x##_z16
323 #include "depthtmp.h"
327 ** 24/8-bit interleaved depth/stencil functions
328 ** Note: we're actually reading back combined depth+stencil values.
329 ** The wrappers in main/depthstencil.c are used to extract the depth
330 ** and stencil values.
332 /* Change ZZZS -> SZZZ */
333 #define WRITE_DEPTH( _x, _y, d ) { \
334 GLuint tmp = ((d) >> 8) | ((d) << 24); \
335 ((GLuint *)buf)[(_x) + (_y) * pitch] = tmp; \
338 /* Change SZZZ -> ZZZS */
339 #define READ_DEPTH( d, _x, _y ) { \
340 GLuint tmp = ((GLuint *)buf)[(_x) + (_y) * pitch]; \
341 d = (tmp << 8) | (tmp >> 24); \
344 #define TAG(x) intel##x##_z24_s8
345 #include "depthtmp.h"
349 ** 24/8-bit x-tile interleaved depth/stencil functions
350 ** Note: we're actually reading back combined depth+stencil values.
351 ** The wrappers in main/depthstencil.c are used to extract the depth
352 ** and stencil values.
354 /* Change ZZZS -> SZZZ */
355 #define WRITE_DEPTH( _x, _y, d ) { \
356 GLuint tmp = ((d) >> 8) | ((d) << 24); \
357 *((GLuint *)x_tile_swizzle (irb, intel, _x, _y)) = tmp; \
360 /* Change SZZZ -> ZZZS */
361 #define READ_DEPTH( d, _x, _y ) { \
362 GLuint tmp = *((GLuint *)x_tile_swizzle (irb, intel, _x, _y)); \
363 d = (tmp << 8) | (tmp >> 24); \
366 #define TAG(x) intel_XTile_##x##_z24_s8
367 #include "depthtmp.h"
370 ** 24/8-bit y-tile interleaved depth/stencil functions
371 ** Note: we're actually reading back combined depth+stencil values.
372 ** The wrappers in main/depthstencil.c are used to extract the depth
373 ** and stencil values.
375 /* Change ZZZS -> SZZZ */
376 #define WRITE_DEPTH( _x, _y, d ) { \
377 GLuint tmp = ((d) >> 8) | ((d) << 24); \
378 *((GLuint *)y_tile_swizzle (irb, intel, _x, _y)) = tmp; \
381 /* Change SZZZ -> ZZZS */
382 #define READ_DEPTH( d, _x, _y ) { \
383 GLuint tmp = *((GLuint *)y_tile_swizzle (irb, intel, _x, _y)); \
384 d = (tmp << 8) | (tmp >> 24); \
387 #define TAG(x) intel_YTile_##x##_z24_s8
388 #include "depthtmp.h"
392 ** 8-bit stencil function (XXX FBO: This is obsolete)
394 #define WRITE_STENCIL( _x, _y, d ) { \
395 GLuint tmp = ((GLuint *)buf)[(_x) + (_y) * pitch]; \
397 tmp |= ((d) << 24); \
398 ((GLuint *) buf)[(_x) + (_y) * pitch] = tmp; \
401 #define READ_STENCIL( d, _x, _y ) \
402 d = ((GLuint *)buf)[(_x) + (_y) * pitch] >> 24;
404 #define TAG(x) intel##x##_z24_s8
405 #include "stenciltmp.h"
408 ** 8-bit x-tile stencil function (XXX FBO: This is obsolete)
410 #define WRITE_STENCIL( _x, _y, d ) { \
411 GLuint *a = (GLuint *) x_tile_swizzle (irb, intel, _x, _y); \
414 tmp |= ((d) << 24); \
418 #define READ_STENCIL( d, _x, _y ) \
419 (d = *((GLuint*) x_tile_swizzle (irb, intel, _x, _y)) >> 24)
421 #define TAG(x) intel_XTile_##x##_z24_s8
422 #include "stenciltmp.h"
425 ** 8-bit y-tile stencil function (XXX FBO: This is obsolete)
427 #define WRITE_STENCIL( _x, _y, d ) { \
428 GLuint *a = (GLuint *) y_tile_swizzle (irb, intel, _x, _y); \
431 tmp |= ((d) << 24); \
435 #define READ_STENCIL( d, _x, _y ) \
436 (d = *((GLuint*) y_tile_swizzle (irb, intel, _x, _y)) >> 24)
438 #define TAG(x) intel_YTile_##x##_z24_s8
439 #include "stenciltmp.h"
444 * Map or unmap all the renderbuffers which we may need during
445 * software rendering.
446 * XXX in the future, we could probably convey extra information to
447 * reduce the number of mappings needed. I.e. if doing a glReadPixels
448 * from the depth buffer, we really only need one mapping.
450 * XXX Rewrite this function someday.
451 * We can probably just loop over all the renderbuffer attachments,
452 * map/unmap all of them, and not worry about the _ColorDrawBuffers
453 * _ColorReadBuffer, _DepthBuffer or _StencilBuffer fields.
456 intel_map_unmap_buffers(struct intel_context
*intel
, GLboolean map
)
458 GLcontext
*ctx
= &intel
->ctx
;
460 struct intel_renderbuffer
*irb
;
462 /* color draw buffers */
463 for (j
= 0; j
< ctx
->DrawBuffer
->_NumColorDrawBuffers
; j
++) {
464 struct gl_renderbuffer
*rb
= ctx
->DrawBuffer
->_ColorDrawBuffers
[j
];
465 irb
= intel_renderbuffer(rb
);
467 /* this is a user-created intel_renderbuffer */
470 intel_region_map(intel
, irb
->region
);
472 intel_region_unmap(intel
, irb
->region
);
473 irb
->pfMap
= irb
->region
->map
;
474 irb
->pfPitch
= irb
->region
->pitch
;
479 /* check for render to textures */
480 for (i
= 0; i
< BUFFER_COUNT
; i
++) {
481 struct gl_renderbuffer_attachment
*att
=
482 ctx
->DrawBuffer
->Attachment
+ i
;
483 struct gl_texture_object
*tex
= att
->Texture
;
485 /* render to texture */
486 ASSERT(att
->Renderbuffer
);
488 struct gl_texture_image
*texImg
;
489 texImg
= tex
->Image
[att
->CubeMapFace
][att
->TextureLevel
];
490 intel_tex_map_images(intel
, intel_texture_object(tex
));
493 intel_tex_unmap_images(intel
, intel_texture_object(tex
));
498 /* color read buffers */
499 irb
= intel_renderbuffer(ctx
->ReadBuffer
->_ColorReadBuffer
);
500 if (irb
&& irb
->region
) {
502 intel_region_map(intel
, irb
->region
);
504 intel_region_unmap(intel
, irb
->region
);
505 irb
->pfMap
= irb
->region
->map
;
506 irb
->pfPitch
= irb
->region
->pitch
;
509 /* Account for front/back color page flipping.
510 * The span routines use the pfMap and pfPitch fields which will
511 * swap the front/back region map/pitch if we're page flipped.
512 * Do this after mapping, above, so the map field is valid.
515 if (map
&& ctx
->DrawBuffer
->Name
== 0) {
516 struct intel_renderbuffer
*irbFront
517 = intel_get_renderbuffer(ctx
->DrawBuffer
, BUFFER_FRONT_LEFT
);
518 struct intel_renderbuffer
*irbBack
519 = intel_get_renderbuffer(ctx
->DrawBuffer
, BUFFER_BACK_LEFT
);
521 /* double buffered */
522 if (intel
->sarea
->pf_current_page
== 0) {
523 irbFront
->pfMap
= irbFront
->region
->map
;
524 irbFront
->pfPitch
= irbFront
->region
->pitch
;
525 irbBack
->pfMap
= irbBack
->region
->map
;
526 irbBack
->pfPitch
= irbBack
->region
->pitch
;
529 irbFront
->pfMap
= irbBack
->region
->map
;
530 irbFront
->pfPitch
= irbBack
->region
->pitch
;
531 irbBack
->pfMap
= irbFront
->region
->map
;
532 irbBack
->pfPitch
= irbFront
->region
->pitch
;
538 /* depth buffer (Note wrapper!) */
539 if (ctx
->DrawBuffer
->_DepthBuffer
) {
540 irb
= intel_renderbuffer(ctx
->DrawBuffer
->_DepthBuffer
->Wrapped
);
541 if (irb
&& irb
->region
) {
543 intel_region_map(intel
, irb
->region
);
544 irb
->pfMap
= irb
->region
->map
;
545 irb
->pfPitch
= irb
->region
->pitch
;
548 intel_region_unmap(intel
, irb
->region
);
549 irb
->pfMap
= irb
->region
->map
;
550 irb
->pfPitch
= irb
->region
->pitch
;
555 /* stencil buffer (Note wrapper!) */
556 if (ctx
->DrawBuffer
->_StencilBuffer
) {
557 irb
= intel_renderbuffer(ctx
->DrawBuffer
->_StencilBuffer
->Wrapped
);
558 if (irb
&& irb
->region
) {
560 intel_region_map(intel
, irb
->region
);
561 irb
->pfMap
= irb
->region
->map
;
562 irb
->pfPitch
= irb
->region
->pitch
;
565 intel_region_unmap(intel
, irb
->region
);
566 irb
->pfMap
= irb
->region
->map
;
567 irb
->pfPitch
= irb
->region
->pitch
;
576 * Prepare for softare rendering. Map current read/draw framebuffers'
577 * renderbuffes and all currently bound texture objects.
579 * Old note: Moved locking out to get reasonable span performance.
582 intelSpanRenderStart(GLcontext
* ctx
)
584 struct intel_context
*intel
= intel_context(ctx
);
587 intelFinish(&intel
->ctx
);
588 LOCK_HARDWARE(intel
);
591 /* Just map the framebuffer and all textures. Bufmgr code will
592 * take care of waiting on the necessary fences:
594 intel_region_map(intel
, intel
->front_region
);
595 intel_region_map(intel
, intel
->back_region
);
596 intel_region_map(intel
, intel
->depth_region
);
599 for (i
= 0; i
< ctx
->Const
.MaxTextureCoordUnits
; i
++) {
600 if (ctx
->Texture
.Unit
[i
]._ReallyEnabled
) {
601 struct gl_texture_object
*texObj
= ctx
->Texture
.Unit
[i
]._Current
;
602 intel_tex_map_images(intel
, intel_texture_object(texObj
));
606 intel_map_unmap_buffers(intel
, GL_TRUE
);
610 * Called when done softare rendering. Unmap the buffers we mapped in
611 * the above function.
614 intelSpanRenderFinish(GLcontext
* ctx
)
616 struct intel_context
*intel
= intel_context(ctx
);
621 /* Now unmap the framebuffer:
624 intel_region_unmap(intel
, intel
->front_region
);
625 intel_region_unmap(intel
, intel
->back_region
);
626 intel_region_unmap(intel
, intel
->depth_region
);
629 for (i
= 0; i
< ctx
->Const
.MaxTextureCoordUnits
; i
++) {
630 if (ctx
->Texture
.Unit
[i
]._ReallyEnabled
) {
631 struct gl_texture_object
*texObj
= ctx
->Texture
.Unit
[i
]._Current
;
632 intel_tex_unmap_images(intel
, intel_texture_object(texObj
));
636 intel_map_unmap_buffers(intel
, GL_FALSE
);
638 UNLOCK_HARDWARE(intel
);
643 intelInitSpanFuncs(GLcontext
* ctx
)
645 struct swrast_device_driver
*swdd
= _swrast_GetDeviceDriverReference(ctx
);
646 swdd
->SpanRenderStart
= intelSpanRenderStart
;
647 swdd
->SpanRenderFinish
= intelSpanRenderFinish
;
652 * Plug in appropriate span read/write functions for the given renderbuffer.
653 * These are used for the software fallbacks.
656 intel_set_span_functions(struct gl_renderbuffer
*rb
, int tiling
)
658 if (rb
->_ActualFormat
== GL_RGB5
) {
661 case INTEL_TILE_NONE
:
663 intelInitPointers_RGB565(rb
);
666 intel_XTile_InitPointers_RGB565(rb
);
669 intel_YTile_InitPointers_RGB565(rb
);
673 else if (rb
->_ActualFormat
== GL_RGBA8
) {
676 case INTEL_TILE_NONE
:
678 intelInitPointers_ARGB8888(rb
);
681 intel_XTile_InitPointers_ARGB8888(rb
);
684 intel_YTile_InitPointers_ARGB8888(rb
);
688 else if (rb
->_ActualFormat
== GL_DEPTH_COMPONENT16
) {
690 case INTEL_TILE_NONE
:
692 intelInitDepthPointers_z16(rb
);
695 intel_XTile_InitDepthPointers_z16(rb
);
698 intel_YTile_InitDepthPointers_z16(rb
);
702 else if (rb
->_ActualFormat
== GL_DEPTH_COMPONENT24
|| /* XXX FBO remove */
703 rb
->_ActualFormat
== GL_DEPTH24_STENCIL8_EXT
) {
705 case INTEL_TILE_NONE
:
707 intelInitDepthPointers_z24_s8(rb
);
710 intel_XTile_InitDepthPointers_z24_s8(rb
);
713 intel_YTile_InitDepthPointers_z24_s8(rb
);
717 else if (rb
->_ActualFormat
== GL_STENCIL_INDEX8_EXT
) {
719 case INTEL_TILE_NONE
:
721 intelInitStencilPointers_z24_s8(rb
);
724 intel_XTile_InitStencilPointers_z24_s8(rb
);
727 intel_YTile_InitStencilPointers_z24_s8(rb
);
733 "Unexpected _ActualFormat in intelSetSpanFunctions");