1 /**************************************************************************
2 *
3 * Copyright 2008 VMware, Inc.
4 * All Rights Reserved.
5 *
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:
13 *
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
17 *
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.
25 *
26 **************************************************************************/
27
28 #include "util/u_format.h"
29 #include "util/u_memory.h"
30 #include "util/simple_list.h"
31
32 #include "tr_dump.h"
33 #include "tr_dump_defines.h"
34 #include "tr_dump_state.h"
35 #include "tr_texture.h"
36 #include "tr_context.h"
37 #include "tr_screen.h"
38 #include "tr_public.h"
39
40
41 static boolean trace = FALSE;
42
43 static const char *
trace_screen_get_name(struct pipe_screen * _screen)44 trace_screen_get_name(struct pipe_screen *_screen)
45 {
46 struct trace_screen *tr_scr = trace_screen(_screen);
47 struct pipe_screen *screen = tr_scr->screen;
48 const char *result;
49
50 trace_dump_call_begin("pipe_screen", "get_name");
51
52 trace_dump_arg(ptr, screen);
53
54 result = screen->get_name(screen);
55
56 trace_dump_ret(string, result);
57
58 trace_dump_call_end();
59
60 return result;
61 }
62
63
64 static const char *
trace_screen_get_vendor(struct pipe_screen * _screen)65 trace_screen_get_vendor(struct pipe_screen *_screen)
66 {
67 struct trace_screen *tr_scr = trace_screen(_screen);
68 struct pipe_screen *screen = tr_scr->screen;
69 const char *result;
70
71 trace_dump_call_begin("pipe_screen", "get_vendor");
72
73 trace_dump_arg(ptr, screen);
74
75 result = screen->get_vendor(screen);
76
77 trace_dump_ret(string, result);
78
79 trace_dump_call_end();
80
81 return result;
82 }
83
84
85 static const char *
trace_screen_get_device_vendor(struct pipe_screen * _screen)86 trace_screen_get_device_vendor(struct pipe_screen *_screen)
87 {
88 struct trace_screen *tr_scr = trace_screen(_screen);
89 struct pipe_screen *screen = tr_scr->screen;
90 const char *result;
91
92 trace_dump_call_begin("pipe_screen", "get_device_vendor");
93
94 trace_dump_arg(ptr, screen);
95
96 result = screen->get_device_vendor(screen);
97
98 trace_dump_ret(string, result);
99
100 trace_dump_call_end();
101
102 return result;
103 }
104
105
106 static int
trace_screen_get_param(struct pipe_screen * _screen,enum pipe_cap param)107 trace_screen_get_param(struct pipe_screen *_screen,
108 enum pipe_cap param)
109 {
110 struct trace_screen *tr_scr = trace_screen(_screen);
111 struct pipe_screen *screen = tr_scr->screen;
112 int result;
113
114 trace_dump_call_begin("pipe_screen", "get_param");
115
116 trace_dump_arg(ptr, screen);
117 trace_dump_arg(int, param);
118
119 result = screen->get_param(screen, param);
120
121 trace_dump_ret(int, result);
122
123 trace_dump_call_end();
124
125 return result;
126 }
127
128
129 static int
trace_screen_get_shader_param(struct pipe_screen * _screen,unsigned shader,enum pipe_shader_cap param)130 trace_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader,
131 enum pipe_shader_cap param)
132 {
133 struct trace_screen *tr_scr = trace_screen(_screen);
134 struct pipe_screen *screen = tr_scr->screen;
135 int result;
136
137 trace_dump_call_begin("pipe_screen", "get_shader_param");
138
139 trace_dump_arg(ptr, screen);
140 trace_dump_arg(uint, shader);
141 trace_dump_arg(int, param);
142
143 result = screen->get_shader_param(screen, shader, param);
144
145 trace_dump_ret(int, result);
146
147 trace_dump_call_end();
148
149 return result;
150 }
151
152
153 static float
trace_screen_get_paramf(struct pipe_screen * _screen,enum pipe_capf param)154 trace_screen_get_paramf(struct pipe_screen *_screen,
155 enum pipe_capf param)
156 {
157 struct trace_screen *tr_scr = trace_screen(_screen);
158 struct pipe_screen *screen = tr_scr->screen;
159 float result;
160
161 trace_dump_call_begin("pipe_screen", "get_paramf");
162
163 trace_dump_arg(ptr, screen);
164 trace_dump_arg(int, param);
165
166 result = screen->get_paramf(screen, param);
167
168 trace_dump_ret(float, result);
169
170 trace_dump_call_end();
171
172 return result;
173 }
174
175
176 static int
trace_screen_get_compute_param(struct pipe_screen * _screen,enum pipe_shader_ir ir_type,enum pipe_compute_cap param,void * data)177 trace_screen_get_compute_param(struct pipe_screen *_screen,
178 enum pipe_shader_ir ir_type,
179 enum pipe_compute_cap param, void *data)
180 {
181 struct trace_screen *tr_scr = trace_screen(_screen);
182 struct pipe_screen *screen = tr_scr->screen;
183 int result;
184
185 trace_dump_call_begin("pipe_screen", "get_compute_param");
186
187 trace_dump_arg(ptr, screen);
188 trace_dump_arg(int, ir_type);
189 trace_dump_arg(int, param);
190 trace_dump_arg(ptr, data);
191
192 result = screen->get_compute_param(screen, ir_type, param, data);
193
194 trace_dump_ret(int, result);
195
196 trace_dump_call_end();
197
198 return result;
199 }
200
201
202 static boolean
trace_screen_is_format_supported(struct pipe_screen * _screen,enum pipe_format format,enum pipe_texture_target target,unsigned sample_count,unsigned tex_usage)203 trace_screen_is_format_supported(struct pipe_screen *_screen,
204 enum pipe_format format,
205 enum pipe_texture_target target,
206 unsigned sample_count,
207 unsigned tex_usage)
208 {
209 struct trace_screen *tr_scr = trace_screen(_screen);
210 struct pipe_screen *screen = tr_scr->screen;
211 boolean result;
212
213 trace_dump_call_begin("pipe_screen", "is_format_supported");
214
215 trace_dump_arg(ptr, screen);
216 trace_dump_arg(format, format);
217 trace_dump_arg(int, target);
218 trace_dump_arg(uint, sample_count);
219 trace_dump_arg(uint, tex_usage);
220
221 result = screen->is_format_supported(screen, format, target, sample_count,
222 tex_usage);
223
224 trace_dump_ret(bool, result);
225
226 trace_dump_call_end();
227
228 return result;
229 }
230
231
232 static struct pipe_context *
trace_screen_context_create(struct pipe_screen * _screen,void * priv,unsigned flags)233 trace_screen_context_create(struct pipe_screen *_screen, void *priv,
234 unsigned flags)
235 {
236 struct trace_screen *tr_scr = trace_screen(_screen);
237 struct pipe_screen *screen = tr_scr->screen;
238 struct pipe_context *result;
239
240 trace_dump_call_begin("pipe_screen", "context_create");
241
242 trace_dump_arg(ptr, screen);
243 trace_dump_arg(ptr, priv);
244 trace_dump_arg(uint, flags);
245
246 result = screen->context_create(screen, priv, flags);
247
248 trace_dump_ret(ptr, result);
249
250 trace_dump_call_end();
251
252 result = trace_context_create(tr_scr, result);
253
254 return result;
255 }
256
257
258 static void
trace_screen_flush_frontbuffer(struct pipe_screen * _screen,struct pipe_resource * _resource,unsigned level,unsigned layer,void * context_private,struct pipe_box * sub_box)259 trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
260 struct pipe_resource *_resource,
261 unsigned level, unsigned layer,
262 void *context_private,
263 struct pipe_box *sub_box)
264 {
265 struct trace_screen *tr_scr = trace_screen(_screen);
266 struct trace_resource *tr_res = trace_resource(_resource);
267 struct pipe_screen *screen = tr_scr->screen;
268 struct pipe_resource *resource = tr_res->resource;
269
270 trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
271
272 trace_dump_arg(ptr, screen);
273 trace_dump_arg(ptr, resource);
274 trace_dump_arg(uint, level);
275 trace_dump_arg(uint, layer);
276 /* XXX: hide, as there is nothing we can do with this
277 trace_dump_arg(ptr, context_private);
278 */
279
280 screen->flush_frontbuffer(screen, resource, level, layer, context_private, sub_box);
281
282 trace_dump_call_end();
283 }
284
285
286 /********************************************************************
287 * texture
288 */
289
290
291 static struct pipe_resource *
trace_screen_resource_create(struct pipe_screen * _screen,const struct pipe_resource * templat)292 trace_screen_resource_create(struct pipe_screen *_screen,
293 const struct pipe_resource *templat)
294 {
295 struct trace_screen *tr_scr = trace_screen(_screen);
296 struct pipe_screen *screen = tr_scr->screen;
297 struct pipe_resource *result;
298
299 trace_dump_call_begin("pipe_screen", "resource_create");
300
301 trace_dump_arg(ptr, screen);
302 trace_dump_arg(resource_template, templat);
303
304 result = screen->resource_create(screen, templat);
305
306 trace_dump_ret(ptr, result);
307
308 trace_dump_call_end();
309
310 result = trace_resource_create(tr_scr, result);
311
312 return result;
313 }
314
315 static struct pipe_resource *
trace_screen_resource_from_handle(struct pipe_screen * _screen,const struct pipe_resource * templ,struct winsys_handle * handle,unsigned usage)316 trace_screen_resource_from_handle(struct pipe_screen *_screen,
317 const struct pipe_resource *templ,
318 struct winsys_handle *handle,
319 unsigned usage)
320 {
321 struct trace_screen *tr_screen = trace_screen(_screen);
322 struct pipe_screen *screen = tr_screen->screen;
323 struct pipe_resource *result;
324
325 /* TODO trace call */
326
327 result = screen->resource_from_handle(screen, templ, handle, usage);
328
329 result = trace_resource_create(trace_screen(_screen), result);
330
331 return result;
332 }
333
334 static boolean
trace_screen_resource_get_handle(struct pipe_screen * _screen,struct pipe_context * _pipe,struct pipe_resource * _resource,struct winsys_handle * handle,unsigned usage)335 trace_screen_resource_get_handle(struct pipe_screen *_screen,
336 struct pipe_context *_pipe,
337 struct pipe_resource *_resource,
338 struct winsys_handle *handle,
339 unsigned usage)
340 {
341 struct trace_screen *tr_screen = trace_screen(_screen);
342 struct trace_context *tr_pipe = _pipe ? trace_context(_pipe) : NULL;
343 struct trace_resource *tr_resource = trace_resource(_resource);
344 struct pipe_screen *screen = tr_screen->screen;
345 struct pipe_resource *resource = tr_resource->resource;
346
347 /* TODO trace call */
348
349 return screen->resource_get_handle(screen, tr_pipe ? tr_pipe->pipe : NULL,
350 resource, handle, usage);
351 }
352
353
354
355 static void
trace_screen_resource_destroy(struct pipe_screen * _screen,struct pipe_resource * _resource)356 trace_screen_resource_destroy(struct pipe_screen *_screen,
357 struct pipe_resource *_resource)
358 {
359 struct trace_screen *tr_scr = trace_screen(_screen);
360 struct trace_resource *tr_res = trace_resource(_resource);
361 struct pipe_screen *screen = tr_scr->screen;
362 struct pipe_resource *resource = tr_res->resource;
363
364 assert(resource->screen == screen);
365
366 trace_dump_call_begin("pipe_screen", "resource_destroy");
367
368 trace_dump_arg(ptr, screen);
369 trace_dump_arg(ptr, resource);
370
371 trace_dump_call_end();
372
373 trace_resource_destroy(tr_scr, tr_res);
374 }
375
376
377 /********************************************************************
378 * fence
379 */
380
381
382 static void
trace_screen_fence_reference(struct pipe_screen * _screen,struct pipe_fence_handle ** pdst,struct pipe_fence_handle * src)383 trace_screen_fence_reference(struct pipe_screen *_screen,
384 struct pipe_fence_handle **pdst,
385 struct pipe_fence_handle *src)
386 {
387 struct trace_screen *tr_scr = trace_screen(_screen);
388 struct pipe_screen *screen = tr_scr->screen;
389 struct pipe_fence_handle *dst;
390
391 assert(pdst);
392 dst = *pdst;
393
394 trace_dump_call_begin("pipe_screen", "fence_reference");
395
396 trace_dump_arg(ptr, screen);
397 trace_dump_arg(ptr, dst);
398 trace_dump_arg(ptr, src);
399
400 screen->fence_reference(screen, pdst, src);
401
402 trace_dump_call_end();
403 }
404
405
406 static boolean
trace_screen_fence_finish(struct pipe_screen * _screen,struct pipe_context * _ctx,struct pipe_fence_handle * fence,uint64_t timeout)407 trace_screen_fence_finish(struct pipe_screen *_screen,
408 struct pipe_context *_ctx,
409 struct pipe_fence_handle *fence,
410 uint64_t timeout)
411 {
412 struct trace_screen *tr_scr = trace_screen(_screen);
413 struct pipe_screen *screen = tr_scr->screen;
414 struct pipe_context *ctx = _ctx ? trace_context(_ctx)->pipe : NULL;
415 int result;
416
417 trace_dump_call_begin("pipe_screen", "fence_finish");
418
419 trace_dump_arg(ptr, screen);
420 trace_dump_arg(ptr, ctx);
421 trace_dump_arg(ptr, fence);
422 trace_dump_arg(uint, timeout);
423
424 result = screen->fence_finish(screen, ctx, fence, timeout);
425
426 trace_dump_ret(bool, result);
427
428 trace_dump_call_end();
429
430 return result;
431 }
432
433
434 /********************************************************************
435 * screen
436 */
437
438 static uint64_t
trace_screen_get_timestamp(struct pipe_screen * _screen)439 trace_screen_get_timestamp(struct pipe_screen *_screen)
440 {
441 struct trace_screen *tr_scr = trace_screen(_screen);
442 struct pipe_screen *screen = tr_scr->screen;
443 uint64_t result;
444
445 trace_dump_call_begin("pipe_screen", "get_timestamp");
446 trace_dump_arg(ptr, screen);
447
448 result = screen->get_timestamp(screen);
449
450 trace_dump_ret(uint, result);
451 trace_dump_call_end();
452
453 return result;
454 }
455
456 static void
trace_screen_destroy(struct pipe_screen * _screen)457 trace_screen_destroy(struct pipe_screen *_screen)
458 {
459 struct trace_screen *tr_scr = trace_screen(_screen);
460 struct pipe_screen *screen = tr_scr->screen;
461
462 trace_dump_call_begin("pipe_screen", "destroy");
463 trace_dump_arg(ptr, screen);
464 trace_dump_call_end();
465
466 screen->destroy(screen);
467
468 FREE(tr_scr);
469 }
470
471 boolean
trace_enabled(void)472 trace_enabled(void)
473 {
474 static boolean firstrun = TRUE;
475
476 if (!firstrun)
477 return trace;
478 firstrun = FALSE;
479
480 if(trace_dump_trace_begin()) {
481 trace_dumping_start();
482 trace = TRUE;
483 }
484
485 return trace;
486 }
487
488 struct pipe_screen *
trace_screen_create(struct pipe_screen * screen)489 trace_screen_create(struct pipe_screen *screen)
490 {
491 struct trace_screen *tr_scr;
492
493 if (!trace_enabled())
494 goto error1;
495
496 trace_dump_call_begin("", "pipe_screen_create");
497
498 tr_scr = CALLOC_STRUCT(trace_screen);
499 if (!tr_scr)
500 goto error2;
501
502 tr_scr->base.destroy = trace_screen_destroy;
503 tr_scr->base.get_name = trace_screen_get_name;
504 tr_scr->base.get_vendor = trace_screen_get_vendor;
505 tr_scr->base.get_device_vendor = trace_screen_get_device_vendor;
506 tr_scr->base.get_param = trace_screen_get_param;
507 tr_scr->base.get_shader_param = trace_screen_get_shader_param;
508 tr_scr->base.get_paramf = trace_screen_get_paramf;
509 tr_scr->base.get_compute_param = trace_screen_get_compute_param;
510 tr_scr->base.is_format_supported = trace_screen_is_format_supported;
511 assert(screen->context_create);
512 tr_scr->base.context_create = trace_screen_context_create;
513 tr_scr->base.resource_create = trace_screen_resource_create;
514 tr_scr->base.resource_from_handle = trace_screen_resource_from_handle;
515 tr_scr->base.resource_get_handle = trace_screen_resource_get_handle;
516 tr_scr->base.resource_destroy = trace_screen_resource_destroy;
517 tr_scr->base.fence_reference = trace_screen_fence_reference;
518 tr_scr->base.fence_finish = trace_screen_fence_finish;
519 tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
520 tr_scr->base.get_timestamp = trace_screen_get_timestamp;
521
522 tr_scr->screen = screen;
523
524 trace_dump_ret(ptr, screen);
525 trace_dump_call_end();
526
527 return &tr_scr->base;
528
529 error2:
530 trace_dump_ret(ptr, screen);
531 trace_dump_call_end();
532 error1:
533 return screen;
534 }
535
536
537 struct trace_screen *
trace_screen(struct pipe_screen * screen)538 trace_screen(struct pipe_screen *screen)
539 {
540 assert(screen);
541 assert(screen->destroy == trace_screen_destroy);
542 return (struct trace_screen *)screen;
543 }
544