static void
trace_winsys_flush_frontbuffer(struct pipe_winsys *_winsys,
struct pipe_surface *surface,
void *context_private)
{
struct trace_winsys *tr_ws = trace_winsys(_winsys);
struct pipe_winsys *winsys = tr_ws->winsys;
assert(surface);
if(surface->texture) {
struct trace_screen *tr_scr = trace_screen(surface->texture->screen);
struct trace_texture *tr_tex = trace_texture(tr_scr, surface->texture);
struct trace_surface *tr_surf = trace_surface(tr_tex, surface);
surface = tr_surf->surface;
}
trace_dump_call_begin("pipe_winsys", "flush_frontbuffer");
trace_dump_arg(ptr, winsys);
trace_dump_arg(ptr, surface);
/* XXX: hide, as there is nothing we can do with this
trace_dump_arg(ptr, context_private);
*/
winsys->flush_frontbuffer(winsys, surface, context_private);
trace_dump_call_end();
}
static struct pipe_surface *
trace_screen_get_tex_surface(struct pipe_screen *_screen,
struct pipe_resource *_texture,
unsigned face, unsigned level,
unsigned zslice,
unsigned usage)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_resource *tr_tex = trace_resource(_texture);
struct pipe_screen *screen = tr_scr->screen;
struct pipe_resource *texture = tr_tex->resource;
struct pipe_surface *result = NULL;
assert(texture->screen == screen);
trace_dump_call_begin("pipe_screen", "get_tex_surface");
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, texture);
trace_dump_arg(uint, face);
trace_dump_arg(uint, level);
trace_dump_arg(uint, zslice);
trace_dump_arg(uint, usage);
result = screen->get_tex_surface(screen, texture, face, level, zslice, usage);
trace_dump_ret(ptr, result);
trace_dump_call_end();
result = trace_surface_create(tr_tex, result);
return result;
}
struct pipe_surface *
trace_surface_create(struct trace_texture *tr_tex,
struct pipe_surface *surface)
{
struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
struct trace_surface *tr_surf;
if(!surface)
goto error;
assert(surface->texture == tr_tex->texture);
tr_surf = CALLOC_STRUCT(trace_surface);
if(!tr_surf)
goto error;
memcpy(&tr_surf->base, surface, sizeof(struct pipe_surface));
pipe_reference_init(&tr_surf->base.reference, 1);
tr_surf->base.texture = NULL;
pipe_texture_reference(&tr_surf->base.texture, &tr_tex->base);
tr_surf->surface = surface;
trace_screen_add_to_list(tr_scr, surfaces, tr_surf);
return &tr_surf->base;
error:
pipe_surface_reference(&surface, NULL);
return NULL;
}
struct pipe_transfer *
trace_transfer_create(struct trace_texture *tr_tex,
struct pipe_transfer *transfer)
{
struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
struct trace_transfer *tr_trans;
if(!transfer)
goto error;
assert(transfer->texture == tr_tex->texture);
tr_trans = CALLOC_STRUCT(trace_transfer);
if(!tr_trans)
goto error;
memcpy(&tr_trans->base, transfer, sizeof(struct pipe_transfer));
tr_trans->base.texture = NULL;
pipe_texture_reference(&tr_trans->base.texture, &tr_tex->base);
tr_trans->transfer = transfer;
assert(tr_trans->base.texture == &tr_tex->base);
trace_screen_add_to_list(tr_scr, transfers, tr_trans);
return &tr_trans->base;
error:
transfer->texture->screen->tex_transfer_destroy(transfer);
return NULL;
}
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 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)
{
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, sub_box);
trace_dump_call_end();
}
static struct pipe_resource *
trace_screen_user_buffer_create(struct pipe_screen *_screen,
void *data,
unsigned size,
unsigned usage)
{
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", "user_buffer_create");
trace_dump_arg(ptr, screen);
trace_dump_arg_begin("data");
trace_dump_bytes(data, size);
trace_dump_arg_end();
trace_dump_arg(uint, size);
trace_dump_arg(uint, usage);
result = screen->user_buffer_create(screen, data, size, usage);
trace_dump_ret(ptr, result);
trace_dump_call_end();
if(result) {
assert(!(result->flags & TRACE_FLAG_USER_BUFFER));
result->flags |= TRACE_FLAG_USER_BUFFER;
}
return trace_resource_create(tr_scr, 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;
}
void
trace_texture_destroy(struct trace_texture *tr_tex)
{
struct trace_screen *tr_scr = trace_screen(tr_tex->base.screen);
trace_screen_remove_from_list(tr_scr, textures, tr_tex);
pipe_texture_reference(&tr_tex->texture, NULL);
FREE(tr_tex);
}
void
trace_surface_destroy(struct trace_surface *tr_surf)
{
struct trace_screen *tr_scr = trace_screen(tr_surf->base.texture->screen);
trace_screen_remove_from_list(tr_scr, surfaces, tr_surf);
pipe_texture_reference(&tr_surf->base.texture, NULL);
pipe_surface_reference(&tr_surf->surface, NULL);
FREE(tr_surf);
}
void
trace_transfer_destroy(struct trace_transfer *tr_trans)
{
struct trace_screen *tr_scr = trace_screen(tr_trans->base.texture->screen);
struct pipe_screen *screen = tr_trans->transfer->texture->screen;
trace_screen_remove_from_list(tr_scr, transfers, tr_trans);
pipe_texture_reference(&tr_trans->base.texture, NULL);
screen->tex_transfer_destroy(tr_trans->transfer);
FREE(tr_trans);
}
static struct pipe_texture *
trace_screen_texture_create(struct pipe_screen *_screen,
const struct pipe_texture *templat)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
struct pipe_texture *result;
trace_dump_call_begin("pipe_screen", "texture_create");
trace_dump_arg(ptr, screen);
trace_dump_arg(template, templat);
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);
}
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 INLINE struct pipe_buffer *
trace_buffer_unwrap(struct trace_context *tr_ctx,
struct pipe_buffer *buffer)
{
struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
struct trace_buffer *tr_buf;
if(!buffer)
return NULL;
tr_buf = trace_buffer(buffer);
assert(tr_buf->buffer);
assert(tr_buf->buffer->screen == tr_scr->screen);
(void) tr_scr;
return tr_buf->buffer;
}
static INLINE void
trace_context_destroy(struct pipe_context *_pipe)
{
struct trace_screen *tr_scr = trace_screen(_pipe->screen);
struct trace_context *tr_ctx = trace_context(_pipe);
struct pipe_context *pipe = tr_ctx->pipe;
trace_dump_call_begin("pipe_context", "destroy");
trace_dump_arg(ptr, pipe);
trace_dump_call_end();
trace_screen_remove_from_list(tr_scr, contexts, tr_ctx);
pipe->destroy(pipe);
FREE(tr_ctx);
}
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_tex_surface_destroy(struct pipe_surface *_surface)
{
struct trace_screen *tr_scr = trace_screen(_surface->texture->screen);
struct trace_surface *tr_surf = trace_surface(_surface);
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *surface = tr_surf->surface;
trace_dump_call_begin("pipe_screen", "tex_surface_destroy");
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, surface);
trace_dump_call_end();
trace_surface_destroy(tr_surf);
}
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 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);
}
static void
trace_screen_resource_destroy(struct pipe_screen *_screen,
struct pipe_resource *_texture)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_resource *tr_tex = trace_resource(_texture);
struct pipe_screen *screen = tr_scr->screen;
struct pipe_resource *texture = tr_tex->resource;
assert(texture->screen == screen);
trace_dump_call_begin("pipe_screen", "texture_destroy");
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, texture);
trace_dump_call_end();
trace_resource_destroy(tr_scr, tr_tex);
}
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 INLINE struct pipe_surface *
trace_surface_unwrap(struct trace_context *tr_ctx,
struct pipe_surface *surface)
{
struct trace_screen *tr_scr = trace_screen(tr_ctx->base.screen);
struct trace_surface *tr_surf;
if(!surface)
return NULL;
assert(surface->texture);
if(!surface->texture)
return surface;
tr_surf = trace_surface(surface);
assert(tr_surf->surface);
assert(tr_surf->surface->texture->screen == tr_scr->screen);
(void) tr_scr;
return tr_surf->surface;
}
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 float
trace_screen_get_paramf(struct pipe_screen *_screen,
int 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 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 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 void
trace_screen_flush_frontbuffer(struct pipe_screen *_screen,
struct pipe_surface *_surface,
void *context_private)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct trace_surface *tr_surf = trace_surface(_surface);
struct pipe_screen *screen = tr_scr->screen;
struct pipe_surface *surface = tr_surf->surface;
trace_dump_call_begin("pipe_screen", "flush_frontbuffer");
trace_dump_arg(ptr, screen);
trace_dump_arg(ptr, surface);
/* XXX: hide, as there is nothing we can do with this
trace_dump_arg(ptr, context_private);
*/
screen->flush_frontbuffer(screen, surface, context_private);
trace_dump_call_end();
}
/**
* XXX: Dispatch pipe_screen::flush_front_buffer to our
* stw_winsys::flush_front_buffer.
*/
static void
stw_flush_frontbuffer(struct pipe_screen *screen,
struct pipe_surface *surface,
void *context_private )
{
const struct stw_winsys *stw_winsys = stw_dev->stw_winsys;
HDC hdc = (HDC)context_private;
struct stw_framebuffer *fb;
fb = stw_framebuffer_from_hdc( hdc );
/* fb can be NULL if window was destroyed already */
if (fb) {
#if DEBUG
{
struct pipe_surface *surface2;
if(!st_get_framebuffer_surface( fb->stfb, ST_SURFACE_FRONT_LEFT, &surface2 ))
assert(0);
else
assert(surface2 == surface);
}
#endif
#ifdef DEBUG
if(stw_dev->trace_running) {
screen = trace_screen(screen)->screen;
surface = trace_surface(surface)->surface;
}
#endif
}
stw_winsys->flush_frontbuffer(screen, surface, hdc);
if(fb) {
stw_framebuffer_update(fb);
stw_framebuffer_release(fb);
}
}
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;
}
