}
+static struct disk_cache *
+trace_screen_get_disk_shader_cache(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", "get_disk_shader_cache");
+
+ trace_dump_arg(ptr, screen);
+
+ struct disk_cache *result = screen->get_disk_shader_cache(screen);
+
+ trace_dump_ret(ptr, result);
+
+ trace_dump_call_end();
+
+ return result;
+}
+
+
static int
trace_screen_get_param(struct pipe_screen *_screen,
enum pipe_cap param)
static int
-trace_screen_get_shader_param(struct pipe_screen *_screen, unsigned shader,
- enum pipe_shader_cap param)
+trace_screen_get_shader_param(struct pipe_screen *_screen,
+ enum pipe_shader_type shader,
+ enum pipe_shader_cap param)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
}
+static int
+trace_screen_get_compute_param(struct pipe_screen *_screen,
+ enum pipe_shader_ir ir_type,
+ enum pipe_compute_cap param, void *data)
+{
+ struct trace_screen *tr_scr = trace_screen(_screen);
+ struct pipe_screen *screen = tr_scr->screen;
+ int result;
+
+ trace_dump_call_begin("pipe_screen", "get_compute_param");
+
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(int, ir_type);
+ trace_dump_arg(int, param);
+ trace_dump_arg(ptr, data);
+
+ result = screen->get_compute_param(screen, ir_type, param, data);
+
+ trace_dump_ret(int, result);
+
+ trace_dump_call_end();
+
+ return result;
+}
+
+
static boolean
trace_screen_is_format_supported(struct pipe_screen *_screen,
enum pipe_format format,
static void
trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
- struct pipe_resource *_resource,
+ struct pipe_resource *resource,
unsigned level, unsigned layer,
void *context_private,
struct pipe_box *sub_box)
{
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");
}
+static void
+trace_screen_get_driver_uuid(struct pipe_screen *_screen, char *uuid)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+
+ trace_dump_call_begin("pipe_screen", "get_driver_uuid");
+ trace_dump_arg(ptr, screen);
+
+ screen->get_driver_uuid(screen, uuid);
+
+ trace_dump_ret(string, uuid);
+ trace_dump_call_end();
+}
+
+static void
+trace_screen_get_device_uuid(struct pipe_screen *_screen, char *uuid)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+
+ trace_dump_call_begin("pipe_screen", "get_device_uuid");
+ trace_dump_arg(ptr, screen);
+
+ screen->get_device_uuid(screen, uuid);
+
+ trace_dump_ret(string, uuid);
+ trace_dump_call_end();
+}
+
+
/********************************************************************
* texture
*/
trace_dump_call_end();
- result = trace_resource_create(tr_scr, result);
-
+ if (result)
+ result->screen = _screen;
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 winsys_handle *handle,
+ unsigned usage)
{
struct trace_screen *tr_screen = trace_screen(_screen);
struct pipe_screen *screen = tr_screen->screen;
/* TODO trace call */
- result = screen->resource_from_handle(screen, templ, handle);
-
- result = trace_resource_create(trace_screen(_screen), result);
+ result = screen->resource_from_handle(screen, templ, handle, usage);
+ if (result)
+ result->screen = _screen;
return result;
}
+static bool
+trace_screen_check_resource_capability(struct pipe_screen *_screen,
+ struct pipe_resource *resource,
+ unsigned bind)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+
+ return screen->check_resource_capability(screen, resource, bind);
+}
+
static boolean
trace_screen_resource_get_handle(struct pipe_screen *_screen,
- struct pipe_resource *_resource,
- struct winsys_handle *handle)
+ struct pipe_context *_pipe,
+ struct pipe_resource *resource,
+ struct winsys_handle *handle,
+ unsigned usage)
{
struct trace_screen *tr_screen = trace_screen(_screen);
- struct trace_resource *tr_resource = trace_resource(_resource);
+ struct trace_context *tr_pipe = _pipe ? trace_context(_pipe) : NULL;
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);
+ return screen->resource_get_handle(screen, tr_pipe ? tr_pipe->pipe : NULL,
+ resource, handle, usage);
}
+static struct pipe_resource *
+trace_screen_resource_from_memobj(struct pipe_screen *_screen,
+ const struct pipe_resource *templ,
+ struct pipe_memory_object *memobj,
+ uint64_t offset)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+ trace_dump_call_begin("pipe_screen", "resource_from_memobj");
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(resource_template, templ);
+ trace_dump_arg(ptr, memobj);
+ trace_dump_arg(uint, offset);
+
+ struct pipe_resource *res =
+ screen->resource_from_memobj(screen, templ, memobj, offset);
+
+ if (!res)
+ return NULL;
+ res->screen = _screen;
+
+ trace_dump_ret(ptr, res);
+ trace_dump_call_end();
+ return res;
+}
static void
-trace_screen_resource_destroy(struct pipe_screen *_screen,
- struct pipe_resource *_resource)
+trace_screen_resource_changed(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_call_begin("pipe_screen", "resource_changed");
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, resource);
+ screen->resource_changed(screen, resource);
+
trace_dump_call_end();
+}
+
+static void
+trace_screen_resource_destroy(struct pipe_screen *_screen,
+ struct pipe_resource *resource)
+{
+ struct trace_screen *tr_scr = trace_screen(_screen);
+ struct pipe_screen *screen = tr_scr->screen;
- trace_resource_destroy(tr_scr, tr_res);
+ /* Don't trace this, because due to the lack of pipe_resource wrapping,
+ * we can get this call from inside of driver calls, which would try
+ * to lock an already-locked mutex.
+ */
+ screen->resource_destroy(screen, resource);
}
static boolean
trace_screen_fence_finish(struct pipe_screen *_screen,
+ struct pipe_context *_ctx,
struct pipe_fence_handle *fence,
uint64_t timeout)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
+ struct pipe_context *ctx = _ctx ? trace_context(_ctx)->pipe : NULL;
int result;
trace_dump_call_begin("pipe_screen", "fence_finish");
trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, ctx);
trace_dump_arg(ptr, fence);
trace_dump_arg(uint, timeout);
- result = screen->fence_finish(screen, fence, timeout);
+ result = screen->fence_finish(screen, ctx, fence, timeout);
trace_dump_ret(bool, result);
}
+/********************************************************************
+ * memobj
+ */
+
+static struct pipe_memory_object *
+trace_screen_memobj_create_from_handle(struct pipe_screen *_screen,
+ struct winsys_handle *handle,
+ bool dedicated)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+
+ trace_dump_call_begin("pipe_screen", "memobj_create_from_handle");
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, handle);
+ trace_dump_arg(bool, dedicated);
+
+ struct pipe_memory_object *res =
+ screen->memobj_create_from_handle(screen, handle, dedicated);
+
+ trace_dump_ret(ptr, res);
+ trace_dump_call_end();
+
+ return res;
+}
+
+static void
+trace_screen_memobj_destroy(struct pipe_screen *_screen,
+ struct pipe_memory_object *memobj)
+{
+ struct pipe_screen *screen = trace_screen(_screen)->screen;
+
+ trace_dump_call_begin("pipe_screen", "memobj_destroy");
+ trace_dump_arg(ptr, screen);
+ trace_dump_arg(ptr, memobj);
+ trace_dump_call_end();
+
+ screen->memobj_destroy(screen, memobj);
+}
+
+
/********************************************************************
* screen
*/
trace_dump_call_begin("", "pipe_screen_create");
tr_scr = CALLOC_STRUCT(trace_screen);
- if(!tr_scr)
+ if (!tr_scr)
goto error2;
+#define SCR_INIT(_member) \
+ tr_scr->base._member = screen->_member ? trace_screen_##_member : NULL
+
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_device_vendor = trace_screen_get_device_vendor;
+ SCR_INIT(get_disk_shader_cache);
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.get_compute_param = trace_screen_get_compute_param;
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;
+ SCR_INIT(check_resource_capability);
tr_scr->base.resource_get_handle = trace_screen_resource_get_handle;
+ SCR_INIT(resource_from_memobj);
+ SCR_INIT(resource_changed);
tr_scr->base.resource_destroy = trace_screen_resource_destroy;
tr_scr->base.fence_reference = trace_screen_fence_reference;
tr_scr->base.fence_finish = trace_screen_fence_finish;
+ SCR_INIT(memobj_create_from_handle);
+ SCR_INIT(memobj_destroy);
tr_scr->base.flush_frontbuffer = trace_screen_flush_frontbuffer;
tr_scr->base.get_timestamp = trace_screen_get_timestamp;
+ SCR_INIT(get_driver_uuid);
+ SCR_INIT(get_device_uuid);
tr_scr->screen = screen;
projects / mesa.git / blobdiff