1 /**************************************************************************
3 * Copyright 2007 VMware, Inc.
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 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.
26 **************************************************************************/
28 #include "util/u_rect.h"
29 #include "util/u_surface.h"
30 #include "lp_context.h"
32 #include "lp_limits.h"
33 #include "lp_surface.h"
34 #include "lp_texture.h"
39 * Adjust x, y, width, height to lie on tile bounds.
42 adjust_to_tile_bounds(unsigned x
, unsigned y
, unsigned width
, unsigned height
,
43 unsigned *x_tile
, unsigned *y_tile
,
44 unsigned *w_tile
, unsigned *h_tile
)
46 *x_tile
= x
& ~(TILE_SIZE
- 1);
47 *y_tile
= y
& ~(TILE_SIZE
- 1);
48 *w_tile
= ((x
+ width
+ TILE_SIZE
- 1) & ~(TILE_SIZE
- 1)) - *x_tile
;
49 *h_tile
= ((y
+ height
+ TILE_SIZE
- 1) & ~(TILE_SIZE
- 1)) - *y_tile
;
55 lp_resource_copy(struct pipe_context
*pipe
,
56 struct pipe_resource
*dst
, unsigned dst_level
,
57 unsigned dstx
, unsigned dsty
, unsigned dstz
,
58 struct pipe_resource
*src
, unsigned src_level
,
59 const struct pipe_box
*src_box
)
61 struct llvmpipe_resource
*src_tex
= llvmpipe_resource(src
);
62 struct llvmpipe_resource
*dst_tex
= llvmpipe_resource(dst
);
63 const enum pipe_format format
= src_tex
->base
.format
;
64 unsigned width
= src_box
->width
;
65 unsigned height
= src_box
->height
;
66 unsigned depth
= src_box
->depth
;
69 llvmpipe_flush_resource(pipe
,
71 FALSE
, /* read_only */
72 TRUE
, /* cpu_access */
73 FALSE
, /* do_not_block */
76 llvmpipe_flush_resource(pipe
,
79 TRUE
, /* cpu_access */
80 FALSE
, /* do_not_block */
83 /* Fallback for buffers. */
84 if (dst
->target
== PIPE_BUFFER
&& src
->target
== PIPE_BUFFER
) {
85 util_resource_copy_region(pipe
, dst
, dst_level
, dstx
, dsty
, dstz
,
86 src
, src_level
, src_box
);
91 printf("surface copy from %u lvl %u to %u lvl %u: %u,%u,%u to %u,%u,%u %u x %u x %u\n",
92 src_tex->id, src_level, dst_tex->id, dst_level,
93 src_box->x, src_box->y, src_box->z, dstx, dsty, dstz,
94 src_box->width, src_box->height, src_box->depth);
97 for (z
= 0; z
< src_box
->depth
; z
++){
99 /* set src tiles to linear layout */
101 unsigned tx
, ty
, tw
, th
;
104 adjust_to_tile_bounds(src_box
->x
, src_box
->y
, width
, height
,
107 for (y
= 0; y
< th
; y
+= TILE_SIZE
) {
108 for (x
= 0; x
< tw
; x
+= TILE_SIZE
) {
109 (void) llvmpipe_get_texture_tile_linear(src_tex
,
110 src_box
->z
+ z
, src_level
,
117 /* set dst tiles to linear layout */
119 unsigned tx
, ty
, tw
, th
;
121 enum lp_texture_usage usage
;
123 adjust_to_tile_bounds(dstx
, dsty
, width
, height
, &tx
, &ty
, &tw
, &th
);
125 for (y
= 0; y
< th
; y
+= TILE_SIZE
) {
126 boolean contained_y
= ty
+ y
>= dsty
&&
127 ty
+ y
+ TILE_SIZE
<= dsty
+ height
?
130 for (x
= 0; x
< tw
; x
+= TILE_SIZE
) {
131 boolean contained_x
= tx
+ x
>= dstx
&&
132 tx
+ x
+ TILE_SIZE
<= dstx
+ width
?
136 * Set the usage mode to WRITE_ALL for the tiles which are
137 * completely contained by the dest rectangle.
139 if (contained_y
&& contained_x
)
140 usage
= LP_TEX_USAGE_WRITE_ALL
;
142 usage
= LP_TEX_USAGE_READ_WRITE
;
144 (void) llvmpipe_get_texture_tile_linear(dst_tex
,
155 const ubyte
*src_linear_ptr
156 = llvmpipe_get_texture_image_address(src_tex
, src_box
->z
,
158 ubyte
*dst_linear_ptr
159 = llvmpipe_get_texture_image_address(dst_tex
, dstz
,
162 if (dst_linear_ptr
&& src_linear_ptr
) {
163 util_copy_box(dst_linear_ptr
, format
,
164 llvmpipe_resource_stride(&dst_tex
->base
, dst_level
),
165 dst_tex
->img_stride
[dst_level
],
167 width
, height
, depth
,
169 llvmpipe_resource_stride(&src_tex
->base
, src_level
),
170 src_tex
->img_stride
[src_level
],
171 src_box
->x
, src_box
->y
, 0);
177 static void lp_blit(struct pipe_context
*pipe
,
178 const struct pipe_blit_info
*blit_info
)
180 struct llvmpipe_context
*lp
= llvmpipe_context(pipe
);
181 struct pipe_blit_info info
= *blit_info
;
183 if (info
.src
.resource
->nr_samples
> 1 &&
184 info
.dst
.resource
->nr_samples
<= 1 &&
185 !util_format_is_depth_or_stencil(info
.src
.resource
->format
) &&
186 !util_format_is_pure_integer(info
.src
.resource
->format
)) {
187 debug_printf("llvmpipe: color resolve unimplemented\n");
191 if (util_try_blit_via_copy_region(pipe
, &info
)) {
195 if (info
.mask
& PIPE_MASK_S
) {
196 debug_printf("llvmpipe: cannot blit stencil, skipping\n");
197 info
.mask
&= ~PIPE_MASK_S
;
200 if (!util_blitter_is_blit_supported(lp
->blitter
, &info
)) {
201 debug_printf("llvmpipe: blit unsupported %s -> %s\n",
202 util_format_short_name(info
.src
.resource
->format
),
203 util_format_short_name(info
.dst
.resource
->format
));
207 /* XXX turn off occlusion and streamout queries */
209 util_blitter_save_vertex_buffer_slot(lp
->blitter
, lp
->vertex_buffer
);
210 util_blitter_save_vertex_elements(lp
->blitter
, (void*)lp
->velems
);
211 util_blitter_save_vertex_shader(lp
->blitter
, (void*)lp
->vs
);
212 util_blitter_save_geometry_shader(lp
->blitter
, (void*)lp
->gs
);
213 util_blitter_save_so_targets(lp
->blitter
, lp
->num_so_targets
,
214 (struct pipe_stream_output_target
**)lp
->so_targets
);
215 util_blitter_save_rasterizer(lp
->blitter
, (void*)lp
->rasterizer
);
216 util_blitter_save_viewport(lp
->blitter
, &lp
->viewports
[0]);
217 util_blitter_save_scissor(lp
->blitter
, &lp
->scissors
[0]);
218 util_blitter_save_fragment_shader(lp
->blitter
, lp
->fs
);
219 util_blitter_save_blend(lp
->blitter
, (void*)lp
->blend
);
220 util_blitter_save_depth_stencil_alpha(lp
->blitter
, (void*)lp
->depth_stencil
);
221 util_blitter_save_stencil_ref(lp
->blitter
, &lp
->stencil_ref
);
222 /*util_blitter_save_sample_mask(sp->blitter, lp->sample_mask);*/
223 util_blitter_save_framebuffer(lp
->blitter
, &lp
->framebuffer
);
224 util_blitter_save_fragment_sampler_states(lp
->blitter
,
225 lp
->num_samplers
[PIPE_SHADER_FRAGMENT
],
226 (void**)lp
->samplers
[PIPE_SHADER_FRAGMENT
]);
227 util_blitter_save_fragment_sampler_views(lp
->blitter
,
228 lp
->num_sampler_views
[PIPE_SHADER_FRAGMENT
],
229 lp
->sampler_views
[PIPE_SHADER_FRAGMENT
]);
230 util_blitter_save_render_condition(lp
->blitter
, lp
->render_cond_query
,
231 lp
->render_cond_cond
, lp
->render_cond_mode
);
232 util_blitter_blit(lp
->blitter
, &info
);
237 lp_flush_resource(struct pipe_context
*ctx
, struct pipe_resource
*resource
)
242 static struct pipe_surface
*
243 llvmpipe_create_surface(struct pipe_context
*pipe
,
244 struct pipe_resource
*pt
,
245 const struct pipe_surface
*surf_tmpl
)
247 struct pipe_surface
*ps
;
249 if (!(pt
->bind
& (PIPE_BIND_DEPTH_STENCIL
| PIPE_BIND_RENDER_TARGET
)))
250 debug_printf("Illegal surface creation without bind flag\n");
252 ps
= CALLOC_STRUCT(pipe_surface
);
254 pipe_reference_init(&ps
->reference
, 1);
255 pipe_resource_reference(&ps
->texture
, pt
);
257 ps
->format
= surf_tmpl
->format
;
258 if (llvmpipe_resource_is_texture(pt
)) {
259 assert(surf_tmpl
->u
.tex
.level
<= pt
->last_level
);
260 assert(surf_tmpl
->u
.tex
.first_layer
<= surf_tmpl
->u
.tex
.last_layer
);
261 ps
->width
= u_minify(pt
->width0
, surf_tmpl
->u
.tex
.level
);
262 ps
->height
= u_minify(pt
->height0
, surf_tmpl
->u
.tex
.level
);
263 ps
->u
.tex
.level
= surf_tmpl
->u
.tex
.level
;
264 ps
->u
.tex
.first_layer
= surf_tmpl
->u
.tex
.first_layer
;
265 ps
->u
.tex
.last_layer
= surf_tmpl
->u
.tex
.last_layer
;
268 /* setting width as number of elements should get us correct renderbuffer width */
269 ps
->width
= surf_tmpl
->u
.buf
.last_element
- surf_tmpl
->u
.buf
.first_element
+ 1;
270 ps
->height
= pt
->height0
;
271 ps
->u
.buf
.first_element
= surf_tmpl
->u
.buf
.first_element
;
272 ps
->u
.buf
.last_element
= surf_tmpl
->u
.buf
.last_element
;
273 assert(ps
->u
.buf
.first_element
<= ps
->u
.buf
.last_element
);
274 assert(util_format_get_blocksize(surf_tmpl
->format
) *
275 (ps
->u
.buf
.last_element
+ 1) <= pt
->width0
);
283 llvmpipe_surface_destroy(struct pipe_context
*pipe
,
284 struct pipe_surface
*surf
)
286 /* Effectively do the texture_update work here - if texture images
287 * needed post-processing to put them into hardware layout, this is
288 * where it would happen. For llvmpipe, nothing to do.
290 assert(surf
->texture
);
291 pipe_resource_reference(&surf
->texture
, NULL
);
297 llvmpipe_clear_render_target(struct pipe_context
*pipe
,
298 struct pipe_surface
*dst
,
299 const union pipe_color_union
*color
,
300 unsigned dstx
, unsigned dsty
,
301 unsigned width
, unsigned height
)
303 struct llvmpipe_context
*llvmpipe
= llvmpipe_context(pipe
);
305 if (!llvmpipe_check_render_cond(llvmpipe
))
308 util_clear_render_target(pipe
, dst
, color
,
309 dstx
, dsty
, width
, height
);
314 llvmpipe_clear_depth_stencil(struct pipe_context
*pipe
,
315 struct pipe_surface
*dst
,
316 unsigned clear_flags
,
319 unsigned dstx
, unsigned dsty
,
320 unsigned width
, unsigned height
)
322 struct llvmpipe_context
*llvmpipe
= llvmpipe_context(pipe
);
324 if (!llvmpipe_check_render_cond(llvmpipe
))
327 util_clear_depth_stencil(pipe
, dst
, clear_flags
,
329 dstx
, dsty
, width
, height
);
334 llvmpipe_init_surface_functions(struct llvmpipe_context
*lp
)
336 lp
->pipe
.clear_render_target
= llvmpipe_clear_render_target
;
337 lp
->pipe
.clear_depth_stencil
= llvmpipe_clear_depth_stencil
;
338 lp
->pipe
.create_surface
= llvmpipe_create_surface
;
339 lp
->pipe
.surface_destroy
= llvmpipe_surface_destroy
;
340 /* These two are not actually functions dealing with surfaces */
341 lp
->pipe
.resource_copy_region
= lp_resource_copy
;
342 lp
->pipe
.blit
= lp_blit
;
343 lp
->pipe
.flush_resource
= lp_flush_resource
;