/* * new_template.c * * MathMap * * Copyright (C) 2002-2007 Mark Probst * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* * $g -> GIMP ? 1 : 0 * $m -> mathmap code * $p -> USER_CURVE_POINTS * $q -> USER_GRADIENT_POINTS * $xy_decls -> declarations for xy-constant variables * $xy_code -> code for xy-constant variables * $x_decls -> declarations for x-constant variables * $x_code -> code for x-constant variables * $y_decls -> declarations for y-constant variables * $y_code -> code for y-constant variables * $opmacros_h -> full name of opmacros.h file * $max_debug_tuples -> MAX_DEBUG_TUPLES */ #include #include #include #if !1 #define OPENSTEP #endif #define IN_COMPILED_CODE #include "/usr/share/gimp/2.0/mathmap/opmacros.h" #include "/usr/share/gimp/2.0/mathmap/pools.h" #ifndef MIN #define MIN(a,b) (((a)<(b))?(a):(b)) #endif #ifndef MAX #define MAX(a,b) (((a)<(b))?(b):(a)) #endif #define M_PI 3.14159265358979323846 /* pi */ #define EDGE_BEHAVIOUR_COLOR 1 #define EDGE_BEHAVIOUR_WRAP 2 #define EDGE_BEHAVIOUR_REFLECT 3 #define EDGE_BEHAVIOUR_ROTATE 4 #define USERVAL_IMAGE 7 #define USER_CURVE_POINTS 1024 #define USER_GRADIENT_POINTS 1024 #define MAX_DEBUG_TUPLES 8 typedef struct { int number; int length; float data[]; } tuple_t; typedef unsigned int color_t; #define MAKE_RGBA_COLOR(r,g,b,a) ((((color_t)(r))<<24)|(((color_t)(g))<<16)|(((color_t)(b))<<8)|((color_t)(a))) #define RED(c) ((c)>>24) #define GREEN(c) (((c)>>16)&0xff) #define BLUE(c) (((c)>>8)&0xff) #define ALPHA(c) ((c)&0xff) #define IMAGE_DRAWABLE 1 #define IMAGE_CLOSURE 2 #define IMAGE_FLOATMAP 3 struct _mathmap_invocation_t; struct _userval_t; struct _image_t; typedef float* (*filter_func_t) (struct _mathmap_invocation_t*, struct _userval_t*, float, float, float, pools_t*); typedef struct { float *values; } curve_t; typedef struct { color_t *values; } gradient_t; typedef struct _userval_t { int type; union { int int_const; float float_const; float bool_const; struct _image_t *image; curve_t *curve; gradient_t *gradient; struct { #if 1 struct { double r, g, b, a; } button_value; #endif color_t value; } color; } v; #ifndef OPENSTEP void *widget; #endif } userval_t; typedef struct _image_t { int type; int pixel_width; int pixel_height; union { void *drawable; struct { filter_func_t func; userval_t args[]; } closure; struct { float ax; float bx; float ay; float by; float *data; } floatmap; } v; } image_t; typedef struct _mathmap_t { void *internals; void *filters; void *current_filter; void *main_filter; unsigned int flags; void *initfunc; void *module_info; void *interpreter_insns; void *interpreter_values; struct _mathmap_t *next; } mathmap_t; typedef struct { float tmp_6_1; float tmp_8_1; image_t * tmp_11_1; float tmp_12_1; image_t * tmp_13_1; float tmp_14_1; float tmp_15_1; float tmp_29_1; float tmp_48_1; float tmp_50_1; float tmp_84_1; float tmp_86_1; float tmp_133_1; float tmp_135_1; int tmp_160_1; float tmp_169_2; float tmp_248_1; float tmp_251_1; } xy_const_vars_t; typedef struct { float tmp_257_1; } y_const_vars_t; struct _mathmap_slice_t; typedef void (*init_frame_func_t) (struct _mathmap_slice_t*); typedef void (*calc_lines_func_t) (struct _mathmap_slice_t*, int, int, unsigned char*); typedef struct { init_frame_func_t init_frame; calc_lines_func_t calc_lines; } mathfuncs_t; typedef struct _mathmap_invocation_t { mathmap_t *mathmap; userval_t *uservals; int antialiasing; int supersampling; int output_bpp; int edge_behaviour_x, edge_behaviour_y; color_t edge_color_x, edge_color_y; int current_frame; int img_width, img_height; int render_width, render_height; float image_R; float current_x, current_y, current_r, current_a, current_t; int row_stride; unsigned char * volatile rows_finished; mathfuncs_t mathfuncs; int do_debug; int num_debug_tuples; tuple_t *debug_tuples[MAX_DEBUG_TUPLES]; int interpreter_ip; color_t interpreter_output_color; } mathmap_invocation_t; typedef struct _mathmap_slice_t { mathmap_invocation_t *invocation; float sampling_offset_x, sampling_offset_y; int region_x, region_y, region_width, region_height; xy_const_vars_t *xy_vars; y_const_vars_t *y_vars; pools_t pools; } mathmap_slice_t; extern color_t get_orig_val_pixel (mathmap_invocation_t *invocation, float x, float y, image_t *image, int frame); extern color_t get_orig_val_intersample_pixel (mathmap_invocation_t *invocation, float x, float y, image_t *image, int frame); extern float* get_floatmap_pixel (mathmap_invocation_t *invocation, image_t *image, float x, float y, float frame); extern image_t* render_image (mathmap_invocation_t *invocation, image_t *image, int width, int height, pools_t *pools); extern float noise (float, float, float); struct _gsl_vector; typedef struct _gsl_vector gsl_vector; struct _gsl_matrix; typedef struct _gsl_matrix gsl_matrix; gsl_matrix * gsl_matrix_alloc (const size_t n1, const size_t n2); void gsl_matrix_free (gsl_matrix * m); void gsl_matrix_set(gsl_matrix * m, const size_t i, const size_t j, const double x); gsl_vector *gsl_vector_alloc (const size_t n); void gsl_vector_free (gsl_vector * v); double gsl_vector_get (const gsl_vector * v, const size_t i); void gsl_vector_set (gsl_vector * v, const size_t i, double x); int gsl_linalg_HH_solve (gsl_matrix * A, const gsl_vector * b, gsl_vector * x); #define GSL_PREC_SINGLE 1 double gsl_sf_ellint_Kcomp (double k, unsigned int mode); double gsl_sf_ellint_Ecomp (double k, unsigned int mode); double gsl_sf_ellint_F (double phi, double k, unsigned int mode); double gsl_sf_ellint_E (double phi, double k, unsigned int mode); double gsl_sf_ellint_P (double phi, double k, double n, unsigned int mode); double gsl_sf_ellint_D (double phi, double k, double n, unsigned int mode); double gsl_sf_ellint_RC (double x, double y, unsigned int mode); double gsl_sf_ellint_RD (double x, double y, double z, unsigned int mode); double gsl_sf_ellint_RF (double x, double y, double z, unsigned int mode); double gsl_sf_ellint_RJ (double x, double y, double z, double p, unsigned int mode); int gsl_sf_elljac_e (double u, double m, double *sn, double *cn, double *dn); complex float cgamma (complex float z); double gsl_sf_beta (double a, double b); extern void save_debug_tuples (mathmap_invocation_t *invocation, int row, int col); #define DECLARE_NATIVE_FILTER(name) extern image_t* name (mathmap_invocation_t*, userval_t*, pools_t*) DECLARE_NATIVE_FILTER(native_filter_gaussian_blur); static float* filter___composer_filter__ (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools); static float* filter_composer_test (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools); static float* filter_desaturate (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools); static float* filter_desaturate (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools); static float* filter_comp_dissolve (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools); static float* filter_mosaic (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools); static void calc_lines (mathmap_slice_t *slice, int first_row, int last_row, unsigned char *q) { mathmap_invocation_t *invocation = slice->invocation; color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); int row, col; float t = invocation->current_t; float R = invocation->image_R; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float sampling_offset_x = slice->sampling_offset_x, sampling_offset_y = slice->sampling_offset_y; int origin_x = slice->region_x, origin_y = slice->region_y; int frame = invocation->current_frame; int output_bpp = invocation->output_bpp; int is_bw = output_bpp == 1 || output_bpp == 2; int need_alpha = output_bpp == 2 || output_bpp == 4; int alpha_index = output_bpp - 1; xy_const_vars_t *xy_vars = slice->xy_vars; pools_t pixel_pools; pools_t *pools; int region_x = slice->region_x; int render_width = invocation->render_width, render_height = invocation->render_height; init_pools(&pixel_pools); first_row = MAX(0, first_row); last_row = MIN(last_row, slice->region_y + slice->region_height); if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; for (row = first_row - slice->region_y; row < last_row - slice->region_y; ++row) { float y = CALC_VIRTUAL_Y(row + slice->region_y, render_height, sampling_offset_y); unsigned char *p = q; pools = &slice->pools; float tmp_258_1; float tmp_16_1; float tmp_19_1; float tmp_58_1; float tmp_93_1; float tmp_143_1; float tmp_154_1; float tmp_159_2; float tmp_159_3; float tmp_165_1; float tmp_173_1; float tmp_206_1; tmp_16_1 = y; tmp_19_1 = MUL(tmp_16_1,xy_vars->tmp_8_1); tmp_58_1 = MUL(tmp_19_1,xy_vars->tmp_50_1); tmp_93_1 = MUL(tmp_58_1,xy_vars->tmp_86_1); tmp_143_1 = MUL(tmp_93_1,xy_vars->tmp_135_1); tmp_154_1 = ADD(tmp_143_1,xy_vars->tmp_135_1); if (xy_vars->tmp_160_1) { tmp_159_3 = 0; } else { tmp_159_2 = MOD(tmp_154_1,xy_vars->tmp_15_1); tmp_159_3 = tmp_159_2; } tmp_165_1 = SUB(tmp_143_1,tmp_159_3); tmp_173_1 = ADD(tmp_165_1,xy_vars->tmp_169_2); tmp_206_1 = MUL(tmp_173_1,xy_vars->tmp_86_1); tmp_258_1 = MUL(tmp_206_1,xy_vars->tmp_251_1); pools = &pixel_pools; for (col = 0; col < slice->region_width; ++col) { y_const_vars_t *y_vars = &slice->y_vars[col]; float x = CALC_VIRTUAL_X(col + region_x, render_width, sampling_offset_x); float *return_tuple; if (invocation->do_debug) invocation->num_debug_tuples = 0; reset_pools(pools); { float tmp_264_1; float tmp_277_1; float tmp_276_1; int tmp_285_1; float tmp_329_1; float tmp_330_1; float tmp_340_1; float tmp_341_1; int tmp_347_1; float tmp_345_2; float tmp_346_2; float tmp_346_3; float tmp_345_3; float tmp_351_1; float tmp_352_1; float tmp_356_2; float tmp_359_1; float tmp_360_1; float * tmp_375_1; float tmp_371_1; float tmp_372_1; float tmp_373_1; float tmp_374_1; float * tmp_311_1; float tmp_307_1; float tmp_308_1; float tmp_309_1; float tmp_310_1; float tmp_282_3; float tmp_281_3; float tmp_280_3; float tmp_279_3; float tmp_226_1; float tmp_228_1; float tmp_225_1; float tmp_230_1; float tmp_224_1; float tmp_113_1; float tmp_115_1; float tmp_112_1; float tmp_117_1; float tmp_111_1; float * tmp_1_1; int tmp_43_1; tmp_264_1 = noise(y_vars->tmp_257_1,tmp_258_1,0); tmp_277_1 = SUB(tmp_264_1,-0.69999998807907104); tmp_276_1 = DIV(tmp_277_1,1.3999999761581421); tmp_285_1 = LEQ(tmp_276_1,xy_vars->tmp_14_1); if (tmp_285_1) { tmp_329_1 = MUL(y_vars->tmp_257_1,xy_vars->tmp_133_1); tmp_330_1 = MUL(tmp_258_1,xy_vars->tmp_135_1); tmp_340_1 = ADD(tmp_329_1,xy_vars->tmp_133_1); tmp_341_1 = ADD(tmp_330_1,xy_vars->tmp_135_1); tmp_347_1 = EQ(xy_vars->tmp_12_1,0); if (tmp_347_1) { tmp_346_3 = 0; tmp_345_3 = 0; } else { tmp_345_2 = MOD(tmp_340_1,xy_vars->tmp_12_1); tmp_346_2 = MOD(tmp_341_1,xy_vars->tmp_12_1); tmp_346_3 = tmp_346_2; tmp_345_3 = tmp_345_2; } tmp_351_1 = SUB(tmp_329_1,tmp_345_3); tmp_352_1 = SUB(tmp_330_1,tmp_346_3); tmp_356_2 = DIV(xy_vars->tmp_12_1,2); tmp_359_1 = ADD(tmp_351_1,tmp_356_2); tmp_360_1 = ADD(tmp_352_1,tmp_356_2); tmp_375_1 = ORIG_VAL(tmp_359_1,tmp_360_1,xy_vars->tmp_11_1,xy_vars->tmp_29_1); tmp_371_1 = TUPLE_NTH(tmp_375_1,0); tmp_372_1 = TUPLE_NTH(tmp_375_1,1); tmp_373_1 = TUPLE_NTH(tmp_375_1,2); tmp_374_1 = TUPLE_NTH(tmp_375_1,3); tmp_282_3 = tmp_374_1; tmp_281_3 = tmp_373_1; tmp_280_3 = tmp_372_1; tmp_279_3 = tmp_371_1; } else { tmp_311_1 = ORIG_VAL(y_vars->tmp_257_1,tmp_258_1,xy_vars->tmp_13_1,xy_vars->tmp_29_1); tmp_307_1 = TUPLE_NTH(tmp_311_1,0); tmp_308_1 = TUPLE_NTH(tmp_311_1,1); tmp_309_1 = TUPLE_NTH(tmp_311_1,2); tmp_310_1 = TUPLE_NTH(tmp_311_1,3); tmp_282_3 = tmp_310_1; tmp_281_3 = tmp_309_1; tmp_280_3 = tmp_308_1; tmp_279_3 = tmp_307_1; } tmp_226_1 = MUL(0.29899999499320984,tmp_279_3); tmp_228_1 = MUL(0.58700001239776611,tmp_280_3); tmp_225_1 = ADD(tmp_226_1,tmp_228_1); tmp_230_1 = MUL(0.11400000005960464,tmp_281_3); tmp_224_1 = ADD(tmp_225_1,tmp_230_1); tmp_113_1 = MUL(0.29899999499320984,tmp_224_1); tmp_115_1 = MUL(0.58700001239776611,tmp_224_1); tmp_112_1 = ADD(tmp_113_1,tmp_115_1); tmp_117_1 = MUL(0.11400000005960464,tmp_224_1); tmp_111_1 = ADD(tmp_112_1,tmp_117_1); tmp_1_1 = ({ float *tuple = ALLOC_TUPLE(4); TUPLE_SET(tuple, 0, tmp_111_1); TUPLE_SET(tuple, 1, tmp_111_1); TUPLE_SET(tuple, 2, tmp_111_1); TUPLE_SET(tuple, 3, tmp_282_3); tuple; }); tmp_43_1 = OUTPUT_TUPLE(tmp_1_1); } if (is_bw) p[0] = (TUPLE_RED(return_tuple) * 0.299 + TUPLE_GREEN(return_tuple) * 0.587 + TUPLE_BLUE(return_tuple) * 0.114) * 255.0; else { p[0] = TUPLE_RED(return_tuple) * 255.0; p[1] = TUPLE_GREEN(return_tuple) * 255.0; p[2] = TUPLE_BLUE(return_tuple) * 255.0; } if (need_alpha) p[alpha_index] = TUPLE_ALPHA(return_tuple) * 255.0; if (invocation->do_debug) save_debug_tuples(invocation, row, col); p += output_bpp; } q += invocation->row_stride; if (!invocation->supersampling) invocation->rows_finished[row] = 1; } free_pools(&pixel_pools); } static void init_frame (mathmap_slice_t *slice) { mathmap_invocation_t *invocation = slice->invocation; color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); float t = invocation->current_t; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float R = invocation->image_R; pools_t *pools = &slice->pools; if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; if (slice->xy_vars != 0) free(slice->xy_vars); slice->xy_vars = (xy_const_vars_t*)malloc(sizeof(xy_const_vars_t)); if (slice->y_vars != 0) free(slice->y_vars); slice->y_vars = (y_const_vars_t*)malloc(sizeof(y_const_vars_t) * slice->region_width); { xy_const_vars_t *xy_vars = slice->xy_vars; { float tmp_3_1; float tmp_4_1; float tmp_2_1; float tmp_45_1; float tmp_46_1; float tmp_44_1; float tmp_81_1; float tmp_82_1; float tmp_80_1; float tmp_130_1; float tmp_131_1; float tmp_129_1; float tmp_242_1; float tmp_244_1; float tmp_246_1; float tmp_249_1; tmp_3_1 = __canvasPixelH; tmp_4_1 = __canvasPixelW; tmp_2_1 = MAX(tmp_4_1,tmp_3_1); xy_vars->tmp_6_1 = DIV(tmp_4_1,tmp_2_1); xy_vars->tmp_8_1 = DIV(tmp_3_1,tmp_2_1); xy_vars->tmp_11_1 = USERVAL_IMAGE_ACCESS(0); xy_vars->tmp_12_1 = USERVAL_FLOAT_ACCESS(1); xy_vars->tmp_13_1 = USERVAL_IMAGE_ACCESS(2); xy_vars->tmp_14_1 = USERVAL_FLOAT_ACCESS(3); xy_vars->tmp_15_1 = USERVAL_FLOAT_ACCESS(4); xy_vars->tmp_29_1 = t; tmp_45_1 = __canvasPixelH; tmp_46_1 = __canvasPixelW; tmp_44_1 = MAX(tmp_46_1,tmp_45_1); xy_vars->tmp_48_1 = DIV(tmp_46_1,tmp_44_1); xy_vars->tmp_50_1 = DIV(tmp_45_1,tmp_44_1); tmp_81_1 = __canvasPixelH; tmp_82_1 = __canvasPixelW; tmp_80_1 = MAX(tmp_82_1,tmp_81_1); xy_vars->tmp_84_1 = DIV(tmp_82_1,tmp_80_1); xy_vars->tmp_86_1 = DIV(tmp_81_1,tmp_80_1); tmp_130_1 = __canvasPixelH; tmp_131_1 = __canvasPixelW; tmp_129_1 = MAX(tmp_131_1,tmp_130_1); xy_vars->tmp_133_1 = DIV(tmp_131_1,tmp_129_1); xy_vars->tmp_135_1 = DIV(tmp_130_1,tmp_129_1); xy_vars->tmp_160_1 = EQ(xy_vars->tmp_15_1,0); xy_vars->tmp_169_2 = DIV(xy_vars->tmp_15_1,2); tmp_242_1 = __canvasPixelW; tmp_244_1 = __canvasPixelH; tmp_246_1 = SUB(tmp_242_1,1); xy_vars->tmp_248_1 = DIV(tmp_246_1,2); tmp_249_1 = SUB(tmp_244_1,1); xy_vars->tmp_251_1 = DIV(tmp_249_1,2); } } { xy_const_vars_t *xy_vars = slice->xy_vars; int col; for (col = 0; col < slice->region_width; ++col) { y_const_vars_t *y_vars = &slice->y_vars[col]; float x = CALC_VIRTUAL_X(col + slice->region_x, invocation->render_width, slice->sampling_offset_x); { float tmp_17_1; float tmp_18_1; float tmp_57_1; float tmp_92_1; float tmp_142_1; float tmp_153_1; float tmp_158_2; float tmp_158_3; float tmp_164_1; float tmp_172_1; float tmp_205_1; tmp_17_1 = x; tmp_18_1 = MUL(tmp_17_1,xy_vars->tmp_6_1); tmp_57_1 = MUL(tmp_18_1,xy_vars->tmp_48_1); tmp_92_1 = MUL(tmp_57_1,xy_vars->tmp_84_1); tmp_142_1 = MUL(tmp_92_1,xy_vars->tmp_133_1); tmp_153_1 = ADD(tmp_142_1,xy_vars->tmp_133_1); if (xy_vars->tmp_160_1) { tmp_158_3 = 0; } else { tmp_158_2 = MOD(tmp_153_1,xy_vars->tmp_15_1); tmp_158_3 = tmp_158_2; } tmp_164_1 = SUB(tmp_142_1,tmp_158_3); tmp_172_1 = ADD(tmp_164_1,xy_vars->tmp_169_2); tmp_205_1 = MUL(tmp_172_1,xy_vars->tmp_84_1); y_vars->tmp_257_1 = MUL(tmp_205_1,xy_vars->tmp_248_1); } } } } mathfuncs_t mathmapinit (mathmap_invocation_t *invocation) { mathfuncs_t funcs; funcs.init_frame = &init_frame; funcs.calc_lines = &calc_lines; return funcs; } #undef ARG #define ARG(i) (arguments[(i)]) static float* filter___composer_filter__ (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools) { color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); int frame = 0; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float R = invocation->image_R; float *return_tuple; #if 1 if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; #else if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel_fast; else get_orig_val_pixel_func = get_orig_val_pixel_fast; #endif float tmp_3_1; float tmp_4_1; float tmp_2_1; float tmp_6_1; float tmp_8_1; image_t * tmp_11_1; float tmp_12_1; image_t * tmp_13_1; float tmp_14_1; float tmp_15_1; float tmp_16_1; float tmp_17_1; float tmp_18_1; float tmp_19_1; float tmp_29_1; float tmp_45_1; float tmp_46_1; float tmp_44_1; float tmp_48_1; float tmp_50_1; float tmp_57_1; float tmp_58_1; float tmp_81_1; float tmp_82_1; float tmp_80_1; float tmp_84_1; float tmp_86_1; float tmp_92_1; float tmp_93_1; float tmp_130_1; float tmp_131_1; float tmp_129_1; float tmp_133_1; float tmp_135_1; float tmp_142_1; float tmp_143_1; float tmp_153_1; float tmp_154_1; int tmp_160_1; float tmp_158_2; float tmp_159_2; float tmp_159_3; float tmp_158_3; float tmp_164_1; float tmp_165_1; float tmp_169_2; float tmp_172_1; float tmp_173_1; float tmp_205_1; float tmp_206_1; float tmp_242_1; float tmp_244_1; float tmp_246_1; float tmp_248_1; float tmp_249_1; float tmp_251_1; float tmp_257_1; float tmp_258_1; float tmp_264_1; float tmp_277_1; float tmp_276_1; int tmp_285_1; float tmp_329_1; float tmp_330_1; float tmp_340_1; float tmp_341_1; int tmp_347_1; float tmp_345_2; float tmp_346_2; float tmp_346_3; float tmp_345_3; float tmp_351_1; float tmp_352_1; float tmp_356_2; float tmp_359_1; float tmp_360_1; float * tmp_375_1; float tmp_371_1; float tmp_372_1; float tmp_373_1; float tmp_374_1; float * tmp_311_1; float tmp_307_1; float tmp_308_1; float tmp_309_1; float tmp_310_1; float tmp_282_3; float tmp_281_3; float tmp_280_3; float tmp_279_3; float tmp_226_1; float tmp_228_1; float tmp_225_1; float tmp_230_1; float tmp_224_1; float tmp_113_1; float tmp_115_1; float tmp_112_1; float tmp_117_1; float tmp_111_1; float * tmp_1_1; int tmp_43_1; tmp_3_1 = __canvasPixelH; tmp_4_1 = __canvasPixelW; tmp_2_1 = MAX(tmp_4_1,tmp_3_1); tmp_6_1 = DIV(tmp_4_1,tmp_2_1); tmp_8_1 = DIV(tmp_3_1,tmp_2_1); tmp_11_1 = USERVAL_IMAGE_ACCESS(0); tmp_12_1 = USERVAL_FLOAT_ACCESS(1); tmp_13_1 = USERVAL_IMAGE_ACCESS(2); tmp_14_1 = USERVAL_FLOAT_ACCESS(3); tmp_15_1 = USERVAL_FLOAT_ACCESS(4); tmp_16_1 = y; tmp_17_1 = x; tmp_18_1 = MUL(tmp_17_1,tmp_6_1); tmp_19_1 = MUL(tmp_16_1,tmp_8_1); tmp_29_1 = t; tmp_45_1 = __canvasPixelH; tmp_46_1 = __canvasPixelW; tmp_44_1 = MAX(tmp_46_1,tmp_45_1); tmp_48_1 = DIV(tmp_46_1,tmp_44_1); tmp_50_1 = DIV(tmp_45_1,tmp_44_1); tmp_57_1 = MUL(tmp_18_1,tmp_48_1); tmp_58_1 = MUL(tmp_19_1,tmp_50_1); tmp_81_1 = __canvasPixelH; tmp_82_1 = __canvasPixelW; tmp_80_1 = MAX(tmp_82_1,tmp_81_1); tmp_84_1 = DIV(tmp_82_1,tmp_80_1); tmp_86_1 = DIV(tmp_81_1,tmp_80_1); tmp_92_1 = MUL(tmp_57_1,tmp_84_1); tmp_93_1 = MUL(tmp_58_1,tmp_86_1); tmp_130_1 = __canvasPixelH; tmp_131_1 = __canvasPixelW; tmp_129_1 = MAX(tmp_131_1,tmp_130_1); tmp_133_1 = DIV(tmp_131_1,tmp_129_1); tmp_135_1 = DIV(tmp_130_1,tmp_129_1); tmp_142_1 = MUL(tmp_92_1,tmp_133_1); tmp_143_1 = MUL(tmp_93_1,tmp_135_1); tmp_153_1 = ADD(tmp_142_1,tmp_133_1); tmp_154_1 = ADD(tmp_143_1,tmp_135_1); tmp_160_1 = EQ(tmp_15_1,0); if (tmp_160_1) { tmp_159_3 = 0; tmp_158_3 = 0; } else { tmp_158_2 = MOD(tmp_153_1,tmp_15_1); tmp_159_2 = MOD(tmp_154_1,tmp_15_1); tmp_159_3 = tmp_159_2; tmp_158_3 = tmp_158_2; } tmp_164_1 = SUB(tmp_142_1,tmp_158_3); tmp_165_1 = SUB(tmp_143_1,tmp_159_3); tmp_169_2 = DIV(tmp_15_1,2); tmp_172_1 = ADD(tmp_164_1,tmp_169_2); tmp_173_1 = ADD(tmp_165_1,tmp_169_2); tmp_205_1 = MUL(tmp_172_1,tmp_84_1); tmp_206_1 = MUL(tmp_173_1,tmp_86_1); tmp_242_1 = __canvasPixelW; tmp_244_1 = __canvasPixelH; tmp_246_1 = SUB(tmp_242_1,1); tmp_248_1 = DIV(tmp_246_1,2); tmp_249_1 = SUB(tmp_244_1,1); tmp_251_1 = DIV(tmp_249_1,2); tmp_257_1 = MUL(tmp_205_1,tmp_248_1); tmp_258_1 = MUL(tmp_206_1,tmp_251_1); tmp_264_1 = noise(tmp_257_1,tmp_258_1,0); tmp_277_1 = SUB(tmp_264_1,-0.69999998807907104); tmp_276_1 = DIV(tmp_277_1,1.3999999761581421); tmp_285_1 = LEQ(tmp_276_1,tmp_14_1); if (tmp_285_1) { tmp_329_1 = MUL(tmp_257_1,tmp_133_1); tmp_330_1 = MUL(tmp_258_1,tmp_135_1); tmp_340_1 = ADD(tmp_329_1,tmp_133_1); tmp_341_1 = ADD(tmp_330_1,tmp_135_1); tmp_347_1 = EQ(tmp_12_1,0); if (tmp_347_1) { tmp_346_3 = 0; tmp_345_3 = 0; } else { tmp_345_2 = MOD(tmp_340_1,tmp_12_1); tmp_346_2 = MOD(tmp_341_1,tmp_12_1); tmp_346_3 = tmp_346_2; tmp_345_3 = tmp_345_2; } tmp_351_1 = SUB(tmp_329_1,tmp_345_3); tmp_352_1 = SUB(tmp_330_1,tmp_346_3); tmp_356_2 = DIV(tmp_12_1,2); tmp_359_1 = ADD(tmp_351_1,tmp_356_2); tmp_360_1 = ADD(tmp_352_1,tmp_356_2); tmp_375_1 = ORIG_VAL(tmp_359_1,tmp_360_1,tmp_11_1,tmp_29_1); tmp_371_1 = TUPLE_NTH(tmp_375_1,0); tmp_372_1 = TUPLE_NTH(tmp_375_1,1); tmp_373_1 = TUPLE_NTH(tmp_375_1,2); tmp_374_1 = TUPLE_NTH(tmp_375_1,3); tmp_282_3 = tmp_374_1; tmp_281_3 = tmp_373_1; tmp_280_3 = tmp_372_1; tmp_279_3 = tmp_371_1; } else { tmp_311_1 = ORIG_VAL(tmp_257_1,tmp_258_1,tmp_13_1,tmp_29_1); tmp_307_1 = TUPLE_NTH(tmp_311_1,0); tmp_308_1 = TUPLE_NTH(tmp_311_1,1); tmp_309_1 = TUPLE_NTH(tmp_311_1,2); tmp_310_1 = TUPLE_NTH(tmp_311_1,3); tmp_282_3 = tmp_310_1; tmp_281_3 = tmp_309_1; tmp_280_3 = tmp_308_1; tmp_279_3 = tmp_307_1; } tmp_226_1 = MUL(0.29899999499320984,tmp_279_3); tmp_228_1 = MUL(0.58700001239776611,tmp_280_3); tmp_225_1 = ADD(tmp_226_1,tmp_228_1); tmp_230_1 = MUL(0.11400000005960464,tmp_281_3); tmp_224_1 = ADD(tmp_225_1,tmp_230_1); tmp_113_1 = MUL(0.29899999499320984,tmp_224_1); tmp_115_1 = MUL(0.58700001239776611,tmp_224_1); tmp_112_1 = ADD(tmp_113_1,tmp_115_1); tmp_117_1 = MUL(0.11400000005960464,tmp_224_1); tmp_111_1 = ADD(tmp_112_1,tmp_117_1); tmp_1_1 = ({ float *tuple = ALLOC_TUPLE(4); TUPLE_SET(tuple, 0, tmp_111_1); TUPLE_SET(tuple, 1, tmp_111_1); TUPLE_SET(tuple, 2, tmp_111_1); TUPLE_SET(tuple, 3, tmp_282_3); tuple; }); tmp_43_1 = OUTPUT_TUPLE(tmp_1_1); return return_tuple; } static float* filter_composer_test (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools) { color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); int frame = 0; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float R = invocation->image_R; float *return_tuple; #if 1 if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; #else if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel_fast; else get_orig_val_pixel_func = get_orig_val_pixel_fast; #endif float tmp_3_1; float tmp_4_1; float tmp_2_1; float tmp_6_1; float tmp_8_1; image_t * tmp_11_1; float tmp_12_1; float tmp_13_1; float tmp_14_1; float tmp_15_1; float tmp_16_1; float tmp_23_1; float tmp_39_1; float tmp_40_1; float tmp_38_1; float tmp_42_1; float tmp_44_1; float tmp_50_1; float tmp_51_1; float tmp_88_1; float tmp_89_1; float tmp_87_1; float tmp_91_1; float tmp_93_1; float tmp_100_1; float tmp_101_1; float tmp_111_1; float tmp_112_1; int tmp_118_1; float tmp_116_2; float tmp_117_2; float tmp_117_3; float tmp_116_3; float tmp_122_1; float tmp_123_1; float tmp_127_2; float tmp_130_1; float tmp_131_1; float * tmp_146_1; float tmp_142_1; float tmp_143_1; float tmp_144_1; float tmp_145_1; float tmp_71_1; float tmp_73_1; float tmp_70_1; float tmp_75_1; float tmp_69_1; float * tmp_1_1; int tmp_37_1; tmp_3_1 = __canvasPixelH; tmp_4_1 = __canvasPixelW; tmp_2_1 = MAX(tmp_4_1,tmp_3_1); tmp_6_1 = DIV(tmp_4_1,tmp_2_1); tmp_8_1 = DIV(tmp_3_1,tmp_2_1); tmp_11_1 = USERVAL_IMAGE_ACCESS(0); tmp_12_1 = USERVAL_FLOAT_ACCESS(1); tmp_13_1 = y; tmp_14_1 = x; tmp_15_1 = MUL(tmp_14_1,tmp_6_1); tmp_16_1 = MUL(tmp_13_1,tmp_8_1); tmp_23_1 = t; tmp_39_1 = __canvasPixelH; tmp_40_1 = __canvasPixelW; tmp_38_1 = MAX(tmp_40_1,tmp_39_1); tmp_42_1 = DIV(tmp_40_1,tmp_38_1); tmp_44_1 = DIV(tmp_39_1,tmp_38_1); tmp_50_1 = MUL(tmp_15_1,tmp_42_1); tmp_51_1 = MUL(tmp_16_1,tmp_44_1); tmp_88_1 = __canvasPixelH; tmp_89_1 = __canvasPixelW; tmp_87_1 = MAX(tmp_89_1,tmp_88_1); tmp_91_1 = DIV(tmp_89_1,tmp_87_1); tmp_93_1 = DIV(tmp_88_1,tmp_87_1); tmp_100_1 = MUL(tmp_50_1,tmp_91_1); tmp_101_1 = MUL(tmp_51_1,tmp_93_1); tmp_111_1 = ADD(tmp_100_1,tmp_91_1); tmp_112_1 = ADD(tmp_101_1,tmp_93_1); tmp_118_1 = EQ(tmp_12_1,0); if (tmp_118_1) { tmp_117_3 = 0; tmp_116_3 = 0; } else { tmp_116_2 = MOD(tmp_111_1,tmp_12_1); tmp_117_2 = MOD(tmp_112_1,tmp_12_1); tmp_117_3 = tmp_117_2; tmp_116_3 = tmp_116_2; } tmp_122_1 = SUB(tmp_100_1,tmp_116_3); tmp_123_1 = SUB(tmp_101_1,tmp_117_3); tmp_127_2 = DIV(tmp_12_1,2); tmp_130_1 = ADD(tmp_122_1,tmp_127_2); tmp_131_1 = ADD(tmp_123_1,tmp_127_2); tmp_146_1 = ORIG_VAL(tmp_130_1,tmp_131_1,tmp_11_1,tmp_23_1); tmp_142_1 = TUPLE_NTH(tmp_146_1,0); tmp_143_1 = TUPLE_NTH(tmp_146_1,1); tmp_144_1 = TUPLE_NTH(tmp_146_1,2); tmp_145_1 = TUPLE_NTH(tmp_146_1,3); tmp_71_1 = MUL(0.29899999499320984,tmp_142_1); tmp_73_1 = MUL(0.58700001239776611,tmp_143_1); tmp_70_1 = ADD(tmp_71_1,tmp_73_1); tmp_75_1 = MUL(0.11400000005960464,tmp_144_1); tmp_69_1 = ADD(tmp_70_1,tmp_75_1); tmp_1_1 = ({ float *tuple = ALLOC_TUPLE(4); TUPLE_SET(tuple, 0, tmp_69_1); TUPLE_SET(tuple, 1, tmp_69_1); TUPLE_SET(tuple, 2, tmp_69_1); TUPLE_SET(tuple, 3, tmp_145_1); tuple; }); tmp_37_1 = OUTPUT_TUPLE(tmp_1_1); return return_tuple; } static float* filter_desaturate (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools) { color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); int frame = 0; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float R = invocation->image_R; float *return_tuple; #if 1 if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; #else if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel_fast; else get_orig_val_pixel_func = get_orig_val_pixel_fast; #endif float tmp_3_1; float tmp_4_1; float tmp_2_1; float tmp_6_1; float tmp_8_1; image_t * tmp_11_1; float tmp_12_1; float tmp_13_1; float tmp_14_1; float tmp_15_1; float tmp_20_1; float * tmp_26_1; float tmp_22_1; float tmp_23_1; float tmp_24_1; float tmp_25_1; float tmp_34_1; float tmp_36_1; float tmp_33_1; float tmp_38_1; float tmp_32_1; float * tmp_1_1; int tmp_50_1; tmp_3_1 = __canvasPixelH; tmp_4_1 = __canvasPixelW; tmp_2_1 = MAX(tmp_4_1,tmp_3_1); tmp_6_1 = DIV(tmp_4_1,tmp_2_1); tmp_8_1 = DIV(tmp_3_1,tmp_2_1); tmp_11_1 = USERVAL_IMAGE_ACCESS(0); tmp_12_1 = y; tmp_13_1 = x; tmp_14_1 = MUL(tmp_13_1,tmp_6_1); tmp_15_1 = MUL(tmp_12_1,tmp_8_1); tmp_20_1 = t; tmp_26_1 = ORIG_VAL(tmp_14_1,tmp_15_1,tmp_11_1,tmp_20_1); tmp_22_1 = TUPLE_NTH(tmp_26_1,0); tmp_23_1 = TUPLE_NTH(tmp_26_1,1); tmp_24_1 = TUPLE_NTH(tmp_26_1,2); tmp_25_1 = TUPLE_NTH(tmp_26_1,3); tmp_34_1 = MUL(0.29899999499320984,tmp_22_1); tmp_36_1 = MUL(0.58700001239776611,tmp_23_1); tmp_33_1 = ADD(tmp_34_1,tmp_36_1); tmp_38_1 = MUL(0.11400000005960464,tmp_24_1); tmp_32_1 = ADD(tmp_33_1,tmp_38_1); tmp_1_1 = ({ float *tuple = ALLOC_TUPLE(4); TUPLE_SET(tuple, 0, tmp_32_1); TUPLE_SET(tuple, 1, tmp_32_1); TUPLE_SET(tuple, 2, tmp_32_1); TUPLE_SET(tuple, 3, tmp_25_1); tuple; }); tmp_50_1 = OUTPUT_TUPLE(tmp_1_1); return return_tuple; } static float* filter_desaturate (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools) { color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); int frame = 0; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float R = invocation->image_R; float *return_tuple; #if 1 if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; #else if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel_fast; else get_orig_val_pixel_func = get_orig_val_pixel_fast; #endif float tmp_3_1; float tmp_4_1; float tmp_2_1; float tmp_6_1; float tmp_8_1; image_t * tmp_11_1; float tmp_12_1; float tmp_13_1; float tmp_14_1; float tmp_15_1; float tmp_20_1; float * tmp_26_1; float tmp_22_1; float tmp_23_1; float tmp_24_1; float tmp_25_1; float tmp_34_1; float tmp_36_1; float tmp_33_1; float tmp_38_1; float tmp_32_1; float * tmp_1_1; int tmp_50_1; tmp_3_1 = __canvasPixelH; tmp_4_1 = __canvasPixelW; tmp_2_1 = MAX(tmp_4_1,tmp_3_1); tmp_6_1 = DIV(tmp_4_1,tmp_2_1); tmp_8_1 = DIV(tmp_3_1,tmp_2_1); tmp_11_1 = USERVAL_IMAGE_ACCESS(0); tmp_12_1 = y; tmp_13_1 = x; tmp_14_1 = MUL(tmp_13_1,tmp_6_1); tmp_15_1 = MUL(tmp_12_1,tmp_8_1); tmp_20_1 = t; tmp_26_1 = ORIG_VAL(tmp_14_1,tmp_15_1,tmp_11_1,tmp_20_1); tmp_22_1 = TUPLE_NTH(tmp_26_1,0); tmp_23_1 = TUPLE_NTH(tmp_26_1,1); tmp_24_1 = TUPLE_NTH(tmp_26_1,2); tmp_25_1 = TUPLE_NTH(tmp_26_1,3); tmp_34_1 = MUL(0.29899999499320984,tmp_22_1); tmp_36_1 = MUL(0.58700001239776611,tmp_23_1); tmp_33_1 = ADD(tmp_34_1,tmp_36_1); tmp_38_1 = MUL(0.11400000005960464,tmp_24_1); tmp_32_1 = ADD(tmp_33_1,tmp_38_1); tmp_1_1 = ({ float *tuple = ALLOC_TUPLE(4); TUPLE_SET(tuple, 0, tmp_32_1); TUPLE_SET(tuple, 1, tmp_32_1); TUPLE_SET(tuple, 2, tmp_32_1); TUPLE_SET(tuple, 3, tmp_25_1); tuple; }); tmp_50_1 = OUTPUT_TUPLE(tmp_1_1); return return_tuple; } static float* filter_comp_dissolve (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools) { color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); int frame = 0; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float R = invocation->image_R; float *return_tuple; #if 1 if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; #else if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel_fast; else get_orig_val_pixel_func = get_orig_val_pixel_fast; #endif float tmp_2_1; float tmp_4_1; float tmp_6_1; float tmp_8_1; float tmp_9_1; float tmp_11_1; image_t * tmp_12_1; image_t * tmp_13_1; float tmp_14_1; float tmp_15_1; float tmp_16_1; float tmp_17_1; float tmp_18_1; float tmp_23_1; float tmp_36_1; float tmp_35_1; int tmp_44_1; float tmp_49_1; float * tmp_55_1; float tmp_51_1; float tmp_52_1; float tmp_53_1; float tmp_54_1; float tmp_64_1; float * tmp_70_1; float tmp_66_1; float tmp_67_1; float tmp_68_1; float tmp_69_1; float tmp_41_3; float tmp_40_3; float tmp_39_3; float tmp_38_3; float * tmp_1_1; int tmp_75_1; tmp_2_1 = __canvasPixelW; tmp_4_1 = __canvasPixelH; tmp_6_1 = SUB(tmp_2_1,1); tmp_8_1 = DIV(tmp_6_1,2); tmp_9_1 = SUB(tmp_4_1,1); tmp_11_1 = DIV(tmp_9_1,2); tmp_12_1 = USERVAL_IMAGE_ACCESS(0); tmp_13_1 = USERVAL_IMAGE_ACCESS(1); tmp_14_1 = USERVAL_FLOAT_ACCESS(2); tmp_15_1 = y; tmp_16_1 = x; tmp_17_1 = MUL(tmp_16_1,tmp_8_1); tmp_18_1 = MUL(tmp_15_1,tmp_11_1); tmp_23_1 = noise(tmp_17_1,tmp_18_1,0); tmp_36_1 = SUB(tmp_23_1,-0.69999998807907104); tmp_35_1 = DIV(tmp_36_1,1.3999999761581421); tmp_44_1 = LEQ(tmp_35_1,tmp_14_1); if (tmp_44_1) { tmp_49_1 = t; tmp_55_1 = ORIG_VAL(tmp_17_1,tmp_18_1,tmp_13_1,tmp_49_1); tmp_51_1 = TUPLE_NTH(tmp_55_1,0); tmp_52_1 = TUPLE_NTH(tmp_55_1,1); tmp_53_1 = TUPLE_NTH(tmp_55_1,2); tmp_54_1 = TUPLE_NTH(tmp_55_1,3); tmp_41_3 = tmp_54_1; tmp_40_3 = tmp_53_1; tmp_39_3 = tmp_52_1; tmp_38_3 = tmp_51_1; } else { tmp_64_1 = t; tmp_70_1 = ORIG_VAL(tmp_17_1,tmp_18_1,tmp_12_1,tmp_64_1); tmp_66_1 = TUPLE_NTH(tmp_70_1,0); tmp_67_1 = TUPLE_NTH(tmp_70_1,1); tmp_68_1 = TUPLE_NTH(tmp_70_1,2); tmp_69_1 = TUPLE_NTH(tmp_70_1,3); tmp_41_3 = tmp_69_1; tmp_40_3 = tmp_68_1; tmp_39_3 = tmp_67_1; tmp_38_3 = tmp_66_1; } tmp_1_1 = ({ float *tuple = ALLOC_TUPLE(4); TUPLE_SET(tuple, 0, tmp_38_3); TUPLE_SET(tuple, 1, tmp_39_3); TUPLE_SET(tuple, 2, tmp_40_3); TUPLE_SET(tuple, 3, tmp_41_3); tuple; }); tmp_75_1 = OUTPUT_TUPLE(tmp_1_1); return return_tuple; } static float* filter_mosaic (mathmap_invocation_t *invocation, userval_t *arguments, float x, float y, float t, pools_t *pools) { color_t (*get_orig_val_pixel_func) (mathmap_invocation_t*, float, float, image_t*, int); int frame = 0; int __canvasPixelW = invocation->img_width; int __canvasPixelH = invocation->img_height; float R = invocation->image_R; float *return_tuple; #if 1 if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel; else get_orig_val_pixel_func = get_orig_val_pixel; #else if (invocation->antialiasing) get_orig_val_pixel_func = get_orig_val_intersample_pixel_fast; else get_orig_val_pixel_func = get_orig_val_pixel_fast; #endif float tmp_3_1; float tmp_4_1; float tmp_2_1; float tmp_6_1; float tmp_8_1; image_t * tmp_11_1; float tmp_12_1; float tmp_13_1; float tmp_14_1; float tmp_15_1; float tmp_16_1; float tmp_25_1; float tmp_26_1; int tmp_32_1; float tmp_30_2; float tmp_31_2; float tmp_31_3; float tmp_30_3; float tmp_36_1; float tmp_37_1; float tmp_41_2; float tmp_44_1; float tmp_45_1; float tmp_50_1; float * tmp_60_1; int tmp_65_1; tmp_3_1 = __canvasPixelH; tmp_4_1 = __canvasPixelW; tmp_2_1 = MAX(tmp_4_1,tmp_3_1); tmp_6_1 = DIV(tmp_4_1,tmp_2_1); tmp_8_1 = DIV(tmp_3_1,tmp_2_1); tmp_11_1 = USERVAL_IMAGE_ACCESS(0); tmp_12_1 = USERVAL_FLOAT_ACCESS(1); tmp_13_1 = y; tmp_14_1 = x; tmp_15_1 = MUL(tmp_14_1,tmp_6_1); tmp_16_1 = MUL(tmp_13_1,tmp_8_1); tmp_25_1 = ADD(tmp_15_1,tmp_6_1); tmp_26_1 = ADD(tmp_16_1,tmp_8_1); tmp_32_1 = EQ(tmp_12_1,0); if (tmp_32_1) { tmp_31_3 = 0; tmp_30_3 = 0; } else { tmp_30_2 = MOD(tmp_25_1,tmp_12_1); tmp_31_2 = MOD(tmp_26_1,tmp_12_1); tmp_31_3 = tmp_31_2; tmp_30_3 = tmp_30_2; } tmp_36_1 = SUB(tmp_15_1,tmp_30_3); tmp_37_1 = SUB(tmp_16_1,tmp_31_3); tmp_41_2 = DIV(tmp_12_1,2); tmp_44_1 = ADD(tmp_36_1,tmp_41_2); tmp_45_1 = ADD(tmp_37_1,tmp_41_2); tmp_50_1 = t; tmp_60_1 = ORIG_VAL(tmp_44_1,tmp_45_1,tmp_11_1,tmp_50_1); tmp_65_1 = OUTPUT_TUPLE(tmp_60_1); return return_tuple; }