1 /**************************************************************************
3 * Copyright 2008 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 **************************************************************************/
28 #include "util/u_format.h"
29 #include "util/u_memory.h"
30 #include "util/u_simple_list.h"
32 #include "tr_buffer.h"
34 #include "tr_dump_state.h"
35 #include "tr_texture.h"
36 #include "tr_screen.h"
38 #include "util/u_inlines.h"
39 #include "pipe/p_format.h"
42 static boolean trace
= FALSE
;
43 static boolean rbug
= FALSE
;
46 trace_screen_get_name(struct pipe_screen
*_screen
)
48 struct trace_screen
*tr_scr
= trace_screen(_screen
);
49 struct pipe_screen
*screen
= tr_scr
->screen
;
52 trace_dump_call_begin("pipe_screen", "get_name");
54 trace_dump_arg(ptr
, screen
);
56 result
= screen
->get_name(screen
);
58 trace_dump_ret(string
, result
);
60 trace_dump_call_end();
67 trace_screen_get_vendor(struct pipe_screen
*_screen
)
69 struct trace_screen
*tr_scr
= trace_screen(_screen
);
70 struct pipe_screen
*screen
= tr_scr
->screen
;
73 trace_dump_call_begin("pipe_screen", "get_vendor");
75 trace_dump_arg(ptr
, screen
);
77 result
= screen
->get_vendor(screen
);
79 trace_dump_ret(string
, result
);
81 trace_dump_call_end();
88 trace_screen_get_param(struct pipe_screen
*_screen
,
91 struct trace_screen
*tr_scr
= trace_screen(_screen
);
92 struct pipe_screen
*screen
= tr_scr
->screen
;
95 trace_dump_call_begin("pipe_screen", "get_param");
97 trace_dump_arg(ptr
, screen
);
98 trace_dump_arg(int, param
);
100 result
= screen
->get_param(screen
, param
);
102 trace_dump_ret(int, result
);
104 trace_dump_call_end();
111 trace_screen_get_paramf(struct pipe_screen
*_screen
,
114 struct trace_screen
*tr_scr
= trace_screen(_screen
);
115 struct pipe_screen
*screen
= tr_scr
->screen
;
118 trace_dump_call_begin("pipe_screen", "get_paramf");
120 trace_dump_arg(ptr
, screen
);
121 trace_dump_arg(int, param
);
123 result
= screen
->get_paramf(screen
, param
);
125 trace_dump_ret(float, result
);
127 trace_dump_call_end();
134 trace_screen_is_format_supported(struct pipe_screen
*_screen
,
135 enum pipe_format format
,
136 enum pipe_texture_target target
,
140 struct trace_screen
*tr_scr
= trace_screen(_screen
);
141 struct pipe_screen
*screen
= tr_scr
->screen
;
144 trace_dump_call_begin("pipe_screen", "is_format_supported");
146 trace_dump_arg(ptr
, screen
);
147 trace_dump_arg(format
, format
);
148 trace_dump_arg(int, target
);
149 trace_dump_arg(uint
, tex_usage
);
150 trace_dump_arg(uint
, geom_flags
);
152 result
= screen
->is_format_supported(screen
, format
, target
, tex_usage
, geom_flags
);
154 trace_dump_ret(bool, result
);
156 trace_dump_call_end();
163 trace_screen_flush_frontbuffer(struct pipe_screen
*_screen
,
164 struct pipe_surface
*_surface
,
165 void *context_private
)
167 struct trace_screen
*tr_scr
= trace_screen(_screen
);
168 struct trace_surface
*tr_surf
= trace_surface(_surface
);
169 struct pipe_screen
*screen
= tr_scr
->screen
;
170 struct pipe_surface
*surface
= tr_surf
->surface
;
172 trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
174 trace_dump_arg(ptr
, screen
);
175 trace_dump_arg(ptr
, surface
);
176 /* XXX: hide, as there is nothing we can do with this
177 trace_dump_arg(ptr, context_private);
180 screen
->flush_frontbuffer(screen
, surface
, context_private
);
182 trace_dump_call_end();
186 /********************************************************************
191 static struct pipe_texture
*
192 trace_screen_texture_create(struct pipe_screen
*_screen
,
193 const struct pipe_texture
*templat
)
195 struct trace_screen
*tr_scr
= trace_screen(_screen
);
196 struct pipe_screen
*screen
= tr_scr
->screen
;
197 struct pipe_texture
*result
;
199 trace_dump_call_begin("pipe_screen", "texture_create");
201 trace_dump_arg(ptr
, screen
);
202 trace_dump_arg(template, templat
);
204 result
= screen
->texture_create(screen
, templat
);
206 trace_dump_ret(ptr
, result
);
208 trace_dump_call_end();
210 result
= trace_texture_create(tr_scr
, result
);
216 static struct pipe_texture
*
217 trace_screen_texture_blanket(struct pipe_screen
*_screen
,
218 const struct pipe_texture
*templat
,
219 const unsigned *ppitch
,
220 struct pipe_buffer
*_buffer
)
222 struct trace_screen
*tr_scr
= trace_screen(_screen
);
223 struct trace_buffer
*tr_buf
= trace_buffer(_buffer
);
224 struct pipe_screen
*screen
= tr_scr
->screen
;
225 struct pipe_buffer
*buffer
= tr_buf
->buffer
;
226 unsigned pitch
= *ppitch
;
227 struct pipe_texture
*result
;
229 trace_dump_call_begin("pipe_screen", "texture_blanket");
231 trace_dump_arg(ptr
, screen
);
232 trace_dump_arg(template, templat
);
233 trace_dump_arg(uint
, pitch
);
234 trace_dump_arg(ptr
, buffer
);
236 result
= screen
->texture_blanket(screen
, templat
, ppitch
, buffer
);
238 trace_dump_ret(ptr
, result
);
240 trace_dump_call_end();
242 result
= trace_texture_create(tr_scr
, result
);
249 trace_screen_texture_destroy(struct pipe_texture
*_texture
)
251 struct trace_screen
*tr_scr
= trace_screen(_texture
->screen
);
252 struct trace_texture
*tr_tex
= trace_texture(_texture
);
253 struct pipe_screen
*screen
= tr_scr
->screen
;
254 struct pipe_texture
*texture
= tr_tex
->texture
;
256 assert(texture
->screen
== screen
);
258 trace_dump_call_begin("pipe_screen", "texture_destroy");
260 trace_dump_arg(ptr
, screen
);
261 trace_dump_arg(ptr
, texture
);
263 trace_dump_call_end();
265 trace_texture_destroy(tr_tex
);
269 /********************************************************************
274 static struct pipe_surface
*
275 trace_screen_get_tex_surface(struct pipe_screen
*_screen
,
276 struct pipe_texture
*_texture
,
277 unsigned face
, unsigned level
,
281 struct trace_screen
*tr_scr
= trace_screen(_screen
);
282 struct trace_texture
*tr_tex
= trace_texture(_texture
);
283 struct pipe_screen
*screen
= tr_scr
->screen
;
284 struct pipe_texture
*texture
= tr_tex
->texture
;
285 struct pipe_surface
*result
= NULL
;
287 assert(texture
->screen
== screen
);
289 trace_dump_call_begin("pipe_screen", "get_tex_surface");
291 trace_dump_arg(ptr
, screen
);
292 trace_dump_arg(ptr
, texture
);
293 trace_dump_arg(uint
, face
);
294 trace_dump_arg(uint
, level
);
295 trace_dump_arg(uint
, zslice
);
296 trace_dump_arg(uint
, usage
);
298 result
= screen
->get_tex_surface(screen
, texture
, face
, level
, zslice
, usage
);
300 trace_dump_ret(ptr
, result
);
302 trace_dump_call_end();
304 result
= trace_surface_create(tr_tex
, result
);
311 trace_screen_tex_surface_destroy(struct pipe_surface
*_surface
)
313 struct trace_screen
*tr_scr
= trace_screen(_surface
->texture
->screen
);
314 struct trace_surface
*tr_surf
= trace_surface(_surface
);
315 struct pipe_screen
*screen
= tr_scr
->screen
;
316 struct pipe_surface
*surface
= tr_surf
->surface
;
318 trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
320 trace_dump_arg(ptr
, screen
);
321 trace_dump_arg(ptr
, surface
);
323 trace_dump_call_end();
325 trace_surface_destroy(tr_surf
);
329 /********************************************************************
334 static struct pipe_transfer
*
335 trace_screen_get_tex_transfer(struct pipe_screen
*_screen
,
336 struct pipe_texture
*_texture
,
337 unsigned face
, unsigned level
,
339 enum pipe_transfer_usage usage
,
340 unsigned x
, unsigned y
, unsigned w
, unsigned h
)
342 struct trace_screen
*tr_scr
= trace_screen(_screen
);
343 struct trace_texture
*tr_tex
= trace_texture(_texture
);
344 struct pipe_screen
*screen
= tr_scr
->screen
;
345 struct pipe_texture
*texture
= tr_tex
->texture
;
346 struct pipe_transfer
*result
= NULL
;
348 assert(texture
->screen
== screen
);
350 trace_dump_call_begin("pipe_screen", "get_tex_transfer");
352 trace_dump_arg(ptr
, screen
);
353 trace_dump_arg(ptr
, texture
);
354 trace_dump_arg(uint
, face
);
355 trace_dump_arg(uint
, level
);
356 trace_dump_arg(uint
, zslice
);
357 trace_dump_arg(uint
, usage
);
359 trace_dump_arg(uint
, x
);
360 trace_dump_arg(uint
, y
);
361 trace_dump_arg(uint
, w
);
362 trace_dump_arg(uint
, h
);
364 result
= screen
->get_tex_transfer(screen
, texture
, face
, level
, zslice
, usage
,
367 trace_dump_ret(ptr
, result
);
369 trace_dump_call_end();
372 result
= trace_transfer_create(tr_tex
, result
);
379 trace_screen_tex_transfer_destroy(struct pipe_transfer
*_transfer
)
381 struct trace_screen
*tr_scr
= trace_screen(_transfer
->texture
->screen
);
382 struct trace_transfer
*tr_trans
= trace_transfer(_transfer
);
383 struct pipe_screen
*screen
= tr_scr
->screen
;
384 struct pipe_transfer
*transfer
= tr_trans
->transfer
;
386 trace_dump_call_begin("pipe_screen", "tex_transfer_destroy");
388 trace_dump_arg(ptr
, screen
);
389 trace_dump_arg(ptr
, transfer
);
391 trace_dump_call_end();
393 trace_transfer_destroy(tr_trans
);
398 trace_screen_transfer_map(struct pipe_screen
*_screen
,
399 struct pipe_transfer
*_transfer
)
401 struct trace_screen
*tr_scr
= trace_screen(_screen
);
402 struct trace_transfer
*tr_trans
= trace_transfer(_transfer
);
403 struct pipe_screen
*screen
= tr_scr
->screen
;
404 struct pipe_transfer
*transfer
= tr_trans
->transfer
;
407 map
= screen
->transfer_map(screen
, transfer
);
409 if(transfer
->usage
& PIPE_TRANSFER_WRITE
) {
410 assert(!tr_trans
->map
);
420 trace_screen_transfer_unmap(struct pipe_screen
*_screen
,
421 struct pipe_transfer
*_transfer
)
423 struct trace_screen
*tr_scr
= trace_screen(_screen
);
424 struct trace_transfer
*tr_trans
= trace_transfer(_transfer
);
425 struct pipe_screen
*screen
= tr_scr
->screen
;
426 struct pipe_transfer
*transfer
= tr_trans
->transfer
;
429 size_t size
= util_format_get_nblocksy(transfer
->texture
->format
, transfer
->height
) * transfer
->stride
;
431 trace_dump_call_begin("pipe_screen", "transfer_write");
433 trace_dump_arg(ptr
, screen
);
435 trace_dump_arg(ptr
, transfer
);
437 trace_dump_arg_begin("stride");
438 trace_dump_uint(transfer
->stride
);
439 trace_dump_arg_end();
441 trace_dump_arg_begin("data");
442 trace_dump_bytes(tr_trans
->map
, size
);
443 trace_dump_arg_end();
445 trace_dump_arg_begin("size");
446 trace_dump_uint(size
);
447 trace_dump_arg_end();
449 trace_dump_call_end();
451 tr_trans
->map
= NULL
;
454 screen
->transfer_unmap(screen
, transfer
);
458 /********************************************************************
463 static struct pipe_buffer
*
464 trace_screen_surface_buffer_create(struct pipe_screen
*_screen
,
465 unsigned width
, unsigned height
,
466 enum pipe_format format
,
471 struct trace_screen
*tr_scr
= trace_screen(_screen
);
472 struct pipe_screen
*screen
= tr_scr
->screen
;
474 struct pipe_buffer
*result
;
476 trace_dump_call_begin("pipe_screen", "surface_buffer_create");
478 trace_dump_arg(ptr
, screen
);
479 trace_dump_arg(uint
, width
);
480 trace_dump_arg(uint
, height
);
481 trace_dump_arg(format
, format
);
482 trace_dump_arg(uint
, usage
);
483 trace_dump_arg(uint
, tex_usage
);
485 result
= screen
->surface_buffer_create(screen
,
494 trace_dump_arg(uint
, stride
);
496 trace_dump_ret(ptr
, result
);
498 trace_dump_call_end();
500 return trace_buffer_create(tr_scr
, result
);
504 static struct pipe_buffer
*
505 trace_screen_buffer_create(struct pipe_screen
*_screen
,
510 struct trace_screen
*tr_scr
= trace_screen(_screen
);
511 struct pipe_screen
*screen
= tr_scr
->screen
;
512 struct pipe_buffer
*result
;
514 trace_dump_call_begin("pipe_screen", "buffer_create");
516 trace_dump_arg(ptr
, screen
);
517 trace_dump_arg(uint
, alignment
);
518 trace_dump_arg(uint
, usage
);
519 trace_dump_arg(uint
, size
);
521 result
= screen
->buffer_create(screen
, alignment
, usage
, size
);
523 trace_dump_ret(ptr
, result
);
525 trace_dump_call_end();
527 /* Zero the buffer to avoid dumping uninitialized memory */
528 if(result
->usage
& PIPE_BUFFER_USAGE_CPU_WRITE
) {
530 map
= pipe_buffer_map(screen
, result
, PIPE_BUFFER_USAGE_CPU_WRITE
);
532 memset(map
, 0, result
->size
);
533 screen
->buffer_unmap(screen
, result
);
537 return trace_buffer_create(tr_scr
, result
);
541 static struct pipe_buffer
*
542 trace_screen_user_buffer_create(struct pipe_screen
*_screen
,
546 struct trace_screen
*tr_scr
= trace_screen(_screen
);
547 struct pipe_screen
*screen
= tr_scr
->screen
;
548 struct pipe_buffer
*result
;
550 trace_dump_call_begin("pipe_screen", "user_buffer_create");
552 trace_dump_arg(ptr
, screen
);
553 trace_dump_arg_begin("data");
554 trace_dump_bytes(data
, size
);
555 trace_dump_arg_end();
556 trace_dump_arg(uint
, size
);
558 result
= screen
->user_buffer_create(screen
, data
, size
);
560 trace_dump_ret(ptr
, result
);
562 trace_dump_call_end();
565 assert(!(result
->usage
& TRACE_BUFFER_USAGE_USER
));
566 result
->usage
|= TRACE_BUFFER_USAGE_USER
;
569 return trace_buffer_create(tr_scr
, result
);
574 * This function is used to track if data has been changed on a user buffer
575 * without map/unmap being called.
578 trace_screen_user_buffer_update(struct pipe_screen
*_screen
,
579 struct pipe_buffer
*_buffer
)
582 struct trace_screen
*tr_scr
= trace_screen(_screen
);
583 struct pipe_screen
*screen
= tr_scr
->screen
;
586 if(buffer
&& buffer
->usage
& TRACE_BUFFER_USAGE_USER
) {
587 map
= screen
->buffer_map(screen
, buffer
, PIPE_BUFFER_USAGE_CPU_READ
);
589 trace_dump_call_begin("pipe_winsys", "buffer_write");
591 trace_dump_arg(ptr
, screen
);
593 trace_dump_arg(ptr
, buffer
);
595 trace_dump_arg_begin("data");
596 trace_dump_bytes(map
, buffer
->size
);
597 trace_dump_arg_end();
599 trace_dump_arg_begin("size");
600 trace_dump_uint(buffer
->size
);
601 trace_dump_arg_end();
603 trace_dump_call_end();
605 screen
->buffer_unmap(screen
, buffer
);
613 trace_screen_buffer_map(struct pipe_screen
*_screen
,
614 struct pipe_buffer
*_buffer
,
617 struct trace_screen
*tr_scr
= trace_screen(_screen
);
618 struct trace_buffer
*tr_buf
= trace_buffer(_buffer
);
619 struct pipe_screen
*screen
= tr_scr
->screen
;
620 struct pipe_buffer
*buffer
= tr_buf
->buffer
;
623 assert(screen
->buffer_map
);
624 map
= screen
->buffer_map(screen
, buffer
, usage
);
626 if(usage
& PIPE_BUFFER_USAGE_CPU_WRITE
) {
636 trace_screen_buffer_map_range(struct pipe_screen
*_screen
,
637 struct pipe_buffer
*_buffer
,
642 struct trace_screen
*tr_scr
= trace_screen(_screen
);
643 struct trace_buffer
*tr_buf
= trace_buffer(_buffer
);
644 struct pipe_screen
*screen
= tr_scr
->screen
;
645 struct pipe_buffer
*buffer
= tr_buf
->buffer
;
648 assert(screen
->buffer_map_range
);
649 map
= screen
->buffer_map_range(screen
, buffer
, offset
, length
, usage
);
651 if(usage
& PIPE_BUFFER_USAGE_CPU_WRITE
) {
661 buffer_write(struct pipe_screen
*screen
,
662 struct pipe_buffer
*buffer
,
669 trace_dump_call_begin("pipe_screen", "buffer_write");
671 trace_dump_arg(ptr
, screen
);
673 trace_dump_arg(ptr
, buffer
);
675 trace_dump_arg(uint
, offset
);
677 trace_dump_arg_begin("data");
678 trace_dump_bytes(map
+ offset
, size
);
679 trace_dump_arg_end();
681 trace_dump_arg(uint
, size
);
683 trace_dump_call_end();
689 trace_screen_buffer_flush_mapped_range(struct pipe_screen
*_screen
,
690 struct pipe_buffer
*_buffer
,
694 struct trace_screen
*tr_scr
= trace_screen(_screen
);
695 struct trace_buffer
*tr_buf
= trace_buffer(_buffer
);
696 struct pipe_screen
*screen
= tr_scr
->screen
;
697 struct pipe_buffer
*buffer
= tr_buf
->buffer
;
700 buffer_write(screen
, buffer
, offset
, tr_buf
->map
, length
);
701 tr_buf
->range_flushed
= TRUE
;
702 screen
->buffer_flush_mapped_range(screen
, buffer
, offset
, length
);
707 trace_screen_buffer_unmap(struct pipe_screen
*_screen
,
708 struct pipe_buffer
*_buffer
)
710 struct trace_screen
*tr_scr
= trace_screen(_screen
);
711 struct trace_buffer
*tr_buf
= trace_buffer(_buffer
);
712 struct pipe_screen
*screen
= tr_scr
->screen
;
713 struct pipe_buffer
*buffer
= tr_buf
->buffer
;
715 if (tr_buf
->map
&& !tr_buf
->range_flushed
)
716 buffer_write(screen
, buffer
, 0, tr_buf
->map
, buffer
->size
);
718 tr_buf
->range_flushed
= FALSE
;
719 screen
->buffer_unmap(screen
, buffer
);
724 trace_screen_buffer_destroy(struct pipe_buffer
*_buffer
)
726 struct trace_screen
*tr_scr
= trace_screen(_buffer
->screen
);
727 struct trace_buffer
*tr_buf
= trace_buffer(_buffer
);
728 struct pipe_screen
*screen
= tr_scr
->screen
;
729 struct pipe_buffer
*buffer
= tr_buf
->buffer
;
731 trace_dump_call_begin("pipe_screen", "buffer_destroy");
733 trace_dump_arg(ptr
, screen
);
734 trace_dump_arg(ptr
, buffer
);
736 trace_dump_call_end();
738 trace_buffer_destroy(tr_scr
, _buffer
);
742 /********************************************************************
748 trace_screen_fence_reference(struct pipe_screen
*_screen
,
749 struct pipe_fence_handle
**pdst
,
750 struct pipe_fence_handle
*src
)
752 struct trace_screen
*tr_scr
= trace_screen(_screen
);
753 struct pipe_screen
*screen
= tr_scr
->screen
;
754 struct pipe_fence_handle
*dst
;
759 trace_dump_call_begin("pipe_screen", "fence_reference");
761 trace_dump_arg(ptr
, screen
);
762 trace_dump_arg(ptr
, dst
);
763 trace_dump_arg(ptr
, src
);
765 screen
->fence_reference(screen
, pdst
, src
);
767 trace_dump_call_end();
772 trace_screen_fence_signalled(struct pipe_screen
*_screen
,
773 struct pipe_fence_handle
*fence
,
776 struct trace_screen
*tr_scr
= trace_screen(_screen
);
777 struct pipe_screen
*screen
= tr_scr
->screen
;
780 trace_dump_call_begin("pipe_screen", "fence_signalled");
782 trace_dump_arg(ptr
, screen
);
783 trace_dump_arg(ptr
, fence
);
784 trace_dump_arg(uint
, flags
);
786 result
= screen
->fence_signalled(screen
, fence
, flags
);
788 trace_dump_ret(int, result
);
790 trace_dump_call_end();
797 trace_screen_fence_finish(struct pipe_screen
*_screen
,
798 struct pipe_fence_handle
*fence
,
801 struct trace_screen
*tr_scr
= trace_screen(_screen
);
802 struct pipe_screen
*screen
= tr_scr
->screen
;
805 trace_dump_call_begin("pipe_screen", "fence_finish");
807 trace_dump_arg(ptr
, screen
);
808 trace_dump_arg(ptr
, fence
);
809 trace_dump_arg(uint
, flags
);
811 result
= screen
->fence_finish(screen
, fence
, flags
);
813 trace_dump_ret(int, result
);
815 trace_dump_call_end();
821 /********************************************************************
826 trace_screen_destroy(struct pipe_screen
*_screen
)
828 struct trace_screen
*tr_scr
= trace_screen(_screen
);
829 struct pipe_screen
*screen
= tr_scr
->screen
;
831 trace_dump_call_begin("pipe_screen", "destroy");
832 trace_dump_arg(ptr
, screen
);
833 trace_dump_call_end();
834 trace_dump_trace_end();
837 trace_rbug_stop(tr_scr
->rbug
);
839 screen
->destroy(screen
);
847 static boolean firstrun
= TRUE
;
855 if(trace_dump_trace_begin()) {
856 trace_dumping_start();
860 if (debug_get_bool_option("GALLIUM_RBUG", FALSE
)) {
869 trace_screen_create(struct pipe_screen
*screen
)
871 struct trace_screen
*tr_scr
;
872 struct pipe_winsys
*winsys
;
877 if (!trace_enabled())
880 trace_dump_call_begin("", "pipe_screen_create");
882 tr_scr
= CALLOC_STRUCT(trace_screen
);
887 winsys
= trace_winsys_create(screen
->winsys
);
891 winsys
= screen
->winsys
;
893 pipe_mutex_init(tr_scr
->list_mutex
);
894 make_empty_list(&tr_scr
->buffers
);
895 make_empty_list(&tr_scr
->contexts
);
896 make_empty_list(&tr_scr
->textures
);
897 make_empty_list(&tr_scr
->surfaces
);
898 make_empty_list(&tr_scr
->transfers
);
900 tr_scr
->base
.winsys
= winsys
;
901 tr_scr
->base
.destroy
= trace_screen_destroy
;
902 tr_scr
->base
.get_name
= trace_screen_get_name
;
903 tr_scr
->base
.get_vendor
= trace_screen_get_vendor
;
904 tr_scr
->base
.get_param
= trace_screen_get_param
;
905 tr_scr
->base
.get_paramf
= trace_screen_get_paramf
;
906 tr_scr
->base
.is_format_supported
= trace_screen_is_format_supported
;
907 tr_scr
->base
.texture_create
= trace_screen_texture_create
;
908 tr_scr
->base
.texture_blanket
= trace_screen_texture_blanket
;
909 tr_scr
->base
.texture_destroy
= trace_screen_texture_destroy
;
910 tr_scr
->base
.get_tex_surface
= trace_screen_get_tex_surface
;
911 tr_scr
->base
.tex_surface_destroy
= trace_screen_tex_surface_destroy
;
912 tr_scr
->base
.get_tex_transfer
= trace_screen_get_tex_transfer
;
913 tr_scr
->base
.tex_transfer_destroy
= trace_screen_tex_transfer_destroy
;
914 tr_scr
->base
.transfer_map
= trace_screen_transfer_map
;
915 tr_scr
->base
.transfer_unmap
= trace_screen_transfer_unmap
;
916 tr_scr
->base
.buffer_create
= trace_screen_buffer_create
;
917 tr_scr
->base
.user_buffer_create
= trace_screen_user_buffer_create
;
918 tr_scr
->base
.surface_buffer_create
= trace_screen_surface_buffer_create
;
919 if (screen
->buffer_map
)
920 tr_scr
->base
.buffer_map
= trace_screen_buffer_map
;
921 if (screen
->buffer_map_range
)
922 tr_scr
->base
.buffer_map_range
= trace_screen_buffer_map_range
;
923 if (screen
->buffer_flush_mapped_range
)
924 tr_scr
->base
.buffer_flush_mapped_range
= trace_screen_buffer_flush_mapped_range
;
925 if (screen
->buffer_unmap
)
926 tr_scr
->base
.buffer_unmap
= trace_screen_buffer_unmap
;
927 tr_scr
->base
.buffer_destroy
= trace_screen_buffer_destroy
;
928 tr_scr
->base
.fence_reference
= trace_screen_fence_reference
;
929 tr_scr
->base
.fence_signalled
= trace_screen_fence_signalled
;
930 tr_scr
->base
.fence_finish
= trace_screen_fence_finish
;
931 tr_scr
->base
.flush_frontbuffer
= trace_screen_flush_frontbuffer
;
932 tr_scr
->screen
= screen
;
934 trace_dump_ret(ptr
, screen
);
935 trace_dump_call_end();
938 tr_scr
->rbug
= trace_rbug_start(tr_scr
);
940 return &tr_scr
->base
;
947 trace_dump_ret(ptr
, screen
);
948 trace_dump_call_end();
949 trace_dump_trace_end();
955 struct trace_screen
*
956 trace_screen(struct pipe_screen
*screen
)
959 assert(screen
->destroy
== trace_screen_destroy
);
960 return (struct trace_screen
*)screen
;