Subversion Repositories filter_foundry

Rev

Rev 136 | Rev 141 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /*
  2.     This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
  3.     Copyright (C) 2003-5 Toby Thain, toby@telegraphics.com.au
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. */
  19.  
  20. #ifdef MAC_ENV
  21.         #include <fp.h>
  22. #endif
  23.  
  24. #include <math.h>
  25. #include <stdlib.h>
  26.  
  27. #ifndef PARSERTEST
  28. #include "ff.h"
  29. #endif
  30. #include "funcs.h"
  31. #include "y.tab.h"
  32.  
  33. #include "node.h" // for symbol "var[]"
  34.  
  35. #define RINT //no rounding for now
  36.  
  37. //#if TARGET_API_MAC_CARBON
  38. // this is another incompatibility between Classic stdclib and OS X stdclib
  39. // ***FIXME: need to access real OS X includes for Carbon build
  40. //#undef RAND_MAX
  41. //#define RAND_MAX    0x7fffffff
  42. //#endif
  43.  
  44. extern value_type slider[],cell[],var[],map[][0x100];
  45. extern unsigned char *image_ptr;
  46.  
  47. double costab[COSTABSIZE];
  48. double tantab[TANTABSIZE];
  49. void init_trigtab(){
  50.         int i;
  51.         for(i=0;i<COSTABSIZE;++i){
  52.                 costab[i] = cos(FFANGLE(i));
  53.         }
  54.         for(i=0;i<TANTABSIZE;++i){
  55.                 if (i>=256) {
  56.                         /* the last '-1' in the expression '512-i-1' is for FilterFactory compatibility, and to avoid the undefined pi/2 area */
  57.                         tantab[i] = -tantab[512-i-1];
  58.                 } else {
  59.                         tantab[i] = tan(FFANGLE(i));
  60.                 }
  61.         }
  62. }
  63.  
  64. /* Channel z for the input pixel at coordinates x,y.
  65.  * Coordinates are relative to the input image data (pb->inData) */
  66. static value_type rawsrc(value_type x,value_type y,value_type z){
  67.         if(x < gpb->inRect.left)
  68.                 x = gpb->inRect.left;
  69.         else if(x >= gpb->inRect.right)
  70.                 x = gpb->inRect.right-1;
  71.         if(y < gpb->inRect.top)
  72.                 y = gpb->inRect.top;
  73.         else if(y >= gpb->inRect.bottom)
  74.                 y = gpb->inRect.bottom-1;
  75.         return ((unsigned char*)gpb->inData)[ (long)gpb->inRowBytes*(y - gpb->inRect.top)
  76.                                                                                   + (long)nplanes*(x - gpb->inRect.left) + z ];
  77. }
  78.  
  79. /* src(x,y,z) Channel z for the pixel at coordinates x,y.
  80.  * Coordinates are relative to filtered area (selection). */
  81. value_type ff_src(value_type x,value_type y,value_type z){
  82. #ifdef PARSERTEST
  83.         return 0;
  84. #else
  85.         if(x < 0)
  86.                 x = 0;
  87.         else if(x >= var['X'])
  88.                 x = var['X']-1;
  89.         if(y < 0)
  90.                 y = 0;
  91.         else if(y >= var['Y'])
  92.                 y = var['Y']-1;
  93.         return z >= 0 && z < var['Z'] ?
  94.                 image_ptr[(long)gpb->inRowBytes*y + (long)nplanes*x + z] : 0;
  95. #endif
  96. }
  97.  
  98. /* rad(d,m,z) Channel z in the source image, which is m units away,
  99.         at an angle of d, from the center of the image */
  100. value_type ff_rad(value_type d,value_type m,value_type z){
  101.         return ff_src(ff_r2x(d,m) + var['X']/2, ff_r2y(d,m) + var['Y']/2, z);
  102. }
  103.  
  104. /* ctl(i) Value of slider i, where i is an integer between 0 and 7, inclusive */
  105. value_type ff_ctl(value_type i){
  106.         return i>=0 && i<=7 ? slider[i] : 0;
  107. }
  108.  
  109. /* val(i,a,b) Value of slider i, mapped onto the range a to b */
  110. value_type ff_val(value_type i,value_type a,value_type b){
  111.         return ((long)ff_ctl(i)*(b-a))/255 + a;
  112. }
  113.  
  114. /* map(i,n) Item n from mapping table i, where i is an integer between
  115.         0 and 3, inclusive, and n is and integer between 0 and 255,
  116.         inclusive */
  117. value_type ff_map(value_type i,value_type n){
  118. /*
  119.         if( i>=0 && i<=3 && n>=0 && n<=255 ){
  120.                 int H = slider[i*2],L = slider[i*2+1];
  121.                 return n<=L || H==L ? 0 : ( n>=H ? 255 : ((n-L)*255L)/(H-L) );
  122.         }else
  123.                 return 0;
  124. */
  125.         // this code is from GIMP User Filter
  126.         value_type x = ff_ctl(i*2),
  127.                            y = ff_ctl(i*2+1);
  128.         return abs(((long)n*(y-x) / 255)+x);
  129. }
  130.  
  131. /* min(a,b) Lesser of a and b */
  132. value_type ff_min(value_type a,value_type b){
  133.         return a < b ? a : b;
  134. }
  135.  
  136. /* max(a,b) Greater of a and b */
  137. value_type ff_max(value_type a,value_type b){
  138.         return a > b ? a : b;
  139. }
  140.  
  141. /* abs(a) Absolute value of a */
  142. value_type ff_abs(value_type a){
  143.         return abs(a);
  144. }
  145.  
  146. /* add(a,b,c) Sum of a and b, or c, whichever is lesser */
  147. value_type ff_add(value_type a,value_type b,value_type c){
  148.         return ff_min(a+b,c);
  149. }
  150.  
  151. /* sub(a,b,c) Difference of a and b, or c, whichever is greater */
  152. value_type ff_sub(value_type a,value_type b,value_type c){
  153.         return ff_max(ff_dif(a,b),c);
  154. }
  155.  
  156. /* dif(a,b) Absolute value of the difference of a and b */
  157. value_type ff_dif(value_type a,value_type b){
  158.         return abs(a-b);
  159. }
  160.  
  161. /* rnd(a,b) Random number between a and b, inclusive */
  162. value_type ff_rnd(value_type a,value_type b){
  163.         return (int)((abs(a-b)+1)*(rand()/(RAND_MAX+1.))) + ff_min(a,b);
  164. //      return ((unsigned)rand() % (ff_dif(a,b)+1)) + ff_min(a,b);
  165. }
  166.  
  167. /* mix(a,b,n,d) Mixture of a and b by fraction n/d, a*n/d+b*(d-n)/d */
  168. value_type ff_mix(value_type a,value_type b,value_type n,value_type d){
  169.         return d ? ((long)a*n)/d + ((long)b*(d-n))/d : 0;
  170. }
  171.  
  172. /* scl(a,il,ih,ol,oh) Scale a from input range (il to ih)
  173.                       to output range (ol to oh) */
  174. value_type ff_scl(value_type a,value_type il,value_type ih,
  175.                                   value_type ol,value_type oh){
  176.         return ih==il ? 0 : ol + ((long)(oh-ol)*(a-il))/(ih-il);
  177. }
  178.  
  179. /* adapted from http://remus.rutgers.edu/~rhoads/Code/isqrt.c */
  180. /* also see http://www.freaknet.org/martin/tape/gos/misc/personal/msc/sqrt/sqrt.c */
  181. #define NBITS (sizeof(long)*8)
  182. #define TOP2BITS(x) (x>>(NBITS-2))
  183.  
  184. unsigned long isqrt (unsigned long x)
  185. {
  186.     unsigned i;
  187.     unsigned long a = 0, e = 0, r = 0;
  188.  
  189.  
  190.     for (i=0; i < (NBITS >> 1); i++)
  191.         {
  192.         r <<= 2;
  193.         r +=  TOP2BITS(x);
  194.         x <<= 2;
  195.  
  196.         a <<= 1;
  197.         e  =  (a<<1) | 1;
  198.  
  199.         if (r >= e)
  200.             {
  201.             r -= e;
  202.             a++;
  203.             }
  204.         }
  205.  
  206.     return a;
  207. }
  208.  
  209. /* sqr(x) Square root of x */
  210. value_type ff_sqr(value_type x){
  211.         return x < 0 ? 0 : isqrt(x);
  212. }
  213.  
  214. /* sin(x) Sine function of x, where x is an integer between 0 and
  215.         1024, inclusive, and the value returned is an integer
  216.         between -512 and 512, inclusive (Windows) or -1024 and
  217.         1024, inclusive (Mac OS) */
  218. value_type ff_sin(value_type x){
  219.         //return RINT(TRIGAMP*sin(FFANGLE(x)));
  220.         return ff_cos(x-256);
  221. }
  222.  
  223. /* cos(x) Cosine function of x, where x is an integer between 0 and
  224.    1024, inclusive, and the value returned is an integer
  225.    between -512 and 512, inclusive (Windows) or -1024 and
  226.    1024, inclusive (Mac OS) */
  227. value_type ff_cos(value_type x){
  228.         //return RINT(TRIGAMP*cos(FFANGLE(x)));
  229.         return RINT(TRIGAMP*costab[abs(x) % COSTABSIZE]);
  230. }
  231.  
  232. /* tan(x) Bounded tangent function of x, where x is an integer
  233.    between -256 and 256, inclusive, and the value returned is
  234.    an integer between -512 and 512, inclusive (Windows) or
  235.    -1024 and 1024, inclusive (Mac OS) */
  236. value_type ff_tan(value_type x){
  237.         // TODO: Shouldn't the output be bounded to -1024..1024, or do I understand the definition wrong?
  238.         if (x < 0) x--; /* required for FilterFactory compatibility */
  239.         while (x < 0) x += TANTABSIZE;
  240.         return RINT(2*TRIGAMP*tantab[x % TANTABSIZE]); /* FIXME: why do we need factor 2? */
  241. }
  242.  
  243. /* r2x(d,m) x displacement of the pixel m units away, at an angle of d,
  244.    from an arbitrary center */
  245. value_type ff_r2x(value_type d,value_type m){
  246.         return RINT(m*costab[abs(d) % COSTABSIZE]);
  247. }
  248.  
  249. /* r2y(d,m) y displacement of the pixel m units away, at an angle of d,
  250.    from an arbitrary center */
  251. value_type ff_r2y(value_type d,value_type m){
  252.         return RINT(m*costab[abs(d-256) % COSTABSIZE]);
  253. }
  254.  
  255. /* c2d(x,y) Angle displacement of the pixel at coordinates x,y */
  256. /* note, sign of y difference is negated, as we are dealing with top-down coordinates
  257.    angle is "observed" */
  258. value_type ff_c2d(value_type x,value_type y){
  259.         // Behavior of FilterFoundry <1.7:
  260.         //return RINT(TO_FFANGLE(atan2(-y,-x))); /* FIXME: why must we negate x here? */
  261.  
  262.         // Behavior in FilterFoundry 1.7+: Matches FilterFactory
  263.         return RINT(TO_FFANGLE(atan2(y,x)));
  264. }
  265.  
  266. /* c2m(x,y) Magnitude displacement of the pixel at coordinates x,y */
  267. value_type ff_c2m(value_type x,value_type y){
  268.         return isqrt((long)x*x + (long)y*y);
  269. }
  270.  
  271. /* get(i) Returns the current cell value at i */
  272. value_type ff_get(value_type i){
  273.         return i>=0 && i<=0xff ? cell[i] : 0;
  274. }
  275.  
  276. /* put(v,i) Puts the new value v into cell i */
  277. value_type ff_put(value_type v,value_type i){
  278.         if(i>=0 && i<=0xff)
  279.                 cell[i] = v;
  280.         return v;
  281. }
  282.  
  283. value_type ff_cnv(value_type m11,value_type m12,value_type m13,
  284.                                   value_type m21,value_type m22,value_type m23,
  285.                                   value_type m31,value_type m32,value_type m33,
  286.                                   value_type d)
  287. {
  288. #ifdef PARSERTEST
  289.         return 0;
  290. #else
  291.         long total;
  292.         // shift x,y from selection-relative to image relative
  293.         int x = var['x'] + gpb->filterRect.left,
  294.                 y = var['y'] + gpb->filterRect.top,
  295.                 z = var['z'];
  296.  
  297.         if(z >= 0 && z < var['Z'])
  298.                 total = m11*rawsrc(x-1,y-1,z) + m12*rawsrc(x,y-1,z) + m13*rawsrc(x+1,y-1,z)
  299.                           + m21*rawsrc(x-1,y,  z) + m22*rawsrc(x,y,  z) + m23*rawsrc(x+1,y,  z)
  300.                           + m31*rawsrc(x-1,y+1,z) + m32*rawsrc(x,y+1,z) + m33*rawsrc(x+1,y+1,z);
  301.         else
  302.                 total = 0;
  303.  
  304.         return d ? total/d : 0;
  305. #endif
  306. }
  307.  
  308. /* rst(i) sets a random seed and returns 0. (undocumented Filter Factory function).
  309.    Added by DM, 18 Dec 2018 */
  310. value_type ff_rst(value_type seed){
  311.         srand(seed);
  312.         return 0;
  313. }
  314.  
  315. value_type zero_val = 0;
  316. value_type one_val = 1;
  317. value_type max_channel_val = 255;
  318.  
  319. /* predefined symbols */
  320. struct sym_rec predefs[]={
  321.         /* functions */
  322.  
  323.         {0,TOK_FN3,"src", (pfunc_type)ff_src, 0},
  324.         {0,TOK_FN3,"rad", (pfunc_type)ff_rad, 0},
  325.         {0,TOK_FN1,"ctl", (pfunc_type)ff_ctl, 0},
  326.         {0,TOK_FN3,"val", (pfunc_type)ff_val, 0},
  327.         {0,TOK_FN2,"map", (pfunc_type)ff_map, 0},
  328.         {0,TOK_FN2,"min", (pfunc_type)ff_min, 0},
  329.         {0,TOK_FN2,"max", (pfunc_type)ff_max, 0},
  330.         {0,TOK_FN1,"abs", (pfunc_type)ff_abs, 0},
  331.         {0,TOK_FN3,"add", (pfunc_type)ff_add, 0},
  332.         {0,TOK_FN3,"sub", (pfunc_type)ff_sub, 0},
  333.         {0,TOK_FN2,"dif", (pfunc_type)ff_dif, 0},
  334.         {0,TOK_FN2,"rnd", (pfunc_type)ff_rnd, 0},
  335.         {0,TOK_FN4,"mix", (pfunc_type)ff_mix, 0},
  336.         {0,TOK_FN5,"scl", (pfunc_type)ff_scl, 0},
  337.         {0,TOK_FN1,"sqr", (pfunc_type)ff_sqr, 0},
  338.         {0,TOK_FN1,"sin", (pfunc_type)ff_sin, 0},
  339.         {0,TOK_FN1,"cos", (pfunc_type)ff_cos, 0},
  340.         {0,TOK_FN1,"tan", (pfunc_type)ff_tan, 0},
  341.         {0,TOK_FN2,"r2x", (pfunc_type)ff_r2x, 0},
  342.         {0,TOK_FN2,"r2y", (pfunc_type)ff_r2y, 0},
  343.         {0,TOK_FN2,"c2d", (pfunc_type)ff_c2d, 0},
  344.         {0,TOK_FN2,"c2m", (pfunc_type)ff_c2m, 0},
  345.         {0,TOK_FN1,"get", (pfunc_type)ff_get, 0},
  346.         {0,TOK_FN2,"put", (pfunc_type)ff_put, 0},
  347.         {0,TOK_FN10,"cnv",(pfunc_type)ff_cnv, 0},
  348.         {0,TOK_FN1,"rst", (pfunc_type)ff_rst, 0}, // undocumented FilterFactory function
  349.  
  350.         /* predefined variables (names with more than 1 character); most of them are undocumented in FilterFactory */
  351.         /* the predefined variables with 1 character are defined in lexer.l and process.c */
  352.         /* in this table, you must not add TOK_VAR with only 1 character (since this case is not defined in parser.y) */
  353.  
  354.         {0,TOK_VAR,"rmax",0, &max_channel_val}, // alias of 'R' (defined in lexer.l, line 129)
  355.         {0,TOK_VAR,"gmax",0, &max_channel_val}, // alias of 'G' (defined in lexer.l, line 129)
  356.         {0,TOK_VAR,"bmax",0, &max_channel_val}, // alias of 'B' (defined in lexer.l, line 129)
  357.         {0,TOK_VAR,"amax",0, &max_channel_val}, // alias of 'A' (defined in lexer.l, line 129)
  358.         {0,TOK_VAR,"cmax",0, &max_channel_val}, // alias of 'C' (defined in lexer.l, line 129)
  359.         {0,TOK_VAR,"imax",0, &max_channel_val}, // alias of 'I' (defined in lexer.l, line 129)
  360.         {0,TOK_VAR,"umax",0, &max_channel_val}, // alias of 'U' (defined in lexer.l, line 129)
  361.         {0,TOK_VAR,"vmax",0, &max_channel_val}, // alias of 'V' (defined in lexer.l, line 129)
  362.         {0,TOK_VAR,"dmax",0, &var['D']},
  363.         {0,TOK_VAR,"mmax",0, &var['M']},
  364.         {0,TOK_VAR,"pmax",0, &var['Z']},
  365.         {0,TOK_VAR,"xmax",0, &var['X']},
  366.         {0,TOK_VAR,"ymax",0, &var['Y']},
  367.         {0,TOK_VAR,"zmax",0, &var['Z']},
  368.  
  369.         {0,TOK_VAR,"rmin",0, &zero_val},
  370.         {0,TOK_VAR,"gmin",0, &zero_val},
  371.         {0,TOK_VAR,"bmin",0, &zero_val},
  372.         {0,TOK_VAR,"amin",0, &zero_val},
  373.         {0,TOK_VAR,"cmin",0, &zero_val},
  374.         {0,TOK_VAR,"imin",0, &zero_val},
  375.         {0,TOK_VAR,"umin",0, &zero_val},
  376.         {0,TOK_VAR,"vmin",0, &zero_val},
  377.         {0,TOK_VAR,"dmin",0, &zero_val},
  378.         {0,TOK_VAR,"mmin",0, &zero_val},
  379.         {0,TOK_VAR,"pmin",0, &zero_val},
  380.         {0,TOK_VAR,"xmin",0, &zero_val},
  381.         {0,TOK_VAR,"ymin",0, &zero_val},
  382.         {0,TOK_VAR,"zmin",0, &zero_val},
  383.  
  384.         /* Undocumented synonyms of FilterFactory for compatibility with Premiere */
  385.         {0,TOK_FN10,"cnv0",(pfunc_type)ff_cnv, 0},
  386.         {0,TOK_FN3,"src0", (pfunc_type)ff_src, 0},
  387.         {0,TOK_FN3,"rad0", (pfunc_type)ff_rad, 0},
  388.         {0,TOK_FN10,"cnv1",(pfunc_type)ff_cnv, 0},
  389.         {0,TOK_FN3,"src1", (pfunc_type)ff_src, 0},
  390.         {0,TOK_FN3,"rad1", (pfunc_type)ff_rad, 0},
  391.         {0,TOK_VAR,"r0",0, &var['r']},
  392.         {0,TOK_VAR,"g0",0, &var['g']},
  393.         {0,TOK_VAR,"b0",0, &var['b']},
  394.         {0,TOK_VAR,"a0",0, &var['a']},
  395.         {0,TOK_VAR,"c0",0, &var['c']},
  396.         {0,TOK_VAR,"i0",0, &var['i']},
  397.         {0,TOK_VAR,"u0",0, &var['u']},
  398.         {0,TOK_VAR,"v0",0, &var['v']},
  399.         {0,TOK_VAR,"d0",0, &var['d']},
  400.         {0,TOK_VAR,"m0",0, &var['m']},
  401.         {0,TOK_VAR,"r1",0, &var['r']},
  402.         {0,TOK_VAR,"g1",0, &var['g']},
  403.         {0,TOK_VAR,"b1",0, &var['b']},
  404.         {0,TOK_VAR,"a1",0, &var['a']},
  405.         {0,TOK_VAR,"c1",0, &var['c']},
  406.         {0,TOK_VAR,"i1",0, &var['i']},
  407.         {0,TOK_VAR,"u1",0, &var['u']},
  408.         {0,TOK_VAR,"v1",0, &var['v']},
  409.         {0,TOK_VAR,"d1",0, &var['d']},
  410.         {0,TOK_VAR,"m1",0, &var['m']},
  411.         {0,TOK_VAR,"tmin",0, &zero_val},
  412.         {0,TOK_VAR,"tmax",0, &one_val},
  413.         {0,TOK_VAR,"total",0, &one_val},
  414.  
  415.         {0,0,0,0,0}
  416. };