/*
* the interface, not static
*/
int execute_filter(Filter * filter) {
//test whether this filter_tree is passed
bool filter_result = filter->cmd(filter);
if (filter_result) {
if (filter->passed == 0)
return true;//if no passed return true
bool execute_result = execute_filter(filter->passed);
if (execute_result)
return true;
}
if (filter->failed == 0)
return false;
return execute_filter(filter->failed);
}
void vegaColorMatrix(VGImage dst, VGImage src,
const VGfloat * matrix)
{
struct vg_context *ctx = vg_current_context();
struct vg_image *d, *s;
struct filter_info info;
if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return;
}
if (!matrix || !is_aligned(matrix)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
d = handle_to_image(dst);
s = handle_to_image(src);
if (vg_image_overlaps(d, s)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
info.dst = d;
info.src = s;
info.setup_shader = &setup_color_matrix;
info.user_data = NULL;
info.const_buffer = matrix;
info.const_buffer_len = 20 * sizeof(VGfloat);
info.tiling_mode = VG_TILE_PAD;
info.extra_texture_view = NULL;
execute_filter(ctx, &info);
}
int filter_uri(UriUriA **uri, int level)
{
char *url;
if (!option_values.exec_filter)
return 0;
if (!uri)
return -1;
if ((url = uri2string(*uri)) == NULL)
return -1;
uri_free(*uri);
*uri = NULL;
if (execute_filter(option_values.exec_filter, &url, level)) {
string_free(url);
return -1;
}
*uri = create_absolute_uri(NULL, url);
string_free(url);
if (!*uri)
return -1;
return 0;
}
void vegaLookup(VGImage dst, VGImage src,
const VGubyte * redLUT,
const VGubyte * greenLUT,
const VGubyte * blueLUT,
const VGubyte * alphaLUT,
VGboolean outputLinear,
VGboolean outputPremultiplied)
{
struct vg_context *ctx = vg_current_context();
struct vg_image *d, *s;
VGuint color_data[256];
VGint i;
struct pipe_sampler_view *lut_texture_view;
VGfloat buffer[4];
struct filter_info info;
if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return;
}
if (!redLUT || !greenLUT || !blueLUT || !alphaLUT) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
d = handle_to_image(dst);
s = handle_to_image(src);
if (vg_image_overlaps(d, s)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
for (i = 0; i < 256; ++i) {
color_data[i] = blueLUT[i] << 24 | greenLUT[i] << 16 |
redLUT[i] << 8 | alphaLUT[i];
}
lut_texture_view = create_texture_1d_view(ctx, color_data, 255);
buffer[0] = 0.f;
buffer[1] = 0.f;
buffer[2] = 1.f;
buffer[3] = 1.f;
info.dst = d;
info.src = s;
info.setup_shader = &setup_lookup;
info.user_data = NULL;
info.const_buffer = buffer;
info.const_buffer_len = 4 * sizeof(VGfloat);
info.tiling_mode = VG_TILE_PAD;
info.extra_texture_view = lut_texture_view;
execute_filter(ctx, &info);
pipe_sampler_view_reference(&lut_texture_view, NULL);
}
bool execute_filter_tree(FTSENT * ent) {
#ifdef DEBUG
fprintf(stderr, "file level: %d\n", ent->fts_level);
#endif
switch(options.symbol_handle) {
case S_L:
stat(ent->fts_path, &status);
break;
case S_P:
lstat(ent->fts_path, &status);
break;
case S_H:
if (ent->fts_level == 0) {
stat(ent->fts_path, &status);
} else {
lstat(ent->fts_path, &status);
}
break;
}
cur_ent = ent;
bool passed = execute_filter(filter_tree.passed);
return passed;
}
static bool not_filter_adapter(Filter * filter) {
Filter * inner_filter = (Filter *) filter->info;
return !execute_filter(inner_filter);
}
void vegaLookupSingle(VGImage dst, VGImage src,
const VGuint * lookupTable,
VGImageChannel sourceChannel,
VGboolean outputLinear,
VGboolean outputPremultiplied)
{
struct vg_context *ctx = vg_current_context();
struct vg_image *d, *s;
struct pipe_sampler_view *lut_texture_view;
VGfloat buffer[4];
struct filter_info info;
VGuint color_data[256];
VGint i;
if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return;
}
if (!lookupTable || !is_aligned(lookupTable)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
if (sourceChannel != VG_RED && sourceChannel != VG_GREEN &&
sourceChannel != VG_BLUE && sourceChannel != VG_ALPHA) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
d = handle_to_image(dst);
s = handle_to_image(src);
if (vg_image_overlaps(d, s)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
vg_validate_state(ctx);
for (i = 0; i < 256; ++i) {
VGuint rgba = lookupTable[i];
VGubyte blue, green, red, alpha;
red = (rgba & 0xff000000)>>24;
green = (rgba & 0x00ff0000)>>16;
blue = (rgba & 0x0000ff00)>> 8;
alpha = (rgba & 0x000000ff)>> 0;
color_data[i] = blue << 24 | green << 16 |
red << 8 | alpha;
}
lut_texture_view = create_texture_1d_view(ctx, color_data, 256);
buffer[0] = 0.f;
buffer[1] = 0.f;
buffer[2] = 1.f;
buffer[3] = 1.f;
info.dst = d;
info.src = s;
info.setup_shader = &setup_lookup_single;
info.user_data = (void*)sourceChannel;
info.const_buffer = buffer;
info.const_buffer_len = 4 * sizeof(VGfloat);
info.tiling_mode = VG_TILE_PAD;
info.extra_texture_view = lut_texture_view;
execute_filter(ctx, &info);
pipe_sampler_view_reference(&lut_texture_view, NULL);
}
void vegaGaussianBlur(VGImage dst, VGImage src,
VGfloat stdDeviationX,
VGfloat stdDeviationY,
VGTilingMode tilingMode)
{
struct vg_context *ctx = vg_current_context();
struct vg_image *d, *s;
VGfloat *buffer, *kernel;
VGint kernel_width, kernel_height, kernel_size;
VGint buffer_len;
VGint idx, i, j;
struct filter_info info;
if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return;
}
if (stdDeviationX <= 0 || stdDeviationY <= 0) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
if (tilingMode < VG_TILE_FILL ||
tilingMode > VG_TILE_REFLECT) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
d = handle_to_image(dst);
s = handle_to_image(src);
if (vg_image_overlaps(d, s)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
kernel_width = compute_kernel_size(stdDeviationX);
kernel_height = compute_kernel_size(stdDeviationY);
kernel_size = kernel_width * kernel_height;
kernel = malloc(sizeof(VGfloat)*kernel_size);
compute_gaussian_kernel(kernel, kernel_width, kernel_height,
stdDeviationX, stdDeviationY);
buffer_len = 8 + 2 * 4 * kernel_size;
buffer = malloc(buffer_len * sizeof(VGfloat));
buffer[0] = 0.f;
buffer[1] = 1.f;
buffer[2] = 2.f; /*unused*/
buffer[3] = 4.f; /*unused*/
buffer[4] = kernel_width * kernel_height;
buffer[5] = 1.f;/*scale*/
buffer[6] = 0.f;/*bias*/
buffer[7] = 0.f;
idx = 8;
for (j = 0; j < kernel_height; ++j) {
for (i = 0; i < kernel_width; ++i) {
VGint index = j * kernel_width + i;
VGfloat x, y;
x = texture_offset(s->width, kernel_width, i, kernel_width/2);
y = texture_offset(s->height, kernel_height, j, kernel_height/2);
buffer[idx + index*4 + 0] = x;
buffer[idx + index*4 + 1] = y;
buffer[idx + index*4 + 2] = 0.f;
buffer[idx + index*4 + 3] = 0.f;
}
}
idx += kernel_size * 4;
for (j = 0; j < kernel_height; ++j) {
for (i = 0; i < kernel_width; ++i) {
/* transpose the kernel */
VGint index = j * kernel_width + i;
VGint kindex = (kernel_width - i - 1) * kernel_height + (kernel_height - j - 1);
buffer[idx + index*4 + 0] = kernel[kindex];
buffer[idx + index*4 + 1] = kernel[kindex];
buffer[idx + index*4 + 2] = kernel[kindex];
buffer[idx + index*4 + 3] = kernel[kindex];
}
}
info.dst = d;
info.src = s;
info.setup_shader = &setup_convolution;
info.user_data = (void*)(long)(buffer_len/4);
info.const_buffer = buffer;
info.const_buffer_len = buffer_len * sizeof(VGfloat);
info.tiling_mode = tilingMode;
info.extra_texture_view = NULL;
execute_filter(ctx, &info);
free(buffer);
free(kernel);
}
void vegaConvolve(VGImage dst, VGImage src,
VGint kernelWidth, VGint kernelHeight,
VGint shiftX, VGint shiftY,
const VGshort * kernel,
VGfloat scale,
VGfloat bias,
VGTilingMode tilingMode)
{
struct vg_context *ctx = vg_current_context();
VGfloat *buffer;
VGint buffer_len;
VGint i, j;
VGint idx = 0;
struct vg_image *d, *s;
VGint kernel_size = kernelWidth * kernelHeight;
struct filter_info info;
const VGint max_kernel_size = vegaGeti(VG_MAX_KERNEL_SIZE);
if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return;
}
if (kernelWidth <= 0 || kernelHeight <= 0 ||
kernelWidth > max_kernel_size || kernelHeight > max_kernel_size) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
if (!kernel || !is_aligned_to(kernel, 2)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
if (tilingMode < VG_TILE_FILL ||
tilingMode > VG_TILE_REFLECT) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
d = handle_to_image(dst);
s = handle_to_image(src);
if (vg_image_overlaps(d, s)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
vg_validate_state(ctx);
buffer_len = 8 + 2 * 4 * kernel_size;
buffer = malloc(buffer_len * sizeof(VGfloat));
buffer[0] = 0.f;
buffer[1] = 1.f;
buffer[2] = 2.f; /*unused*/
buffer[3] = 4.f; /*unused*/
buffer[4] = kernelWidth * kernelHeight;
buffer[5] = scale;
buffer[6] = bias;
buffer[7] = 0.f;
idx = 8;
for (j = 0; j < kernelHeight; ++j) {
for (i = 0; i < kernelWidth; ++i) {
VGint index = j * kernelWidth + i;
VGfloat x, y;
x = texture_offset(s->width, kernelWidth, i, shiftX);
y = texture_offset(s->height, kernelHeight, j, shiftY);
buffer[idx + index*4 + 0] = x;
buffer[idx + index*4 + 1] = y;
buffer[idx + index*4 + 2] = 0.f;
buffer[idx + index*4 + 3] = 0.f;
}
}
idx += kernel_size * 4;
for (j = 0; j < kernelHeight; ++j) {
for (i = 0; i < kernelWidth; ++i) {
/* transpose the kernel */
VGint index = j * kernelWidth + i;
VGint kindex = (kernelWidth - i - 1) * kernelHeight + (kernelHeight - j - 1);
buffer[idx + index*4 + 0] = kernel[kindex];
buffer[idx + index*4 + 1] = kernel[kindex];
buffer[idx + index*4 + 2] = kernel[kindex];
buffer[idx + index*4 + 3] = kernel[kindex];
}
}
info.dst = d;
info.src = s;
info.setup_shader = &setup_convolution;
info.user_data = (void*)(long)(buffer_len/4);
info.const_buffer = buffer;
info.const_buffer_len = buffer_len * sizeof(VGfloat);
info.tiling_mode = tilingMode;
info.extra_texture_view = NULL;
execute_filter(ctx, &info);
free(buffer);
}