1 /**************************************************************************
3 * Copyright 2007 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 **************************************************************************/
31 #include "pipe/p_context.h"
32 #include "pipe/p_defines.h"
33 #include "pipe/p_state.h"
34 #include "pipe/p_screen.h"
35 #include "util/u_debug.h"
36 #include "util/u_debug_describe.h"
37 #include "util/u_debug_refcnt.h"
38 #include "util/u_atomic.h"
39 #include "util/u_box.h"
40 #include "util/u_math.h"
49 * Reference counting helper functions.
54 pipe_reference_init(struct pipe_reference *reference, unsigned count)
56 p_atomic_set(&reference->count, count);
60 pipe_is_referenced(struct pipe_reference *reference)
62 return p_atomic_read(&reference->count) != 0;
66 * Update reference counting.
67 * The old thing pointed to, if any, will be unreferenced.
68 * Both 'ptr' and 'reference' may be NULL.
69 * \return TRUE if the object's refcount hits zero and should be destroyed.
72 pipe_reference_described(struct pipe_reference *ptr,
73 struct pipe_reference *reference,
74 debug_reference_descriptor get_desc)
76 boolean destroy = FALSE;
78 if(ptr != reference) {
79 /* bump the reference.count first */
81 assert(pipe_is_referenced(reference));
82 p_atomic_inc(&reference->count);
83 debug_reference(reference, get_desc, 1);
87 assert(pipe_is_referenced(ptr));
88 if (p_atomic_dec_zero(&ptr->count)) {
91 debug_reference(ptr, get_desc, -1);
99 pipe_reference(struct pipe_reference *ptr, struct pipe_reference *reference)
101 return pipe_reference_described(ptr, reference,
102 (debug_reference_descriptor)debug_describe_reference);
106 pipe_surface_reference(struct pipe_surface **ptr, struct pipe_surface *surf)
108 struct pipe_surface *old_surf = *ptr;
110 if (pipe_reference_described(&(*ptr)->reference, &surf->reference,
111 (debug_reference_descriptor)debug_describe_surface))
112 old_surf->context->surface_destroy(old_surf->context, old_surf);
117 pipe_resource_reference(struct pipe_resource **ptr, struct pipe_resource *tex)
119 struct pipe_resource *old_tex = *ptr;
121 if (pipe_reference_described(&(*ptr)->reference, &tex->reference,
122 (debug_reference_descriptor)debug_describe_resource))
123 old_tex->screen->resource_destroy(old_tex->screen, old_tex);
128 pipe_sampler_view_reference(struct pipe_sampler_view **ptr, struct pipe_sampler_view *view)
130 struct pipe_sampler_view *old_view = *ptr;
132 if (pipe_reference_described(&(*ptr)->reference, &view->reference,
133 (debug_reference_descriptor)debug_describe_sampler_view))
134 old_view->context->sampler_view_destroy(old_view->context, old_view);
139 pipe_so_target_reference(struct pipe_stream_output_target **ptr,
140 struct pipe_stream_output_target *target)
142 struct pipe_stream_output_target *old = *ptr;
144 if (pipe_reference_described(&(*ptr)->reference, &target->reference,
145 (debug_reference_descriptor)debug_describe_so_target))
146 old->context->stream_output_target_destroy(old->context, old);
151 pipe_surface_reset(struct pipe_context *ctx, struct pipe_surface* ps,
152 struct pipe_resource *pt, unsigned level, unsigned layer,
155 pipe_resource_reference(&ps->texture, pt);
156 ps->format = pt->format;
157 ps->width = u_minify(pt->width0, level);
158 ps->height = u_minify(pt->height0, level);
160 ps->u.tex.level = level;
161 ps->u.tex.first_layer = ps->u.tex.last_layer = layer;
166 pipe_surface_init(struct pipe_context *ctx, struct pipe_surface* ps,
167 struct pipe_resource *pt, unsigned level, unsigned layer,
171 pipe_reference_init(&ps->reference, 1);
172 pipe_surface_reset(ctx, ps, pt, level, layer, flags);
175 /* Return true if the surfaces are equal. */
176 static INLINE boolean
177 pipe_surface_equal(struct pipe_surface *s1, struct pipe_surface *s2)
179 return s1->texture == s2->texture &&
180 s1->format == s2->format &&
181 (s1->texture->target != PIPE_BUFFER ||
182 (s1->u.buf.first_element == s2->u.buf.first_element &&
183 s1->u.buf.last_element == s2->u.buf.last_element)) &&
184 (s1->texture->target == PIPE_BUFFER ||
185 (s1->u.tex.level == s2->u.tex.level &&
186 s1->u.tex.first_layer == s2->u.tex.first_layer &&
187 s1->u.tex.last_layer == s2->u.tex.last_layer));
191 * Convenience wrappers for screen buffer functions.
194 static INLINE struct pipe_resource *
195 pipe_buffer_create( struct pipe_screen *screen,
200 struct pipe_resource buffer;
201 memset(&buffer, 0, sizeof buffer);
202 buffer.target = PIPE_BUFFER;
203 buffer.format = PIPE_FORMAT_R8_UNORM; /* want TYPELESS or similar */
205 buffer.usage = usage;
207 buffer.width0 = size;
210 buffer.array_size = 1;
211 return screen->resource_create(screen, &buffer);
215 static INLINE struct pipe_resource *
216 pipe_user_buffer_create( struct pipe_screen *screen, void *ptr, unsigned size,
219 return screen->user_buffer_create(screen, ptr, size, usage);
223 pipe_buffer_map_range(struct pipe_context *pipe,
224 struct pipe_resource *buffer,
228 struct pipe_transfer **transfer)
233 assert(offset < buffer->width0);
234 assert(offset + length <= buffer->width0);
237 u_box_1d(offset, length, &box);
239 *transfer = pipe->get_transfer( pipe,
245 if (*transfer == NULL)
248 map = pipe->transfer_map( pipe, *transfer );
250 pipe->transfer_destroy( pipe, *transfer );
260 pipe_buffer_map(struct pipe_context *pipe,
261 struct pipe_resource *buffer,
263 struct pipe_transfer **transfer)
265 return pipe_buffer_map_range(pipe, buffer, 0, buffer->width0, usage, transfer);
270 pipe_buffer_unmap(struct pipe_context *pipe,
271 struct pipe_transfer *transfer)
274 pipe->transfer_unmap(pipe, transfer);
275 pipe->transfer_destroy(pipe, transfer);
280 pipe_buffer_flush_mapped_range(struct pipe_context *pipe,
281 struct pipe_transfer *transfer,
289 assert(transfer->box.x <= offset);
290 assert(offset + length <= transfer->box.x + transfer->box.width);
292 /* Match old screen->buffer_flush_mapped_range() behaviour, where
293 * offset parameter is relative to the start of the buffer, not the
296 transfer_offset = offset - transfer->box.x;
298 u_box_1d(transfer_offset, length, &box);
300 pipe->transfer_flush_region(pipe, transfer, &box);
304 pipe_buffer_write(struct pipe_context *pipe,
305 struct pipe_resource *buf,
311 unsigned usage = PIPE_TRANSFER_WRITE;
313 if (offset == 0 && size == buf->width0) {
314 usage |= PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE;
316 usage |= PIPE_TRANSFER_DISCARD_RANGE;
319 u_box_1d(offset, size, &box);
321 pipe->transfer_inline_write( pipe,
332 * Special case for writing non-overlapping ranges.
334 * We can avoid GPU/CPU synchronization when writing range that has never
335 * been written before.
338 pipe_buffer_write_nooverlap(struct pipe_context *pipe,
339 struct pipe_resource *buf,
340 unsigned offset, unsigned size,
345 u_box_1d(offset, size, &box);
347 pipe->transfer_inline_write(pipe,
350 (PIPE_TRANSFER_WRITE |
351 PIPE_TRANSFER_NOOVERWRITE),
358 pipe_buffer_read(struct pipe_context *pipe,
359 struct pipe_resource *buf,
364 struct pipe_transfer *src_transfer;
367 map = (ubyte *) pipe_buffer_map_range(pipe,
374 memcpy(data, map, size);
376 pipe_buffer_unmap(pipe, src_transfer);
379 static INLINE struct pipe_transfer *
380 pipe_get_transfer( struct pipe_context *context,
381 struct pipe_resource *resource,
382 unsigned level, unsigned layer,
383 enum pipe_transfer_usage usage,
384 unsigned x, unsigned y,
385 unsigned w, unsigned h)
388 u_box_2d_zslice( x, y, layer, w, h, &box );
389 return context->get_transfer( context,
397 pipe_transfer_map( struct pipe_context *context,
398 struct pipe_transfer *transfer )
400 return context->transfer_map( context, transfer );
404 pipe_transfer_unmap( struct pipe_context *context,
405 struct pipe_transfer *transfer )
407 context->transfer_unmap( context, transfer );
412 pipe_transfer_destroy( struct pipe_context *context,
413 struct pipe_transfer *transfer )
415 context->transfer_destroy(context, transfer);
419 static INLINE boolean util_get_offset(
420 const struct pipe_rasterizer_state *templ,
424 case PIPE_POLYGON_MODE_POINT:
425 return templ->offset_point;
426 case PIPE_POLYGON_MODE_LINE:
427 return templ->offset_line;
428 case PIPE_POLYGON_MODE_FILL:
429 return templ->offset_tri;
437 * This function is used to copy an array of pipe_vertex_buffer structures,
438 * while properly referencing the pipe_vertex_buffer::buffer member.
440 * \sa util_copy_framebuffer_state
442 static INLINE void util_copy_vertex_buffers(struct pipe_vertex_buffer *dst,
444 const struct pipe_vertex_buffer *src,
449 /* Reference the buffers of 'src' in 'dst'. */
450 for (i = 0; i < src_count; i++) {
451 pipe_resource_reference(&dst[i].buffer, src[i].buffer);
453 /* Unreference the rest of the buffers in 'dst'. */
454 for (; i < *dst_count; i++) {
455 pipe_resource_reference(&dst[i].buffer, NULL);
458 /* Update the size of 'dst' and copy over the other members
459 * of pipe_vertex_buffer. */
460 *dst_count = src_count;
461 memcpy(dst, src, src_count * sizeof(struct pipe_vertex_buffer));
468 #endif /* U_INLINES_H */