2 Copyright (C) Intel Corp. 2006. All Rights Reserved.
3 Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
4 develop this 3D driver.
6 Permission is hereby granted, free of charge, to any person obtaining
7 a 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, sublicense, 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
16 portions of the Software.
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
19 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
21 IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
22 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
23 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
24 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **********************************************************************/
29 * Keith Whitwell <keith@tungstengraphics.com>
32 #include "util/u_memory.h"
33 #include "util/u_simple_list.h"
34 #include "util/u_format.h"
36 #include "brw_screen.h"
37 #include "brw_defines.h"
38 #include "brw_structs.h"
39 #include "brw_winsys.h"
43 static GLuint
translate_tex_target( unsigned target
)
47 return BRW_SURFACE_1D
;
50 return BRW_SURFACE_2D
;
53 return BRW_SURFACE_3D
;
55 case PIPE_TEXTURE_CUBE
:
56 return BRW_SURFACE_CUBE
;
60 return BRW_SURFACE_1D
;
65 static GLuint
translate_tex_format( enum pipe_format pf
)
68 case PIPE_FORMAT_L8_UNORM
:
69 return BRW_SURFACEFORMAT_L8_UNORM
;
71 case PIPE_FORMAT_I8_UNORM
:
72 return BRW_SURFACEFORMAT_I8_UNORM
;
74 case PIPE_FORMAT_A8_UNORM
:
75 return BRW_SURFACEFORMAT_A8_UNORM
;
77 case PIPE_FORMAT_L16_UNORM
:
78 return BRW_SURFACEFORMAT_L16_UNORM
;
80 /* XXX: Add these to gallium
81 case PIPE_FORMAT_I16_UNORM:
82 return BRW_SURFACEFORMAT_I16_UNORM;
84 case PIPE_FORMAT_A16_UNORM:
85 return BRW_SURFACEFORMAT_A16_UNORM;
88 case PIPE_FORMAT_L8A8_UNORM
:
89 return BRW_SURFACEFORMAT_L8A8_UNORM
;
91 case PIPE_FORMAT_B5G6R5_UNORM
:
92 return BRW_SURFACEFORMAT_B5G6R5_UNORM
;
94 case PIPE_FORMAT_B5G5R5A1_UNORM
:
95 return BRW_SURFACEFORMAT_B5G5R5A1_UNORM
;
97 case PIPE_FORMAT_B4G4R4A4_UNORM
:
98 return BRW_SURFACEFORMAT_B4G4R4A4_UNORM
;
100 case PIPE_FORMAT_B8G8R8X8_UNORM
:
101 return BRW_SURFACEFORMAT_R8G8B8X8_UNORM
;
103 case PIPE_FORMAT_B8G8R8A8_UNORM
:
104 return BRW_SURFACEFORMAT_B8G8R8A8_UNORM
;
110 case PIPE_FORMAT_YUYV
:
111 return BRW_SURFACEFORMAT_YCRCB_NORMAL
;
113 case PIPE_FORMAT_UYVY
:
114 return BRW_SURFACEFORMAT_YCRCB_SWAPUVY
;
117 * Compressed formats.
119 /* XXX: Add FXT to gallium?
120 case PIPE_FORMAT_FXT1_RGBA:
121 return BRW_SURFACEFORMAT_FXT1;
124 case PIPE_FORMAT_DXT1_RGB
:
125 return BRW_SURFACEFORMAT_DXT1_RGB
;
127 case PIPE_FORMAT_DXT1_RGBA
:
128 return BRW_SURFACEFORMAT_BC1_UNORM
;
130 case PIPE_FORMAT_DXT3_RGBA
:
131 return BRW_SURFACEFORMAT_BC2_UNORM
;
133 case PIPE_FORMAT_DXT5_RGBA
:
134 return BRW_SURFACEFORMAT_BC3_UNORM
;
140 case PIPE_FORMAT_A8B8G8R8_SRGB
:
141 return BRW_SURFACEFORMAT_B8G8R8A8_UNORM_SRGB
;
143 case PIPE_FORMAT_L8A8_SRGB
:
144 return BRW_SURFACEFORMAT_L8A8_UNORM_SRGB
;
146 case PIPE_FORMAT_L8_SRGB
:
147 return BRW_SURFACEFORMAT_L8_UNORM_SRGB
;
149 case PIPE_FORMAT_DXT1_SRGB
:
150 return BRW_SURFACEFORMAT_BC1_UNORM_SRGB
;
156 case PIPE_FORMAT_Z16_UNORM
:
157 return BRW_SURFACEFORMAT_I16_UNORM
;
159 case PIPE_FORMAT_Z24S8_UNORM
:
160 case PIPE_FORMAT_Z24X8_UNORM
:
161 return BRW_SURFACEFORMAT_I24X8_UNORM
;
163 case PIPE_FORMAT_Z32_FLOAT
:
164 return BRW_SURFACEFORMAT_I32_FLOAT
;
166 /* XXX: presumably for bump mapping. Add this to mesa state
169 * XXX: Add flipped versions of these formats to Gallium.
171 case PIPE_FORMAT_R8G8_SNORM
:
172 return BRW_SURFACEFORMAT_R8G8_SNORM
;
174 case PIPE_FORMAT_R8G8B8A8_SNORM
:
175 return BRW_SURFACEFORMAT_R8G8B8A8_SNORM
;
178 return BRW_SURFACEFORMAT_INVALID
;
186 static struct pipe_texture
*brw_texture_create( struct pipe_screen
*screen
,
187 const struct pipe_texture
*templ
)
190 struct brw_screen
*bscreen
= brw_screen(screen
);
191 struct brw_texture
*tex
;
192 enum brw_buffer_type buffer_type
;
196 tex
= CALLOC_STRUCT(brw_texture
);
200 memcpy(&tex
->base
, templ
, sizeof *templ
);
201 pipe_reference_init(&tex
->base
.reference
, 1);
202 tex
->base
.screen
= screen
;
204 /* XXX: compressed textures need special treatment here
206 tex
->cpp
= util_format_get_blocksize(tex
->base
.format
);
207 tex
->compressed
= util_format_is_compressed(tex
->base
.format
);
209 make_empty_list(&tex
->views
[0]);
210 make_empty_list(&tex
->views
[1]);
212 /* XXX: No tiling with compressed textures??
214 if (tex
->compressed
== 0 &&
217 if (bscreen
->chipset
.is_965
&&
218 util_format_is_depth_or_stencil(templ
->format
))
219 tex
->tiling
= BRW_TILING_Y
;
221 tex
->tiling
= BRW_TILING_X
;
224 tex
->tiling
= BRW_TILING_NONE
;
230 if (!brw_texture_layout( bscreen
, tex
))
234 if (templ
->tex_usage
& (PIPE_TEXTURE_USAGE_SCANOUT
|
235 PIPE_TEXTURE_USAGE_SHARED
)) {
236 buffer_type
= BRW_BUFFER_TYPE_SCANOUT
;
239 buffer_type
= BRW_BUFFER_TYPE_TEXTURE
;
242 ret
= bscreen
->sws
->bo_alloc( bscreen
->sws
,
244 tex
->pitch
* tex
->total_height
* tex
->cpp
,
250 tex
->ss
.ss0
.mipmap_layout_mode
= BRW_SURFACE_MIPMAPLAYOUT_BELOW
;
251 tex
->ss
.ss0
.surface_type
= translate_tex_target(tex
->base
.target
);
253 format
= translate_tex_format(tex
->base
.format
);
254 assert(format
!= BRW_SURFACEFORMAT_INVALID
);
255 tex
->ss
.ss0
.surface_format
= format
;
257 /* This is ok for all textures with channel width 8bit or less:
259 /* tex->ss.ss0.data_return_format = BRW_SURFACERETURNFORMAT_S1; */
262 /* XXX: what happens when tex->bo->offset changes???
264 tex
->ss
.ss1
.base_addr
= 0; /* reloc */
265 tex
->ss
.ss2
.mip_count
= tex
->base
.last_level
;
266 tex
->ss
.ss2
.width
= tex
->base
.width0
- 1;
267 tex
->ss
.ss2
.height
= tex
->base
.height0
- 1;
269 switch (tex
->tiling
) {
270 case BRW_TILING_NONE
:
271 tex
->ss
.ss3
.tiled_surface
= 0;
272 tex
->ss
.ss3
.tile_walk
= 0;
275 tex
->ss
.ss3
.tiled_surface
= 1;
276 tex
->ss
.ss3
.tile_walk
= BRW_TILEWALK_XMAJOR
;
279 tex
->ss
.ss3
.tiled_surface
= 1;
280 tex
->ss
.ss3
.tile_walk
= BRW_TILEWALK_YMAJOR
;
284 tex
->ss
.ss3
.pitch
= (tex
->pitch
* tex
->cpp
) - 1;
285 tex
->ss
.ss3
.depth
= tex
->base
.depth0
- 1;
287 tex
->ss
.ss4
.min_lod
= 0;
289 if (tex
->base
.target
== PIPE_TEXTURE_CUBE
) {
290 tex
->ss
.ss0
.cube_pos_x
= 1;
291 tex
->ss
.ss0
.cube_pos_y
= 1;
292 tex
->ss
.ss0
.cube_pos_z
= 1;
293 tex
->ss
.ss0
.cube_neg_x
= 1;
294 tex
->ss
.ss0
.cube_neg_y
= 1;
295 tex
->ss
.ss0
.cube_neg_z
= 1;
301 bo_reference(&tex
->bo
, NULL
);
306 static struct pipe_texture
*
307 brw_texture_from_handle(struct pipe_screen
*screen
,
308 const struct pipe_texture
*templ
,
309 struct winsys_handle
*whandle
)
311 struct brw_screen
*bscreen
= brw_screen(screen
);
312 struct brw_texture
*tex
;
313 struct brw_winsys_buffer
*buffer
;
317 if (templ
->target
!= PIPE_TEXTURE_2D
||
318 templ
->last_level
!= 0 ||
322 if (util_format_is_compressed(templ
->format
))
325 tex
= CALLOC_STRUCT(brw_texture
);
329 if (bscreen
->sws
->bo_from_handle(bscreen
->sws
, whandle
, &pitch
, &tiling
, &buffer
) != PIPE_OK
)
332 memcpy(&tex
->base
, templ
, sizeof *templ
);
333 pipe_reference_init(&tex
->base
.reference
, 1);
334 tex
->base
.screen
= screen
;
336 /* XXX: cpp vs. blocksize
338 tex
->cpp
= util_format_get_blocksize(tex
->base
.format
);
339 tex
->tiling
= tiling
;
341 make_empty_list(&tex
->views
[0]);
342 make_empty_list(&tex
->views
[1]);
344 if (!brw_texture_layout(bscreen
, tex
))
347 /* XXX Maybe some more checks? */
348 if ((pitch
/ tex
->cpp
) < tex
->pitch
)
351 tex
->pitch
= pitch
/ tex
->cpp
;
355 /* fix this warning */
357 if (tex
->size
> buffer
->size
)
361 tex
->ss
.ss0
.mipmap_layout_mode
= BRW_SURFACE_MIPMAPLAYOUT_BELOW
;
362 tex
->ss
.ss0
.surface_type
= translate_tex_target(tex
->base
.target
);
363 tex
->ss
.ss0
.surface_format
= translate_tex_format(tex
->base
.format
);
364 assert(tex
->ss
.ss0
.surface_format
!= BRW_SURFACEFORMAT_INVALID
);
366 /* This is ok for all textures with channel width 8bit or less:
368 /* tex->ss.ss0.data_return_format = BRW_SURFACERETURNFORMAT_S1; */
371 /* XXX: what happens when tex->bo->offset changes???
373 tex
->ss
.ss1
.base_addr
= 0; /* reloc */
374 tex
->ss
.ss2
.mip_count
= tex
->base
.last_level
;
375 tex
->ss
.ss2
.width
= tex
->base
.width0
- 1;
376 tex
->ss
.ss2
.height
= tex
->base
.height0
- 1;
378 switch (tex
->tiling
) {
379 case BRW_TILING_NONE
:
380 tex
->ss
.ss3
.tiled_surface
= 0;
381 tex
->ss
.ss3
.tile_walk
= 0;
384 tex
->ss
.ss3
.tiled_surface
= 1;
385 tex
->ss
.ss3
.tile_walk
= BRW_TILEWALK_XMAJOR
;
388 tex
->ss
.ss3
.tiled_surface
= 1;
389 tex
->ss
.ss3
.tile_walk
= BRW_TILEWALK_YMAJOR
;
393 tex
->ss
.ss3
.pitch
= (tex
->pitch
* tex
->cpp
) - 1;
394 tex
->ss
.ss3
.depth
= tex
->base
.depth0
- 1;
396 tex
->ss
.ss4
.min_lod
= 0;
406 brw_texture_get_handle(struct pipe_screen
*screen
,
407 struct pipe_texture
*texture
,
408 struct winsys_handle
*whandle
)
410 struct brw_screen
*bscreen
= brw_screen(screen
);
411 struct brw_texture
*tex
= brw_texture(texture
);
414 stride
= tex
->pitch
* tex
->cpp
;
416 return bscreen
->sws
->bo_get_handle(tex
->bo
, whandle
, stride
);
421 static void brw_texture_destroy(struct pipe_texture
*pt
)
423 struct brw_texture
*tex
= brw_texture(pt
);
424 bo_reference(&tex
->bo
, NULL
);
429 static boolean
brw_is_format_supported( struct pipe_screen
*screen
,
430 enum pipe_format format
,
431 enum pipe_texture_target target
,
433 unsigned geom_flags
)
435 return translate_tex_format(format
) != BRW_SURFACEFORMAT_INVALID
;
439 boolean
brw_is_texture_referenced_by_bo( struct brw_screen
*brw_screen
,
440 struct pipe_texture
*texture
,
443 struct brw_winsys_buffer
*bo
)
445 struct brw_texture
*tex
= brw_texture(texture
);
446 struct brw_surface
*surf
;
449 /* XXX: this is subject to false positives if the underlying
450 * texture BO is referenced, we can't tell whether the sub-region
451 * we care about participates in that.
453 if (brw_screen
->sws
->bo_references( bo
, tex
->bo
))
456 /* Find any view on this texture for this face/level and see if it
459 for (i
= 0; i
< 2; i
++) {
460 foreach (surf
, &tex
->views
[i
]) {
461 if (surf
->bo
== tex
->bo
)
464 if (surf
->id
.bits
.face
!= face
||
465 surf
->id
.bits
.level
!= level
)
468 if (brw_screen
->sws
->bo_references( bo
, surf
->bo
))
481 static struct pipe_transfer
*
482 brw_get_tex_transfer(struct pipe_screen
*screen
,
483 struct pipe_texture
*texture
,
484 unsigned face
, unsigned level
, unsigned zslice
,
485 enum pipe_transfer_usage usage
, unsigned x
, unsigned y
,
486 unsigned w
, unsigned h
)
488 struct brw_texture
*tex
= brw_texture(texture
);
489 struct brw_transfer
*trans
;
490 unsigned offset
; /* in bytes */
492 if (texture
->target
== PIPE_TEXTURE_CUBE
) {
493 offset
= tex
->image_offset
[level
][face
];
494 } else if (texture
->target
== PIPE_TEXTURE_3D
) {
495 offset
= tex
->image_offset
[level
][zslice
];
497 offset
= tex
->image_offset
[level
][0];
502 trans
= CALLOC_STRUCT(brw_transfer
);
504 pipe_texture_reference(&trans
->base
.texture
, texture
);
507 trans
->base
.width
= w
;
508 trans
->base
.height
= h
;
509 trans
->base
.stride
= tex
->pitch
* tex
->cpp
;
510 trans
->offset
= offset
;
511 trans
->base
.usage
= usage
;
517 brw_transfer_map(struct pipe_screen
*screen
,
518 struct pipe_transfer
*transfer
)
520 struct brw_texture
*tex
= brw_texture(transfer
->texture
);
521 struct brw_winsys_screen
*sws
= brw_screen(screen
)->sws
;
523 unsigned usage
= transfer
->usage
;
525 map
= sws
->bo_map(tex
->bo
,
529 (usage
& PIPE_TRANSFER_WRITE
) ? TRUE
: FALSE
,
530 (usage
& 0) ? TRUE
: FALSE
,
531 (usage
& 0) ? TRUE
: FALSE
);
536 /* XXX: blocksize and compressed textures
538 return map
+ brw_transfer(transfer
)->offset
+
539 transfer
->y
/* / transfer->block.height */ * transfer
->stride
+
540 transfer
->x
/* / transfer->block.width */ * brw_texture(transfer
->texture
)->cpp
;
544 brw_transfer_unmap(struct pipe_screen
*screen
,
545 struct pipe_transfer
*transfer
)
547 struct brw_texture
*tex
= brw_texture(transfer
->texture
);
548 struct brw_winsys_screen
*sws
= brw_screen(screen
)->sws
;
550 sws
->bo_unmap(tex
->bo
);
554 brw_tex_transfer_destroy(struct pipe_transfer
*trans
)
556 pipe_texture_reference(&trans
->texture
, NULL
);
561 void brw_screen_tex_init( struct brw_screen
*brw_screen
)
563 brw_screen
->base
.is_format_supported
= brw_is_format_supported
;
564 brw_screen
->base
.texture_create
= brw_texture_create
;
565 brw_screen
->base
.texture_from_handle
= brw_texture_from_handle
;
566 brw_screen
->base
.texture_get_handle
= brw_texture_get_handle
;
567 brw_screen
->base
.texture_destroy
= brw_texture_destroy
;
568 brw_screen
->base
.get_tex_transfer
= brw_get_tex_transfer
;
569 brw_screen
->base
.transfer_map
= brw_transfer_map
;
570 brw_screen
->base
.transfer_unmap
= brw_transfer_unmap
;
571 brw_screen
->base
.tex_transfer_destroy
= brw_tex_transfer_destroy
;