static void draw( void )
{
float clear_color[4] = {.1,.3,.5,0};
ctx->clear(ctx, PIPE_CLEAR_COLOR, clear_color, 0, 0);
if (draw_strip)
util_draw_arrays(ctx, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
else
util_draw_arrays(ctx, PIPE_PRIM_TRIANGLES, 0, 3);
ctx->flush(ctx, PIPE_FLUSH_RENDER_CACHE, NULL);
#if 0
/* At the moment, libgraw leaks out/makes available some of the
* symbols from gallium/auxiliary, including these debug helpers.
* Will eventually want to bless some of these paths, and lock the
* others down so they aren't accessible from test programs.
*
* This currently just happens to work on debug builds - a release
* build will probably fail to link here:
*/
debug_dump_surface_bmp(ctx, "result.bmp", surf);
#endif
screen->flush_frontbuffer(screen, surf, window);
}
/**
* Render a polygon silhouette to stencil buffer.
*/
void renderer_polygon_stencil(struct renderer *renderer,
struct pipe_vertex_buffer *vbuf,
VGuint mode, VGuint start, VGuint count)
{
assert(renderer->state == RENDERER_STATE_POLYGON_STENCIL);
renderer->pipe->set_vertex_buffers(renderer->pipe, 1, vbuf);
if (!renderer->u.polygon_stencil.manual_two_sides) {
util_draw_arrays(renderer->pipe, mode, start, count);
}
else {
struct pipe_rasterizer_state raster;
struct pipe_depth_stencil_alpha_state dsa;
raster = renderer->g3d.rasterizer;
dsa = renderer->u.polygon_stencil.dsa;
/* front */
raster.cull_face = PIPE_FACE_BACK;
dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_INCR_WRAP;
cso_set_rasterizer(renderer->cso, &raster);
cso_set_depth_stencil_alpha(renderer->cso, &dsa);
util_draw_arrays(renderer->pipe, mode, start, count);
/* back */
raster.cull_face = PIPE_FACE_FRONT;
dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_DECR_WRAP;
cso_set_rasterizer(renderer->cso, &raster);
cso_set_depth_stencil_alpha(renderer->cso, &dsa);
util_draw_arrays(renderer->pipe, mode, start, count);
}
}
static void draw( void )
{
union pipe_color_union clear_color = { {.1,.3,.5,0} };
ctx->clear(ctx, PIPE_CLEAR_COLOR, &clear_color, 0, 0);
if (draw_strip)
util_draw_arrays(ctx, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
else
util_draw_arrays(ctx, PIPE_PRIM_TRIANGLES, 0, 3);
ctx->flush(ctx, NULL, 0);
graw_save_surface_to_file(ctx, surf, NULL);
screen->flush_frontbuffer(screen, rttex, 0, 0, window, NULL);
}
static void
draw_layers(struct vl_compositor *c, struct vl_compositor_state *s, struct u_rect *dirty)
{
unsigned vb_index, i;
assert(c);
for (i = 0, vb_index = 0; i < VL_COMPOSITOR_MAX_LAYERS; ++i) {
if (s->used_layers & (1 << i)) {
struct vl_compositor_layer *layer = &s->layers[i];
struct pipe_sampler_view **samplers = &layer->sampler_views[0];
unsigned num_sampler_views = !samplers[1] ? 1 : !samplers[2] ? 2 : 3;
void *blend = layer->blend ? layer->blend : i ? c->blend_add : c->blend_clear;
c->pipe->bind_blend_state(c->pipe, blend);
c->pipe->set_viewport_state(c->pipe, &layer->viewport);
c->pipe->bind_fs_state(c->pipe, layer->fs);
c->pipe->bind_fragment_sampler_states(c->pipe, num_sampler_views, layer->samplers);
c->pipe->set_fragment_sampler_views(c->pipe, num_sampler_views, samplers);
util_draw_arrays(c->pipe, PIPE_PRIM_QUADS, vb_index * 4, 4);
vb_index++;
if (dirty) {
// Remember the currently drawn area as dirty for the next draw command
struct u_rect drawn = calc_drawn_area(s, layer);
dirty->x0 = MIN2(drawn.x0, dirty->x0);
dirty->y0 = MIN2(drawn.y0, dirty->y0);
dirty->x1 = MAX2(drawn.x1, dirty->x1);
dirty->y1 = MAX2(drawn.y1, dirty->y1);
}
}
}
}
/**
* Draw a simple vertex buffer / primitive.
* Limited to float[4] vertex attribs, tightly packed.
*/
void
util_draw_vertex_buffer(struct pipe_context *pipe,
struct cso_context *cso,
struct pipe_resource *vbuf,
uint offset,
uint prim_type,
uint num_verts,
uint num_attribs)
{
struct pipe_vertex_buffer vbuffer;
assert(num_attribs <= PIPE_MAX_ATTRIBS);
/* tell pipe about the vertex buffer */
memset(&vbuffer, 0, sizeof(vbuffer));
vbuffer.buffer = vbuf;
vbuffer.stride = num_attribs * 4 * sizeof(float); /* vertex size */
vbuffer.buffer_offset = offset;
/* note: vertex elements already set by caller */
if (cso) {
cso_set_vertex_buffers(cso, 1, &vbuffer);
cso_draw_arrays(cso, prim_type, 0, num_verts);
} else {
pipe->set_vertex_buffers(pipe, 1, &vbuffer);
util_draw_arrays(pipe, prim_type, 0, num_verts);
}
}
static void draw( void )
{
union pipe_color_union clear_color = { {0,0,0,1} };
int i;
printf("Creating %d shaders\n", num_iters);
for (i = 0; i < num_iters; i++) {
void *fs = set_fragment_shader();
ctx->bind_fs_state(ctx, fs);
ctx->clear(ctx, PIPE_CLEAR_COLOR, &clear_color, 0, 0);
util_draw_arrays(ctx, PIPE_PRIM_POINTS, 0, 1);
ctx->flush(ctx, NULL, 0);
ctx->bind_fs_state(ctx, NULL);
ctx->delete_fs_state(ctx, fs);
}
screen->flush_frontbuffer(screen, tex, 0, 0, window, NULL);
ctx->destroy(ctx);
exit(0);
}
void
vl_median_filter_render(struct vl_median_filter *filter,
struct pipe_sampler_view *src,
struct pipe_surface *dst)
{
struct pipe_viewport_state viewport;
struct pipe_framebuffer_state fb_state;
assert(filter && src && dst);
memset(&viewport, 0, sizeof(viewport));
viewport.scale[0] = dst->width;
viewport.scale[1] = dst->height;
viewport.scale[2] = 1;
viewport.scale[3] = 1;
memset(&fb_state, 0, sizeof(fb_state));
fb_state.width = dst->width;
fb_state.height = dst->height;
fb_state.nr_cbufs = 1;
fb_state.cbufs[0] = dst;
filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state);
filter->pipe->bind_blend_state(filter->pipe, filter->blend);
filter->pipe->bind_fragment_sampler_states(filter->pipe, 1, &filter->sampler);
filter->pipe->set_fragment_sampler_views(filter->pipe, 1, &src);
filter->pipe->bind_vs_state(filter->pipe, filter->vs);
filter->pipe->bind_fs_state(filter->pipe, filter->fs);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
filter->pipe->set_vertex_buffers(filter->pipe, 0, 1, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
util_draw_arrays(filter->pipe, PIPE_PRIM_QUADS, 0, 4);
}
static void draw( void )
{
union pipe_color_union clear_color = { {1,0,1,1} };
ctx->clear(ctx, PIPE_CLEAR_COLOR, &clear_color, 0, 0);
util_draw_arrays(ctx, PIPE_PRIM_TRIANGLES, 0, 3);
ctx->flush(ctx, NULL, 0);
screen->flush_frontbuffer(screen, tex, 0, 0, window);
}
static void draw( void )
{
float clear_color[4] = {.1,.3,.5,0};
ctx->clear(ctx, PIPE_CLEAR_COLOR, clear_color, 0, 0);
util_draw_arrays(ctx, PIPE_PRIM_TRIANGLES, 0, 3);
ctx->flush(ctx, PIPE_FLUSH_RENDER_CACHE, NULL);
graw_save_surface_to_file(ctx, surf, NULL);
screen->flush_frontbuffer(screen, rttex, 0, 0, window);
}
static void draw( void )
{
float clear_color[4] = {.5,.5,.5,1};
ctx->clear(ctx, PIPE_CLEAR_COLOR, clear_color, 0, 0);
util_draw_arrays(ctx, PIPE_PRIM_QUADS, 0, 4);
ctx->flush(ctx, NULL);
graw_save_surface_to_file(ctx, surf, NULL);
screen->flush_frontbuffer(screen, rttex, 0, 0, window);
}
static void draw( void )
{
union pipe_color_union clear_color = { {.1,.3,.5,0} };
ctx->clear(ctx, PIPE_CLEAR_COLOR, &clear_color, 0, 0);
util_draw_arrays(ctx, PIPE_PRIM_POINTS, 0, Elements(vertices));
ctx->flush(ctx, NULL);
graw_save_surface_to_file(ctx, surf, NULL);
screen->flush_frontbuffer(screen, rttex, 0, 0, window);
}
void util_blitter_copy_buffer(struct blitter_context *blitter,
struct pipe_resource *dst,
unsigned dstx,
struct pipe_resource *src,
unsigned srcx,
unsigned size)
{
struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
struct pipe_context *pipe = ctx->base.pipe;
struct pipe_vertex_buffer vb;
struct pipe_stream_output_target *so_target;
/* Drivers not capable of Stream Out should not call this function
* in the first place. */
assert(ctx->has_stream_out);
/* Some alignment is required. */
if (srcx % 4 != 0 || dstx % 4 != 0 || size % 16 != 0 ||
!ctx->has_stream_out) {
struct pipe_box box;
u_box_1d(srcx, size, &box);
util_resource_copy_region(pipe, dst, 0, dstx, 0, 0, src, 0, &box);
return;
}
blitter_set_running_flag(ctx);
blitter_check_saved_vertex_states(ctx);
vb.buffer = src;
vb.buffer_offset = srcx;
vb.stride = 4;
pipe->set_vertex_buffers(pipe, 1, &vb);
pipe->bind_vertex_elements_state(pipe, ctx->velem_state_readbuf);
pipe->bind_vs_state(pipe, ctx->vs_pos_only);
if (ctx->has_geometry_shader)
pipe->bind_gs_state(pipe, NULL);
pipe->bind_rasterizer_state(pipe, ctx->rs_discard_state);
so_target = pipe->create_stream_output_target(pipe, dst, dstx, size);
pipe->set_stream_output_targets(pipe, 1, &so_target, 0);
util_draw_arrays(pipe, PIPE_PRIM_POINTS, 0, size / 16);
blitter_restore_vertex_states(ctx);
blitter_unset_running_flag(ctx);
pipe_so_target_reference(&so_target, NULL);
}
static void draw_polygon(struct vg_context *ctx,
struct polygon *poly)
{
int vert_size;
struct pipe_context *pipe;
struct pipe_vertex_buffer vbuffer;
struct pipe_vertex_element velement;
vert_size = poly->num_verts * COMPONENTS * sizeof(float);
/*polygon_print(poly);*/
pipe = ctx->pipe;
if (poly->vbuf == NULL || poly->dirty) {
if (poly->vbuf) {
pipe_resource_reference(&poly->vbuf,
NULL);
}
poly->screen = pipe->screen;
poly->vbuf= pipe_user_buffer_create(poly->screen,
poly->data,
vert_size,
PIPE_BIND_VERTEX_BUFFER);
poly->dirty = VG_FALSE;
}
/* tell pipe about the vertex buffer */
memset(&vbuffer, 0, sizeof(vbuffer));
vbuffer.buffer = poly->vbuf;
vbuffer.stride = COMPONENTS * sizeof(float); /* vertex size */
vbuffer.buffer_offset = 0;
vbuffer.max_index = poly->num_verts - 1;
pipe->set_vertex_buffers(pipe, 1, &vbuffer);
/* tell pipe about the vertex attributes */
memset(&velement, 0, sizeof(velement));
velement.src_offset = 0;
velement.instance_divisor = 0;
velement.vertex_buffer_index = 0;
velement.src_format = PIPE_FORMAT_R32G32_FLOAT;
cso_set_vertex_elements(ctx->cso_context, 1, &velement);
/* draw */
util_draw_arrays(pipe, PIPE_PRIM_TRIANGLE_FAN, 0, (uint) poly->num_verts);
}
void
vl_deint_filter_render(struct vl_deint_filter *filter,
struct pipe_video_buffer *prevprev,
struct pipe_video_buffer *prev,
struct pipe_video_buffer *cur,
struct pipe_video_buffer *next,
unsigned field)
{
struct pipe_viewport_state viewport;
struct pipe_framebuffer_state fb_state;
struct pipe_sampler_view **cur_sv;
struct pipe_sampler_view **prevprev_sv;
struct pipe_sampler_view **prev_sv;
struct pipe_sampler_view **next_sv;
struct pipe_sampler_view *sampler_views[4];
struct pipe_surface **dst_surfaces;
const unsigned *plane_order;
int i;
unsigned j;
assert(filter && prevprev && prev && cur && next && field <= 1);
/* set up destination and source */
dst_surfaces = filter->video_buffer->get_surfaces(filter->video_buffer);
plane_order = vl_video_buffer_plane_order(filter->video_buffer->buffer_format);
cur_sv = cur->get_sampler_view_components(cur);
prevprev_sv = prevprev->get_sampler_view_components(prevprev);
prev_sv = prev->get_sampler_view_components(prev);
next_sv = next->get_sampler_view_components(next);
/* set up pipe state */
filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state);
filter->pipe->set_vertex_buffers(filter->pipe, 0, 1, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
filter->pipe->bind_vs_state(filter->pipe, filter->vs);
filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT,
0, 4, filter->sampler);
/* prepare viewport */
memset(&viewport, 0, sizeof(viewport));
viewport.scale[2] = 1;
/* prepare framebuffer */
memset(&fb_state, 0, sizeof(fb_state));
fb_state.nr_cbufs = 1;
/* process each plane separately */
for (i = 0, j = 0; i < VL_NUM_COMPONENTS; ++i) {
struct pipe_surface *blit_surf = dst_surfaces[field];
struct pipe_surface *dst_surf = dst_surfaces[1 - field];
int k = plane_order[i];
/* bind blend state for this component in the plane */
filter->pipe->bind_blend_state(filter->pipe, filter->blend[j]);
/* update render target state */
viewport.scale[0] = blit_surf->texture->width0;
viewport.scale[1] = blit_surf->texture->height0;
fb_state.width = blit_surf->texture->width0;
fb_state.height = blit_surf->texture->height0;
/* update sampler view sources */
sampler_views[0] = prevprev_sv[k];
sampler_views[1] = prev_sv[k];
sampler_views[2] = cur_sv[k];
sampler_views[3] = next_sv[k];
filter->pipe->set_sampler_views(filter->pipe, PIPE_SHADER_FRAGMENT, 0, 4, sampler_views);
/* blit current field */
fb_state.cbufs[0] = blit_surf;
filter->pipe->bind_fs_state(filter->pipe, field ? filter->fs_copy_bottom : filter->fs_copy_top);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
util_draw_arrays(filter->pipe, PIPE_PRIM_QUADS, 0, 4);
/* blit or interpolate other field */
fb_state.cbufs[0] = dst_surf;
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
if (i > 0 && filter->skip_chroma) {
util_draw_arrays(filter->pipe, PIPE_PRIM_QUADS, 0, 4);
} else {
filter->pipe->bind_fs_state(filter->pipe, field ? filter->fs_deint_top : filter->fs_deint_bottom);
util_draw_arrays(filter->pipe, PIPE_PRIM_QUADS, 0, 4);
}
if (++j >= util_format_get_nr_components(dst_surf->format)) {
dst_surfaces += 2;
j = 0;
}
}
}
void
vl_deint_filter_render(struct vl_deint_filter *filter,
struct pipe_video_buffer *prevprev,
struct pipe_video_buffer *prev,
struct pipe_video_buffer *cur,
struct pipe_video_buffer *next,
unsigned field)
{
struct pipe_viewport_state viewport;
struct pipe_framebuffer_state fb_state;
struct pipe_sampler_view **cur_sv;
struct pipe_sampler_view **prevprev_sv;
struct pipe_sampler_view **prev_sv;
struct pipe_sampler_view **next_sv;
struct pipe_sampler_view *sampler_views[4];
struct pipe_surface **dst_surfaces;
int j;
assert(filter && prevprev && prev && cur && next && field <= 1);
/* set up destination and source */
dst_surfaces = filter->video_buffer->get_surfaces(filter->video_buffer);
cur_sv = cur->get_sampler_view_components(cur);
prevprev_sv = prevprev->get_sampler_view_components(prevprev);
prev_sv = prev->get_sampler_view_components(prev);
next_sv = next->get_sampler_view_components(next);
/* set up pipe state */
filter->pipe->bind_rasterizer_state(filter->pipe, filter->rs_state);
filter->pipe->bind_blend_state(filter->pipe, filter->blend);
filter->pipe->set_vertex_buffers(filter->pipe, 0, 1, &filter->quad);
filter->pipe->bind_vertex_elements_state(filter->pipe, filter->ves);
filter->pipe->bind_vs_state(filter->pipe, filter->vs);
filter->pipe->bind_sampler_states(filter->pipe, PIPE_SHADER_FRAGMENT,
0, 4, filter->sampler);
/* prepare viewport */
memset(&viewport, 0, sizeof(viewport));
viewport.scale[2] = 1;
viewport.scale[3] = 1;
/* prepare framebuffer */
memset(&fb_state, 0, sizeof(fb_state));
fb_state.nr_cbufs = 1;
/* process each plane separately */
for (j = 0; j < 3; j++) {
/* select correct YV12 surfaces */
int k = j == 1 ? 2 :
j == 2 ? 1 : 0;
struct pipe_surface *blit_surf = dst_surfaces[2 * k + field];
struct pipe_surface *dst_surf = dst_surfaces[2 * k + 1 - field];
/* update render target state */
viewport.scale[0] = blit_surf->texture->width0;
viewport.scale[1] = blit_surf->texture->height0;
fb_state.width = blit_surf->texture->width0;
fb_state.height = blit_surf->texture->height0;
/* update sampler view sources */
sampler_views[0] = prevprev_sv[j];
sampler_views[1] = prev_sv[j];
sampler_views[2] = cur_sv[j];
sampler_views[3] = next_sv[j];
filter->pipe->set_sampler_views(filter->pipe, PIPE_SHADER_FRAGMENT, 0, 4, sampler_views);
/* blit current field */
fb_state.cbufs[0] = blit_surf;
filter->pipe->bind_fs_state(filter->pipe, field ? filter->fs_copy_bottom : filter->fs_copy_top);
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
filter->pipe->set_viewport_states(filter->pipe, 0, 1, &viewport);
util_draw_arrays(filter->pipe, PIPE_PRIM_QUADS, 0, 4);
/* blit or interpolate other field */
fb_state.cbufs[0] = dst_surf;
filter->pipe->set_framebuffer_state(filter->pipe, &fb_state);
if (j > 0 && filter->skip_chroma) {
util_draw_arrays(filter->pipe, PIPE_PRIM_QUADS, 0, 4);
} else {
filter->pipe->bind_fs_state(filter->pipe, field ? filter->fs_deint_top : filter->fs_deint_bottom);
util_draw_arrays(filter->pipe, PIPE_PRIM_QUADS, 0, 4);
}
}
}
