Skip to content

Commit

Permalink
All filter flags are now calculated in the filter code.
Browse files Browse the repository at this point in the history
  • Loading branch information
@schani
schani committed Mar 21, 2008
1 parent a294f96 commit 70ff7a1
Show file tree
Hide file tree
Showing 8 changed files with 194 additions and 159 deletions.
2 changes: 2 additions & 0 deletions TODO
View file
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@
** General

** GIMP Plug-In
ident filter creates one pixel border around image in preview

** Language
figure out how to do calling between pixel/non-pixel filters (eg mugl in composer)
Expand All @@ -23,6 +24,7 @@ why is gaussian so slow in final rendering?
** Native filters

** Compiler
calculate R in the filter code

** Filters

Expand Down
141 changes: 106 additions & 35 deletions compiler.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2006,10 +2006,8 @@ new_binding_values (int kind, gpointer key, binding_values_t *next, int num_valu
}

static binding_values_t*
gen_binding_values_from_userval_infos (userval_info_t *info)
gen_binding_values_from_userval_infos (userval_info_t *info, binding_values_t *bvs)
{
binding_values_t *bvs = NULL;

while (info != NULL)
{
userval_representation_t *rep = lookup_userval_representation(info->type);
Expand Down Expand Up @@ -2050,59 +2048,132 @@ get_internal_value (filter_t *filter, const char *name, gboolean allow_bindings)
}
}

static void
emit_mul_with_internal (filter_t *filter, value_t *lhs, value_t *value, const char *internal_name)
static binding_values_t*
make_internal_binding_from_rhs (internal_t *internal, rhs_t *rhs, binding_values_t *bvs)
{
emit_assign(lhs,
make_op_rhs(OP_MUL, make_value_primary(value),
make_value_primary(get_internal_value(filter, internal_name, FALSE))));
bvs = new_binding_values(BINDING_INTERNAL, internal, bvs, 1, TYPE_INT);
emit_assign(bvs->values[0], rhs);
return bvs;
}

static binding_values_t*
make_pixel_scaled_internal_binding (filter_t *filter, const char *internal_name, value_t *internal_value,
const char *factor_internal_name, binding_values_t *bvs)
make_pixel_xy_binding (filter_t *filter, internal_t *internal, const char *size_internal_name, binding_values_t *bvs)
{
internal_t *internal;
compvar_t *size_minus_one = make_temporary(TYPE_INT);

internal = lookup_internal(filter->v.mathmap.internals, internal_name, TRUE);
g_assert(internal != NULL);
bvs = new_binding_values(BINDING_INTERNAL, internal, bvs, 1, TYPE_INT);
if (filter_flags(filter) & IMAGE_FLAG_UNIT)
emit_assign(bvs->values[0], make_value_rhs(internal_value));
else
emit_mul_with_internal(filter, bvs->values[0], internal_value, factor_internal_name);
emit_assign(make_lhs(size_minus_one),
make_op_rhs(OP_SUB,
make_value_primary(get_internal_value(filter, size_internal_name, TRUE)),
make_int_const_primary(1)));
return make_internal_binding_from_rhs(internal,
make_op_rhs(OP_DIV,
make_compvar_primary(size_minus_one),
make_int_const_primary(2)),
bvs);
}

return bvs;
static value_t*
emit_pixel_wh_max (filter_t *filter)
{
compvar_t *max = make_temporary(TYPE_INT);

emit_assign(make_lhs(max),
make_op_rhs(OP_MAX,
make_value_primary(get_internal_value(filter, "__canvasPixelW", FALSE)),
make_value_primary(get_internal_value(filter, "__canvasPixelH", FALSE))));
return current_value(max);
}

static binding_values_t*
gen_binding_values_for_xy (filter_t *filter, value_t *x, value_t *y, binding_values_t *bvs)
gen_binding_values_for_limits (filter_t *filter, binding_values_t *bvs)
{
bvs = make_pixel_scaled_internal_binding(filter, "x", x, "__canvasPixelX", bvs);
bvs = make_pixel_scaled_internal_binding(filter, "y", y, "__canvasPixelY", bvs);
internal_t *w_internal = lookup_internal(filter->v.mathmap.internals, "W", TRUE);
internal_t *h_internal = lookup_internal(filter->v.mathmap.internals, "H", TRUE);
internal_t *x_internal = lookup_internal(filter->v.mathmap.internals, "X", TRUE);
internal_t *y_internal = lookup_internal(filter->v.mathmap.internals, "Y", TRUE);

g_assert(w_internal != NULL && h_internal != NULL && x_internal != NULL && y_internal != NULL);

switch (filter_flags(filter) & (IMAGE_FLAG_UNIT | IMAGE_FLAG_SQUARE))
{
case 0 :
bvs = make_internal_binding_from_rhs(w_internal,
make_value_rhs(get_internal_value(filter, "__canvasPixelW", FALSE)),
bvs);
bvs = make_internal_binding_from_rhs(h_internal,
make_value_rhs(get_internal_value(filter, "__canvasPixelH", FALSE)),
bvs);
bvs = make_pixel_xy_binding(filter, x_internal, "__canvasPixelW", bvs);
bvs = make_pixel_xy_binding(filter, y_internal, "__canvasPixelH", bvs);
break;

case IMAGE_FLAG_UNIT :
bvs = make_internal_binding_from_rhs(w_internal, make_int_const_rhs(2), bvs);
bvs = make_internal_binding_from_rhs(h_internal, make_int_const_rhs(2), bvs);
bvs = make_internal_binding_from_rhs(x_internal, make_int_const_rhs(1), bvs);
bvs = make_internal_binding_from_rhs(y_internal, make_int_const_rhs(1), bvs);
break;

case IMAGE_FLAG_UNIT | IMAGE_FLAG_SQUARE :
{
value_t *pixel_wh_max = emit_pixel_wh_max(filter);
value_t *x_value, *y_value;

bvs = make_internal_binding_from_rhs(x_internal,
make_op_rhs(OP_DIV,
make_value_primary(get_internal_value(filter, "__canvasPixelW", FALSE)),
make_value_primary(pixel_wh_max)),
bvs);
x_value = bvs->values[0];
bvs = make_internal_binding_from_rhs(y_internal,
make_op_rhs(OP_DIV,
make_value_primary(get_internal_value(filter, "__canvasPixelH", FALSE)),
make_value_primary(pixel_wh_max)),
bvs);
y_value = bvs->values[0];
bvs = make_internal_binding_from_rhs(w_internal,
make_op_rhs(OP_MUL,
make_value_primary(x_value),
make_int_const_primary(2)),
bvs);
bvs = make_internal_binding_from_rhs(h_internal,
make_op_rhs(OP_MUL,
make_value_primary(y_value),
make_int_const_primary(2)),
bvs);
}
break;

default :
g_assert_not_reached();
}

return bvs;
}

static binding_values_t*
gen_binding_values_for_limits (filter_t *filter, binding_values_t *bvs)
gen_binding_values_for_xy (filter_t *filter, value_t *x, value_t *y, binding_values_t *bvs)
{
bvs = make_pixel_scaled_internal_binding(filter, "X", get_internal_value(filter, "X", FALSE), "__canvasPixelX", bvs);
bvs = make_pixel_scaled_internal_binding(filter, "Y", get_internal_value(filter, "Y", FALSE), "__canvasPixelY", bvs);

bvs = make_pixel_scaled_internal_binding(filter, "W", get_internal_value(filter, "W", FALSE), "__canvasPixelX", bvs);
bvs = make_pixel_scaled_internal_binding(filter, "H", get_internal_value(filter, "H", FALSE), "__canvasPixelY", bvs);
bvs = make_internal_binding_from_rhs(lookup_internal(filter->v.mathmap.internals, "x", TRUE),
make_op_rhs(OP_MUL,
make_value_primary(get_internal_value(filter, "x", FALSE)),
make_value_primary(get_internal_value(filter, "X", TRUE))),
bvs);
bvs = make_internal_binding_from_rhs(lookup_internal(filter->v.mathmap.internals, "y", TRUE),
make_op_rhs(OP_MUL,
make_value_primary(get_internal_value(filter, "y", FALSE)),
make_value_primary(get_internal_value(filter, "Y", TRUE))),
bvs);

return bvs;
}

static binding_values_t*
gen_binding_values_from_filter_args (filter_t *filter, primary_t *args)
gen_binding_values_from_filter_args (filter_t *filter, primary_t *args, binding_values_t *bvs)
{
int num_args = num_filter_args(filter);
userval_info_t *info;
int i;
binding_values_t *bvs = NULL;
internal_t *internal;
compvar_t *x_tmp, *y_tmp;

Expand Down Expand Up @@ -2189,26 +2260,26 @@ gen_filter_code (filter_t *filter, compvar_t *tuple, primary_t *args, rhs_t **tu
statement_t *stmt;
compvar_t *result[filter->v.mathmap.decl->v.filter.body->result.length];
rhs_t *rhs;
binding_values_t *binding_values_save = binding_values;

compiler_reset_variables(filter->v.mathmap.variables);

inlining_history = push_inlined_filter(filter, history);

first_stmt = NULL;
emit_loc = &first_stmt;
binding_values = gen_binding_values_for_limits(filter, NULL);
if (args != NULL)
binding_values = gen_binding_values_from_filter_args(filter, args);
binding_values = gen_binding_values_from_filter_args(filter, args, binding_values);
else
{
binding_values = gen_binding_values_from_userval_infos(filter->userval_infos);
binding_values = gen_binding_values_from_userval_infos(filter->userval_infos, binding_values);
binding_values = gen_binding_values_for_xy(filter,
get_internal_value(filter, "x", FALSE),
get_internal_value(filter, "y", FALSE),
binding_values);
}

binding_values = gen_binding_values_for_limits(filter, binding_values);

if (does_filter_use_ra(filter))
binding_values = gen_ra_binding_values(filter, binding_values);

Expand All @@ -2227,7 +2298,7 @@ gen_filter_code (filter_t *filter, compvar_t *tuple, primary_t *args, rhs_t **tu

first_stmt = first_stmt_save;
emit_loc = NULL;
binding_values = NULL;
binding_values = binding_values_save;

inlining_history = history_save;

Expand Down
16 changes: 8 additions & 8 deletions mathmap.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1930,7 +1930,7 @@ recalculate_preview (void)
guchar *p_ul, *p;
gint check, check_0, check_1;
guchar *buf = (guchar*)malloc(4 * preview_width * preview_height);
float old_scale_x, old_scale_y;
int old_render_width, old_render_height;

assert(buf != 0);

Expand All @@ -1954,11 +1954,11 @@ recalculate_preview (void)
*/
disable_debugging(invocation);

old_scale_x = invocation->scale_x;
old_scale_y = invocation->scale_y;
old_render_width = invocation->render_width;
old_render_height = invocation->render_height;

invocation->scale_x *= (float)sel_width / (float)preview_width;
invocation->scale_y *= (float)sel_height / (float)preview_height;
invocation->render_width = preview_width;
invocation->render_height = preview_height;

if (previewing) {
for_each_input_drawable(build_fast_image_source);
Expand All @@ -1967,8 +1967,8 @@ recalculate_preview (void)
else
call_invocation_parallel_and_join(invocation, 0, 0, preview_width, preview_height, buf, NUM_FINAL_RENDER_CPUS);

invocation->scale_x = old_scale_x;
invocation->scale_y = old_scale_y;
invocation->render_width = old_render_width;
invocation->render_height = old_render_height;

p = buf;
p_ul = wint.wimage;
Expand All @@ -1981,7 +1981,7 @@ recalculate_preview (void)
} else {
check_0 = CHECK_LIGHT;
check_1 = CHECK_DARK;
}
}

for (x = 0; x < preview_width; x++)
{
Expand Down
11 changes: 3 additions & 8 deletions mathmap.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -159,13 +159,11 @@ typedef struct _mathmap_invocation_t

/* These are in pixel coordinates: */
int img_width, img_height;
int render_width, render_height;

/* These are in virtual coordinates: */
float middle_x, middle_y;
float image_R, image_X, image_Y, image_W, image_H;

/* The factors for converting between the two: */
float scale_x, scale_y;
float image_R; /* FIXME: remove and calculate in
filter code */

float current_x, current_y, current_r, current_a, current_t;

Expand Down Expand Up @@ -213,9 +211,6 @@ typedef struct
#define M_PI 3.14159265358979323846
#endif

void calc_scale_factors (unsigned int flags, int pixel_width, int pixel_height, float *scale_x, float *scale_y);
void calc_middle_values (int img_width, int img_height, float scale_x, float scale_y, float *middle_x, float *middle_y);

#ifdef MATHMAP_CMDLINE
int cmdline_main (int argc, char *argv[]);
color_t cmdline_mathmap_get_pixel (mathmap_invocation_t *invocation, input_drawable_t *drawable, int frame, int x, int y);
Expand Down
Loading

0 comments on commit 70ff7a1

Please sign in to comment.