0,0 → 1,510 |
/************************************************************************** |
* |
* Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas. |
* All Rights Reserved. |
* |
* Permission is hereby granted, free of charge, to any person obtaining a |
* copy of this software and associated documentation files (the |
* "Software"), to deal in the Software without restriction, including |
* without limitation the rights to use, copy, modify, merge, publish, |
* distribute, sub license, and/or sell copies of the Software, and to |
* permit persons to whom the Software is furnished to do so, subject to |
* the following conditions: |
* |
* The above copyright notice and this permission notice (including the |
* next paragraph) shall be included in all copies or substantial portions |
* of the Software. |
* |
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR |
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
* |
**************************************************************************/ |
|
#include "util/u_format.h" |
#include "util/u_memory.h" |
#include "util/u_simple_list.h" |
|
#include "tr_dump.h" |
#include "tr_dump_state.h" |
#include "tr_texture.h" |
#include "tr_context.h" |
#include "tr_screen.h" |
#include "tr_public.h" |
|
#include "pipe/p_format.h" |
|
|
static boolean trace = FALSE; |
|
static const char * |
trace_screen_get_name(struct pipe_screen *_screen) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
const char *result; |
|
trace_dump_call_begin("pipe_screen", "get_name"); |
|
trace_dump_arg(ptr, screen); |
|
result = screen->get_name(screen); |
|
trace_dump_ret(string, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
static const char * |
trace_screen_get_vendor(struct pipe_screen *_screen) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
const char *result; |
|
trace_dump_call_begin("pipe_screen", "get_vendor"); |
|
trace_dump_arg(ptr, screen); |
|
result = screen->get_vendor(screen); |
|
trace_dump_ret(string, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
static int |
trace_screen_get_param(struct pipe_screen *_screen, |
enum pipe_cap param) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
int result; |
|
trace_dump_call_begin("pipe_screen", "get_param"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(int, param); |
|
result = screen->get_param(screen, param); |
|
trace_dump_ret(int, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
static int |
trace_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader, |
enum pipe_shader_cap param) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
int result; |
|
trace_dump_call_begin("pipe_screen", "get_shader_param"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(uint, shader); |
trace_dump_arg(int, param); |
|
result = screen->get_shader_param(screen, shader, param); |
|
trace_dump_ret(int, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
static float |
trace_screen_get_paramf(struct pipe_screen *_screen, |
enum pipe_capf param) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
float result; |
|
trace_dump_call_begin("pipe_screen", "get_paramf"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(int, param); |
|
result = screen->get_paramf(screen, param); |
|
trace_dump_ret(float, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
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) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
boolean result; |
|
trace_dump_call_begin("pipe_screen", "is_format_supported"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(format, format); |
trace_dump_arg(int, target); |
trace_dump_arg(uint, sample_count); |
trace_dump_arg(uint, tex_usage); |
|
result = screen->is_format_supported(screen, format, target, sample_count, |
tex_usage); |
|
trace_dump_ret(bool, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
static struct pipe_context * |
trace_screen_context_create(struct pipe_screen *_screen, void *priv) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
struct pipe_context *result; |
|
trace_dump_call_begin("pipe_screen", "context_create"); |
|
trace_dump_arg(ptr, screen); |
|
result = screen->context_create(screen, priv); |
|
trace_dump_ret(ptr, result); |
|
trace_dump_call_end(); |
|
result = trace_context_create(tr_scr, result); |
|
return result; |
} |
|
|
static void |
trace_screen_flush_frontbuffer(struct pipe_screen *_screen, |
struct pipe_resource *_resource, |
unsigned level, unsigned layer, |
void *context_private) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct trace_resource *tr_res = trace_resource(_resource); |
struct pipe_screen *screen = tr_scr->screen; |
struct pipe_resource *resource = tr_res->resource; |
|
trace_dump_call_begin("pipe_screen", "flush_frontbuffer"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(ptr, resource); |
trace_dump_arg(uint, level); |
trace_dump_arg(uint, layer); |
/* XXX: hide, as there is nothing we can do with this |
trace_dump_arg(ptr, context_private); |
*/ |
|
screen->flush_frontbuffer(screen, resource, level, layer, context_private); |
|
trace_dump_call_end(); |
} |
|
|
/******************************************************************** |
* texture |
*/ |
|
|
static struct pipe_resource * |
trace_screen_resource_create(struct pipe_screen *_screen, |
const struct pipe_resource *templat) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
struct pipe_resource *result; |
|
trace_dump_call_begin("pipe_screen", "resource_create"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(resource_template, templat); |
|
result = screen->resource_create(screen, templat); |
|
trace_dump_ret(ptr, result); |
|
trace_dump_call_end(); |
|
result = trace_resource_create(tr_scr, result); |
|
return result; |
} |
|
static struct pipe_resource * |
trace_screen_resource_from_handle(struct pipe_screen *_screen, |
const struct pipe_resource *templ, |
struct winsys_handle *handle) |
{ |
struct trace_screen *tr_screen = trace_screen(_screen); |
struct pipe_screen *screen = tr_screen->screen; |
struct pipe_resource *result; |
|
/* TODO trace call */ |
|
result = screen->resource_from_handle(screen, templ, handle); |
|
result = trace_resource_create(trace_screen(_screen), result); |
|
return result; |
} |
|
static boolean |
trace_screen_resource_get_handle(struct pipe_screen *_screen, |
struct pipe_resource *_resource, |
struct winsys_handle *handle) |
{ |
struct trace_screen *tr_screen = trace_screen(_screen); |
struct trace_resource *tr_resource = trace_resource(_resource); |
struct pipe_screen *screen = tr_screen->screen; |
struct pipe_resource *resource = tr_resource->resource; |
|
/* TODO trace call */ |
|
return screen->resource_get_handle(screen, resource, handle); |
} |
|
|
|
static void |
trace_screen_resource_destroy(struct pipe_screen *_screen, |
struct pipe_resource *_resource) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct trace_resource *tr_res = trace_resource(_resource); |
struct pipe_screen *screen = tr_scr->screen; |
struct pipe_resource *resource = tr_res->resource; |
|
assert(resource->screen == screen); |
|
trace_dump_call_begin("pipe_screen", "resource_destroy"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(ptr, resource); |
|
trace_dump_call_end(); |
|
trace_resource_destroy(tr_scr, tr_res); |
} |
|
|
/******************************************************************** |
* fence |
*/ |
|
|
static void |
trace_screen_fence_reference(struct pipe_screen *_screen, |
struct pipe_fence_handle **pdst, |
struct pipe_fence_handle *src) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
struct pipe_fence_handle *dst; |
|
assert(pdst); |
dst = *pdst; |
|
trace_dump_call_begin("pipe_screen", "fence_reference"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(ptr, dst); |
trace_dump_arg(ptr, src); |
|
screen->fence_reference(screen, pdst, src); |
|
trace_dump_call_end(); |
} |
|
|
static boolean |
trace_screen_fence_signalled(struct pipe_screen *_screen, |
struct pipe_fence_handle *fence) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
int result; |
|
trace_dump_call_begin("pipe_screen", "fence_signalled"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(ptr, fence); |
|
result = screen->fence_signalled(screen, fence); |
|
trace_dump_ret(bool, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
static boolean |
trace_screen_fence_finish(struct pipe_screen *_screen, |
struct pipe_fence_handle *fence, |
uint64_t timeout) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
int result; |
|
trace_dump_call_begin("pipe_screen", "fence_finish"); |
|
trace_dump_arg(ptr, screen); |
trace_dump_arg(ptr, fence); |
trace_dump_arg(uint, timeout); |
|
result = screen->fence_finish(screen, fence, timeout); |
|
trace_dump_ret(bool, result); |
|
trace_dump_call_end(); |
|
return result; |
} |
|
|
/******************************************************************** |
* screen |
*/ |
|
static uint64_t |
trace_screen_get_timestamp(struct pipe_screen *_screen) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
uint64_t result; |
|
trace_dump_call_begin("pipe_screen", "get_timestamp"); |
trace_dump_arg(ptr, screen); |
|
result = screen->get_timestamp(screen); |
|
trace_dump_ret(uint, result); |
trace_dump_call_end(); |
|
return result; |
} |
|
static void |
trace_screen_destroy(struct pipe_screen *_screen) |
{ |
struct trace_screen *tr_scr = trace_screen(_screen); |
struct pipe_screen *screen = tr_scr->screen; |
|
trace_dump_call_begin("pipe_screen", "destroy"); |
trace_dump_arg(ptr, screen); |
trace_dump_call_end(); |
|
screen->destroy(screen); |
|
FREE(tr_scr); |
} |
|
boolean |
trace_enabled(void) |
{ |
static boolean firstrun = TRUE; |
|
if (!firstrun) |
return trace; |
firstrun = FALSE; |
|
if(trace_dump_trace_begin()) { |
trace_dumping_start(); |
trace = TRUE; |
} |
|
return trace; |
} |
|
struct pipe_screen * |
trace_screen_create(struct pipe_screen *screen) |
{ |
struct trace_screen *tr_scr; |
|
if(!screen) |
goto error1; |
|
if (!trace_enabled()) |
goto error1; |
|
trace_dump_call_begin("", "pipe_screen_create"); |
|
tr_scr = CALLOC_STRUCT(trace_screen); |
if(!tr_scr) |
goto error2; |
|
tr_scr->base.destroy = trace_screen_destroy; |
tr_scr->base.get_name = trace_screen_get_name; |
tr_scr->base.get_vendor = trace_screen_get_vendor; |
tr_scr->base.get_param = trace_screen_get_param; |
tr_scr->base.get_shader_param = trace_screen_get_shader_param; |
tr_scr->base.get_paramf = trace_screen_get_paramf; |
tr_scr->base.is_format_supported = trace_screen_is_format_supported; |
assert(screen->context_create); |
tr_scr->base.context_create = trace_screen_context_create; |
tr_scr->base.resource_create = trace_screen_resource_create; |
tr_scr->base.resource_from_handle = trace_screen_resource_from_handle; |
tr_scr->base.resource_get_handle = trace_screen_resource_get_handle; |
tr_scr->base.resource_destroy = trace_screen_resource_destroy; |
tr_scr->base.fence_reference = trace_screen_fence_reference; |
tr_scr->base.fence_signalled = trace_screen_fence_signalled; |
tr_scr->base.fence_finish = trace_screen_fence_finish; |
tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer; |
tr_scr->base.get_timestamp = trace_screen_get_timestamp; |
|
tr_scr->screen = screen; |
|
trace_dump_ret(ptr, screen); |
trace_dump_call_end(); |
|
return &tr_scr->base; |
|
error2: |
trace_dump_ret(ptr, screen); |
trace_dump_call_end(); |
error1: |
return screen; |
} |
|
|
struct trace_screen * |
trace_screen(struct pipe_screen *screen) |
{ |
assert(screen); |
assert(screen->destroy == trace_screen_destroy); |
return (struct trace_screen *)screen; |
} |