/**
* Create a new primitive setup/render stage.
*/
struct setup_context *setup_create_context( struct softpipe_context *softpipe )
{
struct setup_context *setup = CALLOC_STRUCT(setup_context);
#if SP_NUM_QUAD_THREADS > 1
uint i;
#endif
setup->softpipe = softpipe;
setup->quad.coef = setup->coef;
setup->quad.posCoef = &setup->posCoef;
#if SP_NUM_QUAD_THREADS > 1
setup->que.first = 0;
setup->que.last = 0;
pipe_mutex_init( setup->que.que_mutex );
pipe_condvar_init( setup->que.que_notfull_condvar );
pipe_condvar_init( setup->que.que_notempty_condvar );
setup->que.jobs_added = 0;
setup->que.jobs_done = 0;
pipe_condvar_init( setup->que.que_done_condvar );
for (i = 0; i < SP_NUM_QUAD_THREADS; i++) {
setup->threads[i].setup = setup;
setup->threads[i].id = i;
setup->threads[i].handle = pipe_thread_create( quad_thread, &setup->threads[i] );
}
#endif
return setup;
}
/**
* Create a new fence object.
*
* The rank will be the number of bins in the scene. Whenever a rendering
* thread hits a fence command, it'll increment the fence counter. When
* the counter == the rank, the fence is finished.
*
* \param rank the expected finished value of the fence counter.
*/
struct lp_fence *
lp_fence_create(unsigned rank)
{
static int fence_id;
struct lp_fence *fence = CALLOC_STRUCT(lp_fence);
if (!fence)
return NULL;
pipe_reference_init(&fence->reference, 1);
pipe_mutex_init(fence->mutex);
pipe_condvar_init(fence->signalled);
fence->id = fence_id++;
fence->rank = rank;
if (LP_DEBUG & DEBUG_FENCE)
debug_printf("%s %d\n", __FUNCTION__, fence->id);
return fence;
}
struct util_ringbuffer *util_ringbuffer_create( unsigned dwords )
{
struct util_ringbuffer *ring = CALLOC_STRUCT(util_ringbuffer);
if (ring == NULL)
return NULL;
assert(util_is_power_of_two(dwords));
ring->buf = MALLOC( dwords * sizeof(unsigned) );
if (ring->buf == NULL)
goto fail;
ring->mask = dwords - 1;
pipe_condvar_init(ring->change);
pipe_mutex_init(ring->mutex);
return ring;
fail:
FREE(ring->buf);
FREE(ring);
return NULL;
}
struct pipe_context *
rbug_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
{
struct rbug_context *rb_pipe;
struct rbug_screen *rb_screen = rbug_screen(_screen);
if (!rb_screen)
return NULL;
rb_pipe = CALLOC_STRUCT(rbug_context);
if (!rb_pipe)
return NULL;
pipe_mutex_init(rb_pipe->draw_mutex);
pipe_condvar_init(rb_pipe->draw_cond);
pipe_mutex_init(rb_pipe->call_mutex);
pipe_mutex_init(rb_pipe->list_mutex);
make_empty_list(&rb_pipe->shaders);
rb_pipe->base.screen = _screen;
rb_pipe->base.priv = pipe->priv; /* expose wrapped data */
rb_pipe->base.draw = NULL;
rb_pipe->base.destroy = rbug_destroy;
rb_pipe->base.draw_vbo = rbug_draw_vbo;
rb_pipe->base.create_query = rbug_create_query;
rb_pipe->base.destroy_query = rbug_destroy_query;
rb_pipe->base.begin_query = rbug_begin_query;
rb_pipe->base.end_query = rbug_end_query;
rb_pipe->base.get_query_result = rbug_get_query_result;
rb_pipe->base.create_blend_state = rbug_create_blend_state;
rb_pipe->base.bind_blend_state = rbug_bind_blend_state;
rb_pipe->base.delete_blend_state = rbug_delete_blend_state;
rb_pipe->base.create_sampler_state = rbug_create_sampler_state;
rb_pipe->base.bind_fragment_sampler_states = rbug_bind_fragment_sampler_states;
rb_pipe->base.bind_vertex_sampler_states = rbug_bind_vertex_sampler_states;
rb_pipe->base.delete_sampler_state = rbug_delete_sampler_state;
rb_pipe->base.create_rasterizer_state = rbug_create_rasterizer_state;
rb_pipe->base.bind_rasterizer_state = rbug_bind_rasterizer_state;
rb_pipe->base.delete_rasterizer_state = rbug_delete_rasterizer_state;
rb_pipe->base.create_depth_stencil_alpha_state = rbug_create_depth_stencil_alpha_state;
rb_pipe->base.bind_depth_stencil_alpha_state = rbug_bind_depth_stencil_alpha_state;
rb_pipe->base.delete_depth_stencil_alpha_state = rbug_delete_depth_stencil_alpha_state;
rb_pipe->base.create_fs_state = rbug_create_fs_state;
rb_pipe->base.bind_fs_state = rbug_bind_fs_state;
rb_pipe->base.delete_fs_state = rbug_delete_fs_state;
rb_pipe->base.create_vs_state = rbug_create_vs_state;
rb_pipe->base.bind_vs_state = rbug_bind_vs_state;
rb_pipe->base.delete_vs_state = rbug_delete_vs_state;
rb_pipe->base.create_gs_state = rbug_create_gs_state;
rb_pipe->base.bind_gs_state = rbug_bind_gs_state;
rb_pipe->base.delete_gs_state = rbug_delete_gs_state;
rb_pipe->base.create_vertex_elements_state = rbug_create_vertex_elements_state;
rb_pipe->base.bind_vertex_elements_state = rbug_bind_vertex_elements_state;
rb_pipe->base.delete_vertex_elements_state = rbug_delete_vertex_elements_state;
rb_pipe->base.set_blend_color = rbug_set_blend_color;
rb_pipe->base.set_stencil_ref = rbug_set_stencil_ref;
rb_pipe->base.set_clip_state = rbug_set_clip_state;
rb_pipe->base.set_constant_buffer = rbug_set_constant_buffer;
rb_pipe->base.set_framebuffer_state = rbug_set_framebuffer_state;
rb_pipe->base.set_polygon_stipple = rbug_set_polygon_stipple;
rb_pipe->base.set_scissor_states = rbug_set_scissor_states;
rb_pipe->base.set_viewport_states = rbug_set_viewport_states;
rb_pipe->base.set_fragment_sampler_views = rbug_set_fragment_sampler_views;
rb_pipe->base.set_vertex_sampler_views = rbug_set_vertex_sampler_views;
rb_pipe->base.set_vertex_buffers = rbug_set_vertex_buffers;
rb_pipe->base.set_index_buffer = rbug_set_index_buffer;
rb_pipe->base.set_sample_mask = rbug_set_sample_mask;
rb_pipe->base.resource_copy_region = rbug_resource_copy_region;
rb_pipe->base.flush_resource = rbug_flush_resource;
rb_pipe->base.clear = rbug_clear;
rb_pipe->base.clear_render_target = rbug_clear_render_target;
rb_pipe->base.clear_depth_stencil = rbug_clear_depth_stencil;
rb_pipe->base.flush = rbug_flush;
rb_pipe->base.create_sampler_view = rbug_context_create_sampler_view;
rb_pipe->base.sampler_view_destroy = rbug_context_sampler_view_destroy;
rb_pipe->base.create_surface = rbug_context_create_surface;
rb_pipe->base.surface_destroy = rbug_context_surface_destroy;
rb_pipe->base.transfer_map = rbug_context_transfer_map;
rb_pipe->base.transfer_unmap = rbug_context_transfer_unmap;
rb_pipe->base.transfer_flush_region = rbug_context_transfer_flush_region;
rb_pipe->base.transfer_inline_write = rbug_context_transfer_inline_write;
rb_pipe->pipe = pipe;
rbug_screen_add_to_list(rb_screen, contexts, rb_pipe);
if (debug_get_bool_option("GALLIUM_RBUG_START_BLOCKED", FALSE)) {
rb_pipe->draw_blocked = RBUG_BLOCK_BEFORE;
}
return &rb_pipe->base;
}
struct radeon_winsys *radeon_drm_winsys_create(int fd)
{
struct radeon_drm_winsys *ws;
if (!fd_tab) {
fd_tab = util_hash_table_create(hash_fd, compare_fd);
}
ws = util_hash_table_get(fd_tab, intptr_to_pointer(fd));
if (ws) {
pipe_reference(NULL, &ws->base.reference);
return &ws->base;
}
ws = CALLOC_STRUCT(radeon_drm_winsys);
if (!ws) {
return NULL;
}
ws->fd = fd;
util_hash_table_set(fd_tab, intptr_to_pointer(fd), ws);
if (!do_winsys_init(ws))
goto fail;
/* Create managers. */
ws->kman = radeon_bomgr_create(ws);
if (!ws->kman)
goto fail;
ws->cman = pb_cache_manager_create(ws->kman, 1000000);
if (!ws->cman)
goto fail;
if (ws->gen >= DRV_R600) {
ws->surf_man = radeon_surface_manager_new(fd);
if (!ws->surf_man)
goto fail;
}
/* init reference */
pipe_reference_init(&ws->base.reference, 1);
/* Set functions. */
ws->base.destroy = radeon_winsys_destroy;
ws->base.query_info = radeon_query_info;
ws->base.cs_request_feature = radeon_cs_request_feature;
ws->base.surface_init = radeon_drm_winsys_surface_init;
ws->base.surface_best = radeon_drm_winsys_surface_best;
ws->base.query_value = radeon_query_value;
radeon_bomgr_init_functions(ws);
radeon_drm_cs_init_functions(ws);
pipe_mutex_init(ws->hyperz_owner_mutex);
pipe_mutex_init(ws->cmask_owner_mutex);
pipe_mutex_init(ws->cs_stack_lock);
p_atomic_set(&ws->ncs, 0);
pipe_semaphore_init(&ws->cs_queued, 0);
pipe_condvar_init(ws->cs_queue_empty);
if (ws->num_cpus > 1 && debug_get_option_thread())
ws->thread = pipe_thread_create(radeon_drm_cs_emit_ioctl, ws);
return &ws->base;
fail:
if (ws->cman)
ws->cman->destroy(ws->cman);
if (ws->kman)
ws->kman->destroy(ws->kman);
if (ws->surf_man)
radeon_surface_manager_free(ws->surf_man);
FREE(ws);
return NULL;
}
struct pipe_context *
trace_context_create(struct trace_screen *tr_scr,
struct pipe_context *pipe)
{
struct trace_context *tr_ctx;
if(!pipe)
goto error1;
if(!trace_enabled())
goto error1;
tr_ctx = CALLOC_STRUCT(trace_context);
if(!tr_ctx)
goto error1;
tr_ctx->base.winsys = NULL;
tr_ctx->base.priv = pipe->priv; /* expose wrapped priv data */
tr_ctx->base.screen = &tr_scr->base;
tr_ctx->draw_blocker = debug_get_flags_option("RBUG_BLOCK",
rbug_blocker_flags,
0);
pipe_mutex_init(tr_ctx->draw_mutex);
pipe_condvar_init(tr_ctx->draw_cond);
pipe_mutex_init(tr_ctx->list_mutex);
make_empty_list(&tr_ctx->shaders);
tr_ctx->base.destroy = trace_context_destroy;
tr_ctx->base.draw_arrays = trace_context_draw_arrays;
tr_ctx->base.draw_elements = trace_context_draw_elements;
tr_ctx->base.draw_range_elements = trace_context_draw_range_elements;
tr_ctx->base.create_query = trace_context_create_query;
tr_ctx->base.destroy_query = trace_context_destroy_query;
tr_ctx->base.begin_query = trace_context_begin_query;
tr_ctx->base.end_query = trace_context_end_query;
tr_ctx->base.get_query_result = trace_context_get_query_result;
tr_ctx->base.create_blend_state = trace_context_create_blend_state;
tr_ctx->base.bind_blend_state = trace_context_bind_blend_state;
tr_ctx->base.delete_blend_state = trace_context_delete_blend_state;
tr_ctx->base.create_sampler_state = trace_context_create_sampler_state;
tr_ctx->base.bind_fragment_sampler_states = trace_context_bind_fragment_sampler_states;
tr_ctx->base.bind_vertex_sampler_states = trace_context_bind_vertex_sampler_states;
tr_ctx->base.delete_sampler_state = trace_context_delete_sampler_state;
tr_ctx->base.create_rasterizer_state = trace_context_create_rasterizer_state;
tr_ctx->base.bind_rasterizer_state = trace_context_bind_rasterizer_state;
tr_ctx->base.delete_rasterizer_state = trace_context_delete_rasterizer_state;
tr_ctx->base.create_depth_stencil_alpha_state = trace_context_create_depth_stencil_alpha_state;
tr_ctx->base.bind_depth_stencil_alpha_state = trace_context_bind_depth_stencil_alpha_state;
tr_ctx->base.delete_depth_stencil_alpha_state = trace_context_delete_depth_stencil_alpha_state;
tr_ctx->base.create_fs_state = trace_context_create_fs_state;
tr_ctx->base.bind_fs_state = trace_context_bind_fs_state;
tr_ctx->base.delete_fs_state = trace_context_delete_fs_state;
tr_ctx->base.create_vs_state = trace_context_create_vs_state;
tr_ctx->base.bind_vs_state = trace_context_bind_vs_state;
tr_ctx->base.delete_vs_state = trace_context_delete_vs_state;
tr_ctx->base.set_blend_color = trace_context_set_blend_color;
tr_ctx->base.set_stencil_ref = trace_context_set_stencil_ref;
tr_ctx->base.set_clip_state = trace_context_set_clip_state;
tr_ctx->base.set_constant_buffer = trace_context_set_constant_buffer;
tr_ctx->base.set_framebuffer_state = trace_context_set_framebuffer_state;
tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
tr_ctx->base.set_fragment_sampler_textures = trace_context_set_fragment_sampler_textures;
tr_ctx->base.set_vertex_sampler_textures = trace_context_set_vertex_sampler_textures;
tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements;
if (pipe->surface_copy)
tr_ctx->base.surface_copy = trace_context_surface_copy;
if (pipe->surface_fill)
tr_ctx->base.surface_fill = trace_context_surface_fill;
tr_ctx->base.clear = trace_context_clear;
tr_ctx->base.flush = trace_context_flush;
tr_ctx->base.is_texture_referenced = trace_is_texture_referenced;
tr_ctx->base.is_buffer_referenced = trace_is_buffer_referenced;
tr_ctx->pipe = pipe;
trace_screen_add_to_list(tr_scr, contexts, tr_ctx);
return &tr_ctx->base;
error1:
return pipe;
}