static bool
init_shaders(struct vl_compositor *c)
{
assert(c);
create_vert_shader(c);
create_frag_shader(c);
return true;
}
void
piglit_init(int argc, char **argv)
{
int i = 1;
if (i < argc && strcmp(argv[i], "rect") == 0) {
TexTarget = GL_TEXTURE_RECTANGLE;
i++;
}
if (i < argc) {
ErrorScale = atof(argv[i]);
}
piglit_require_extension("GL_EXT_framebuffer_object");
piglit_require_fragment_shader();
if (TexTarget == GL_TEXTURE_RECTANGLE) {
piglit_require_extension("GL_ARB_texture_rectangle");
}
create_fbo();
if (ErrorScale == 0.0) {
/* A 1-bit error/difference in Z values results in a delta of 64 in
* pixel intensity (where pixels are in [0,255]).
*/
ErrorScale = ((double) (1ull << Zbits)) * 64.0 / 255.0;
}
create_frag_shader();
if (!piglit_automatic) {
printf("GL_RENDERER = %s\n", (char *) glGetString(GL_RENDERER));
printf("Left: Shader showing difference pixels (black=good, red=error)\n");
printf("Middle: Depth buffer of FBO\n");
printf("Right: Quad textured with depth values\n");
printf("Z bits = %d\n", Zbits);
printf("ErrorScale = %f\n", ErrorScale);
printf("Texture target: %s\n",
TexTarget == GL_TEXTURE_RECTANGLE ? "RECTANGLE" : "2D" );
}
}
static bool
init_shaders(struct vl_zscan *zscan)
{
assert(zscan);
zscan->vs = create_vert_shader(zscan);
if (!zscan->vs)
goto error_vs;
zscan->fs = create_frag_shader(zscan);
if (!zscan->fs)
goto error_fs;
return true;
error_fs:
zscan->pipe->delete_vs_state(zscan->pipe, zscan->vs);
error_vs:
return false;
}
bool
vl_matrix_filter_init(struct vl_matrix_filter *filter, struct pipe_context *pipe,
unsigned video_width, unsigned video_height,
unsigned matrix_width, unsigned matrix_height,
const float *matrix_values)
{
struct pipe_rasterizer_state rs_state;
struct pipe_blend_state blend;
struct pipe_sampler_state sampler;
struct pipe_vertex_element ve;
struct vertex2f *offsets, v, sizes;
unsigned i, num_offsets = matrix_width * matrix_height;
assert(filter && pipe);
assert(video_width && video_height);
assert(matrix_width && matrix_height);
memset(filter, 0, sizeof(*filter));
filter->pipe = pipe;
memset(&rs_state, 0, sizeof(rs_state));
rs_state.half_pixel_center = true;
rs_state.bottom_edge_rule = true;
rs_state.depth_clip_near = 1;
rs_state.depth_clip_far = 1;
filter->rs_state = pipe->create_rasterizer_state(pipe, &rs_state);
if (!filter->rs_state)
goto error_rs_state;
memset(&blend, 0, sizeof blend);
blend.rt[0].rgb_func = PIPE_BLEND_ADD;
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
blend.rt[0].alpha_func = PIPE_BLEND_ADD;
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
blend.logicop_func = PIPE_LOGICOP_CLEAR;
blend.rt[0].colormask = PIPE_MASK_RGBA;
filter->blend = pipe->create_blend_state(pipe, &blend);
if (!filter->blend)
goto error_blend;
memset(&sampler, 0, sizeof(sampler));
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
sampler.compare_func = PIPE_FUNC_ALWAYS;
sampler.normalized_coords = 1;
filter->sampler = pipe->create_sampler_state(pipe, &sampler);
if (!filter->sampler)
goto error_sampler;
filter->quad = vl_vb_upload_quads(pipe);
if(!filter->quad.buffer.resource)
goto error_quad;
memset(&ve, 0, sizeof(ve));
ve.src_offset = 0;
ve.instance_divisor = 0;
ve.vertex_buffer_index = 0;
ve.src_format = PIPE_FORMAT_R32G32_FLOAT;
filter->ves = pipe->create_vertex_elements_state(pipe, 1, &ve);
if (!filter->ves)
goto error_ves;
offsets = MALLOC(sizeof(struct vertex2f) * num_offsets);
if (!offsets)
goto error_offsets;
sizes.x = (float)(matrix_width - 1) / 2.0f;
sizes.y = (float)(matrix_height - 1) / 2.0f;
for (v.x = -sizes.x, i = 0; v.x <= sizes.x; v.x += 1.0f)
for (v.y = -sizes.y; v.y <= sizes.y; v.y += 1.0f)
offsets[i++] = v;
for (i = 0; i < num_offsets; ++i) {
offsets[i].x /= video_width;
offsets[i].y /= video_height;
}
filter->vs = create_vert_shader(filter);
if (!filter->vs)
goto error_vs;
filter->fs = create_frag_shader(filter, num_offsets, offsets, matrix_values);
if (!filter->fs)
goto error_fs;
FREE(offsets);
return true;
error_fs:
pipe->delete_vs_state(pipe, filter->vs);
error_vs:
FREE(offsets);
error_offsets:
pipe->delete_vertex_elements_state(pipe, filter->ves);
error_ves:
pipe_resource_reference(&filter->quad.buffer.resource, NULL);
error_quad:
pipe->delete_sampler_state(pipe, filter->sampler);
error_sampler:
pipe->delete_blend_state(pipe, filter->blend);
error_blend:
pipe->delete_rasterizer_state(pipe, filter->rs_state);
error_rs_state:
return false;
}
bool
vl_median_filter_init(struct vl_median_filter *filter, struct pipe_context *pipe,
unsigned width, unsigned height, unsigned size,
enum vl_median_filter_shape shape)
{
struct pipe_rasterizer_state rs_state;
struct pipe_blend_state blend;
struct pipe_sampler_state sampler;
struct vertex2f *offsets = NULL;
struct pipe_vertex_element ve;
unsigned i, num_offsets = 0;
assert(filter && pipe);
assert(width && height);
assert(size > 1 && size < 20);
memset(filter, 0, sizeof(*filter));
filter->pipe = pipe;
memset(&rs_state, 0, sizeof(rs_state));
rs_state.half_pixel_center = true;
rs_state.bottom_edge_rule = true;
rs_state.depth_clip_near = 1;
rs_state.depth_clip_far = 1;
filter->rs_state = pipe->create_rasterizer_state(pipe, &rs_state);
if (!filter->rs_state)
goto error_rs_state;
memset(&blend, 0, sizeof blend);
blend.rt[0].rgb_func = PIPE_BLEND_ADD;
blend.rt[0].rgb_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rt[0].rgb_dst_factor = PIPE_BLENDFACTOR_ONE;
blend.rt[0].alpha_func = PIPE_BLEND_ADD;
blend.rt[0].alpha_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rt[0].alpha_dst_factor = PIPE_BLENDFACTOR_ONE;
blend.logicop_func = PIPE_LOGICOP_CLEAR;
blend.rt[0].colormask = PIPE_MASK_RGBA;
filter->blend = pipe->create_blend_state(pipe, &blend);
if (!filter->blend)
goto error_blend;
memset(&sampler, 0, sizeof(sampler));
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.min_img_filter = PIPE_TEX_FILTER_NEAREST;
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
sampler.mag_img_filter = PIPE_TEX_FILTER_NEAREST;
sampler.compare_mode = PIPE_TEX_COMPARE_NONE;
sampler.compare_func = PIPE_FUNC_ALWAYS;
sampler.normalized_coords = 1;
filter->sampler = pipe->create_sampler_state(pipe, &sampler);
if (!filter->sampler)
goto error_sampler;
filter->quad = vl_vb_upload_quads(pipe);
if(!filter->quad.buffer.resource)
goto error_quad;
memset(&ve, 0, sizeof(ve));
ve.src_offset = 0;
ve.instance_divisor = 0;
ve.vertex_buffer_index = 0;
ve.src_format = PIPE_FORMAT_R32G32_FLOAT;
filter->ves = pipe->create_vertex_elements_state(pipe, 1, &ve);
if (!filter->ves)
goto error_ves;
generate_offsets(shape, size, &offsets, &num_offsets);
if (!offsets)
goto error_offsets;
for (i = 0; i < num_offsets; ++i) {
offsets[i].x /= width;
offsets[i].y /= height;
}
filter->vs = create_vert_shader(filter);
if (!filter->vs)
goto error_vs;
filter->fs = create_frag_shader(filter, offsets, num_offsets);
if (!filter->fs)
goto error_fs;
FREE(offsets);
return true;
error_fs:
pipe->delete_vs_state(pipe, filter->vs);
error_vs:
FREE(offsets);
error_offsets:
pipe->delete_vertex_elements_state(pipe, filter->ves);
error_ves:
pipe_resource_reference(&filter->quad.buffer.resource, NULL);
error_quad:
pipe->delete_sampler_state(pipe, filter->sampler);
error_sampler:
pipe->delete_blend_state(pipe, filter->blend);
error_blend:
pipe->delete_rasterizer_state(pipe, filter->rs_state);
error_rs_state:
return false;
}
