WebSVN – filter_foundry – Blame – /trunk/funcs.c

Rev	Author	Line No.	Line
259	daniel-mar	1	/*
500	daniel-mar	2	This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
		3	Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.com.au
		4	Copyright (C) 2018-2021 Daniel Marschall, ViaThinkSoft
259	daniel-mar	5
500	daniel-mar	6	This program is free software; you can redistribute it and/or modify
		7	it under the terms of the GNU General Public License as published by
		8	the Free Software Foundation; either version 2 of the License, or
		9	(at your option) any later version.
259	daniel-mar	10
500	daniel-mar	11	This program is distributed in the hope that it will be useful,
		12	but WITHOUT ANY WARRANTY; without even the implied warranty of
		13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		14	GNU General Public License for more details.
259	daniel-mar	15
500	daniel-mar	16	You should have received a copy of the GNU General Public License
		17	along with this program; if not, write to the Free Software
		18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
259	daniel-mar	19	*/
		20
		21	#ifdef MAC_ENV
500	daniel-mar	22	#include <fp.h>
259	daniel-mar	23	#endif
		24
		25	#include <math.h>
		26	#include <stdlib.h>
		27
		28	#ifndef PARSERTEST
500	daniel-mar	29	#include "ff.h"
297	daniel-mar	30	#else
500	daniel-mar	31	#define uint8_t unsigned char
		32	#define uint16_t unsigned short
		33	#define uint32_t unsigned int
		34	#define int32_t int
259	daniel-mar	35	#endif
268	daniel-mar	36
259	daniel-mar	37	#include "funcs.h"
		38	#include "y.tab.h"
		39
		40	#include "node.h" // for symbol "var[]"
		41
		42	#define RINT //no rounding for now
		43
		44	//#if TARGET_API_MAC_CARBON
		45	// this is another incompatibility between Classic stdclib and OS X stdclib
		46	// ***FIXME: need to access real OS X includes for Carbon build
		47	//#undef RAND_MAX
		48	//#define RAND_MAX 0x7fffffff
		49	//#endif
		50
294	daniel-mar	51	const int FACTORY_COS_LOOKUP[1024] = {
		52	16384, 16383, 16382, 16381, 16379, 16376, 16372, 16368, 16364, 16359, 16353, 16346, 16339, 16331, 16323,
		53	16314, 16305, 16294, 16284, 16272, 16260, 16248, 16234, 16221, 16206, 16191, 16175, 16159, 16142, 16125,
		54	16107, 16088, 16069, 16049, 16028, 16007, 15985, 15963, 15940, 15917, 15893, 15868, 15842, 15817, 15790,
		55	15763, 15735, 15707, 15678, 15649, 15618, 15588, 15557, 15525, 15492, 15459, 15426, 15392, 15357, 15322,
		56	15286, 15249, 15212, 15175, 15136, 15098, 15058, 15018, 14978, 14937, 14895, 14853, 14811, 14767, 14723,
		57	14679, 14634, 14589, 14543, 14496, 14449, 14401, 14353, 14304, 14255, 14205, 14155, 14104, 14053, 14001,
		58	13948, 13895, 13842, 13788, 13733, 13678, 13622, 13566, 13510, 13452, 13395, 13337, 13278, 13219, 13159,
		59	13099, 13039, 12977, 12916, 12854, 12791, 12728, 12665, 12601, 12536, 12471, 12406, 12340, 12273, 12207,
		60	12139, 12072, 12003, 11935, 11866, 11796, 11726, 11656, 11585, 11513, 11442, 11370, 11297, 11224, 11151,
		61	11077, 11003, 10928, 10853, 10777, 10701, 10625, 10548, 10471, 10394, 10316, 10237, 10159, 10080, 10000,
		62	9920, 9840, 9760, 9679, 9597, 9516, 9434, 9351, 9269, 9186, 9102, 9018, 8934, 8850, 8765, 8680, 8595,
		63	8509, 8423, 8336, 8250, 8163, 8075, 7988, 7900, 7812, 7723, 7634, 7545, 7456, 7366, 7276, 7186, 7096,
		64	7005, 6914, 6822, 6731, 6639, 6547, 6455, 6362, 6270, 6176, 6083, 5990, 5896, 5802, 5708, 5614, 5519,
		65	5424, 5329, 5234, 5139, 5043, 4948, 4852, 4756, 4659, 4563, 4466, 4369, 4273, 4175, 4078, 3981, 3883,
		66	3785, 3687, 3589, 3491, 3393, 3295, 3196, 3097, 2998, 2900, 2801, 2702, 2602, 2503, 2404, 2304, 2205,
		67	2105, 2005, 1905, 1806, 1706, 1606, 1505, 1405, 1305, 1205, 1105, 1004, 904, 804, 703, 603, 502, 402,
		68	301, 201, 100, -100, -201, -301, -402, -502, -603, -703, -804, -904, -1004, -1105, -1205, -1305, -1405,
		69	-1505, -1606, -1706, -1806, -1905, -2005, -2105, -2205, -2304, -2404, -2503, -2602, -2702, -2801, -2900,
		70	-2998, -3097, -3196, -3295, -3393, -3491, -3589, -3687, -3785, -3883, -3981, -4078, -4175, -4273, -4369,
		71	-4466, -4563, -4659, -4756, -4852, -4948, -5043, -5139, -5234, -5329, -5424, -5519, -5614, -5708, -5802,
		72	-5896, -5990, -6083, -6176, -6270, -6362, -6455, -6547, -6639, -6731, -6822, -6914, -7005, -7096, -7186,
		73	-7276, -7366, -7456, -7545, -7634, -7723, -7812, -7900, -7988, -8075, -8163, -8250, -8336, -8423, -8509,
		74	-8595, -8680, -8765, -8850, -8934, -9018, -9102, -9186, -9269, -9351, -9434, -9516, -9597, -9679, -9760,
		75	-9840, -9920, -10000, -10080, -10159, -10237, -10316, -10394, -10471, -10548, -10625, -10701, -10777,
		76	-10853, -10928, -11003, -11077, -11151, -11224, -11297, -11370, -11442, -11513, -11585, -11656, -11726,
		77	-11796, -11866, -11935, -12003, -12072, -12139, -12207, -12273, -12340, -12406, -12471, -12536, -12601,
		78	-12665, -12728, -12791, -12854, -12916, -12977, -13039, -13099, -13159, -13219, -13278, -13337, -13395,
		79	-13452, -13510, -13566, -13622, -13678, -13733, -13788, -13842, -13895, -13948, -14001, -14053, -14104,
		80	-14155, -14205, -14255, -14304, -14353, -14401, -14449, -14496, -14543, -14589, -14634, -14679, -14723,
		81	-14767, -14811, -14853, -14895, -14937, -14978, -15018, -15058, -15098, -15136, -15175, -15212, -15249,
		82	-15286, -15322, -15357, -15392, -15426, -15459, -15492, -15525, -15557, -15588, -15618, -15649, -15678,
		83	-15707, -15735, -15763, -15790, -15817, -15842, -15868, -15893, -15917, -15940, -15963, -15985, -16007,
		84	-16028, -16049, -16069, -16088, -16107, -16125, -16142, -16159, -16175, -16191, -16206, -16221, -16234,
		85	-16248, -16260, -16272, -16284, -16294, -16305, -16314, -16323, -16331, -16339, -16346, -16353, -16359,
		86	-16364, -16368, -16372, -16376, -16379, -16381, -16382, -16383, -16384, -16384, -16383, -16382, -16381,
		87	-16379, -16376, -16372, -16368, -16364, -16359, -16353, -16346, -16339, -16331, -16323, -16314, -16305,
		88	-16294, -16284, -16272, -16260, -16248, -16234, -16221, -16206, -16191, -16175, -16159, -16142, -16125,
		89	-16107, -16088, -16069, -16049, -16028, -16007, -15985, -15963, -15940, -15917, -15893, -15868, -15842,
		90	-15817, -15790, -15763, -15735, -15707, -15678, -15649, -15618, -15588, -15557, -15525, -15492, -15459,
		91	-15426, -15392, -15357, -15322, -15286, -15249, -15212, -15175, -15136, -15098, -15058, -15018, -14978,
		92	-14937, -14895, -14853, -14811, -14767, -14723, -14679, -14634, -14589, -14543, -14496, -14449, -14401,
		93	-14353, -14304, -14255, -14205, -14155, -14104, -14053, -14001, -13948, -13895, -13842, -13788, -13733,
		94	-13678, -13622, -13566, -13510, -13452, -13395, -13337, -13278, -13219, -13159, -13099, -13039, -12977,
		95	-12916, -12854, -12791, -12728, -12665, -12601, -12536, -12471, -12406, -12340, -12273, -12207, -12139,
		96	-12072, -12003, -11935, -11866, -11796, -11726, -11656, -11585, -11513, -11442, -11370, -11297, -11224,
		97	-11151, -11077, -11003, -10928, -10853, -10777, -10701, -10625, -10548, -10471, -10394, -10316, -10237,
		98	-10159, -10080, -10000, -9920, -9840, -9760, -9679, -9597, -9516, -9434, -9351, -9269, -9186, -9102,
		99	-9018, -8934, -8850, -8765, -8680, -8595, -8509, -8423, -8336, -8250, -8163, -8075, -7988, -7900, -7812,
		100	-7723, -7634, -7545, -7456, -7366, -7276, -7186, -7096, -7005, -6914, -6822, -6731, -6639, -6547, -6455,
		101	-6362, -6270, -6176, -6083, -5990, -5896, -5802, -5708, -5614, -5519, -5424, -5329, -5234, -5139, -5043,
		102	-4948, -4852, -4756, -4659, -4563, -4466, -4369, -4273, -4175, -4078, -3981, -3883, -3785, -3687, -3589,
		103	-3491, -3393, -3295, -3196, -3097, -2998, -2900, -2801, -2702, -2602, -2503, -2404, -2304, -2205, -2105,
		104	-2005, -1905, -1806, -1706, -1606, -1505, -1405, -1305, -1205, -1105, -1004, -904, -804, -703, -603, -502,
		105	-402, -301, -201, -100, 100, 201, 301, 402, 502, 603, 703, 804, 904, 1004, 1105, 1205, 1305, 1405, 1505,
		106	1606, 1706, 1806, 1905, 2005, 2105, 2205, 2304, 2404, 2503, 2602, 2702, 2801, 2900, 2998, 3097, 3196,
		107	3295, 3393, 3491, 3589, 3687, 3785, 3883, 3981, 4078, 4175, 4273, 4369, 4466, 4563, 4659, 4756, 4852,
		108	4948, 5043, 5139, 5234, 5329, 5424, 5519, 5614, 5708, 5802, 5896, 5990, 6083, 6176, 6270, 6362, 6455,
		109	6547, 6639, 6731, 6822, 6914, 7005, 7096, 7186, 7276, 7366, 7456, 7545, 7634, 7723, 7812, 7900, 7988,
		110	8075, 8163, 8250, 8336, 8423, 8509, 8595, 8680, 8765, 8850, 8934, 9018, 9102, 9186, 9269, 9351, 9434,
		111	9516, 9597, 9679, 9760, 9840, 9920, 10000, 10080, 10159, 10237, 10316, 10394, 10471, 10548, 10625, 10701,
		112	10777, 10853, 10928, 11003, 11077, 11151, 11224, 11297, 11370, 11442, 11513, 11585, 11656, 11726, 11796,
		113	11866, 11935, 12003, 12072, 12139, 12207, 12273, 12340, 12406, 12471, 12536, 12601, 12665, 12728, 12791,
		114	12854, 12916, 12977, 13039, 13099, 13159, 13219, 13278, 13337, 13395, 13452, 13510, 13566, 13622, 13678,
		115	13733, 13788, 13842, 13895, 13948, 14001, 14053, 14104, 14155, 14205, 14255, 14304, 14353, 14401, 14449,
		116	14496, 14543, 14589, 14634, 14679, 14723, 14767, 14811, 14853, 14895, 14937, 14978, 15018, 15058, 15098,
		117	15136, 15175, 15212, 15249, 15286, 15322, 15357, 15392, 15426, 15459, 15492, 15525, 15557, 15588, 15618,
		118	15649, 15678, 15707, 15735, 15763, 15790, 15817, 15842, 15868, 15893, 15917, 15940, 15963, 15985, 16007,
		119	16028, 16049, 16069, 16088, 16107, 16125, 16142, 16159, 16175, 16191, 16206, 16221, 16234, 16248, 16260,
		120	16272, 16284, 16294, 16305, 16314, 16323, 16331, 16339, 16346, 16353, 16359, 16364, 16368, 16372, 16376,
		121	16379, 16381, 16382, 16383, 16384 };
		122
		123	const uint16_t FACTORY_C2D_LOOKUP[1024] = {
		124	64, 128, 191, 255, 319, 383, 447, 511, 575, 639, 703, 767, 831, 895, 959, 1023, 1087, 1151, 1215, 1279,
		125	1343, 1407, 1471, 1535, 1599, 1663, 1727, 1791, 1855, 1919, 1983, 2047, 2111, 2175, 2239, 2303, 2366,
		126	2430, 2494, 2558, 2622, 2686, 2750, 2814, 2878, 2942, 3005, 3069, 3133, 3197, 3261, 3325, 3388, 3452,
		127	3516, 3580, 3644, 3708, 3771, 3835, 3899, 3963, 4026, 4090, 4154, 4218, 4281, 4345, 4409, 4473, 4536,
		128	4600, 4664, 4727, 4791, 4855, 4918, 4982, 5046, 5109, 5173, 5236, 5300, 5364, 5427, 5491, 5554, 5618,
		129	5681, 5745, 5808, 5872, 5935, 5999, 6062, 6126, 6189, 6252, 6316, 6379, 6443, 6506, 6569, 6633, 6696,
		130	6759, 6823, 6886, 6949, 7013, 7076, 7139, 7202, 7266, 7329, 7392, 7455, 7518, 7582, 7645, 7708, 7771,
		131	7834, 7897, 7960, 8023, 8086, 8149, 8212, 8275, 8338, 8401, 8464, 8527, 8590, 8653, 8716, 8779, 8841,
		132	8904, 8967, 9030, 9093, 9155, 9218, 9281, 9344, 9406, 9469, 9532, 9594, 9657, 9720, 9782, 9845, 9907,
		133	9970, 10032, 10095, 10157, 10220, 10282, 10345, 10407, 10470, 10532, 10594, 10657, 10719, 10781, 10843,
		134	10906, 10968, 11030, 11092, 11155, 11217, 11279, 11341, 11403, 11465, 11527, 11589, 11651, 11713, 11775,
		135	11837, 11899, 11961, 12023, 12085, 12146, 12208, 12270, 12332, 12394, 12455, 12517, 12579, 12640, 12702,
		136	12764, 12825, 12887, 12948, 13010, 13071, 13133, 13194, 13256, 13317, 13379, 13440, 13501, 13563, 13624,
		137	13685, 13746, 13808, 13869, 13930, 13991, 14052, 14113, 14174, 14235, 14296, 14357, 14418, 14479, 14540,
		138	14601, 14662, 14723, 14784, 14844, 14905, 14966, 15027, 15087, 15148, 15208, 15269, 15330, 15390, 15451,
		139	15511, 15572, 15632, 15693, 15753, 15813, 15874, 15934, 15994, 16054, 16115, 16175, 16235, 16295, 16355,
		140	16415, 16475, 16535, 16595, 16655, 16715, 16775, 16835, 16895, 16955, 17015, 17074, 17134, 17194, 17254,
		141	17313, 17373, 17432, 17492, 17551, 17611, 17670, 17730, 17789, 17849, 17908, 17967, 18027, 18086, 18145,
		142	18204, 18264, 18323, 18382, 18441, 18500, 18559, 18618, 18677, 18736, 18795, 18854, 18912, 18971, 19030,
		143	19089, 19147, 19206, 19265, 19323, 19382, 19440, 19499, 19557, 19616, 19674, 19733, 19791, 19849, 19908,
		144	19966, 20024, 20082, 20141, 20199, 20257, 20315, 20373, 20431, 20489, 20547, 20605, 20663, 20720, 20778,
		145	20836, 20894, 20951, 21009, 21067, 21124, 21182, 21239, 21297, 21354, 21412, 21469, 21526, 21584, 21641,
		146	21698, 21756, 21813, 21870, 21927, 21984, 22041, 22098, 22155, 22212, 22269, 22326, 22383, 22439, 22496,
		147	22553, 22610, 22666, 22723, 22780, 22836, 22893, 22949, 23006, 23062, 23118, 23175, 23231, 23287, 23344,
		148	23400, 23456, 23512, 23568, 23624, 23680, 23736, 23792, 23848, 23904, 23960, 24016, 24071, 24127, 24183,
		149	24238, 24294, 24350, 24405, 24461, 24516, 24572, 24627, 24682, 24738, 24793, 24848, 24904, 24959, 25014,
		150	25069, 25124, 25179, 25234, 25289, 25344, 25399, 25454, 25509, 25563, 25618, 25673, 25727, 25782, 25836,
		151	25891, 25945, 26000, 26054, 26109, 26163, 26217, 26271, 26326, 26380, 26434, 26488, 26542, 26596, 26650,
		152	26704, 26758, 26812, 26866, 26920, 26974, 27027, 27081, 27135, 27188, 27242, 27295, 27349, 27402, 27456,
		153	27509, 27563, 27616, 27669, 27722, 27776, 27829, 27882, 27935, 27988, 28041, 28094, 28147, 28200, 28253,
		154	28305, 28358, 28411, 28464, 28516, 28569, 28621, 28674, 28726, 28779, 28831, 28884, 28936, 28988, 29041,
		155	29093, 29145, 29197, 29249, 29301, 29353, 29405, 29457, 29509, 29561, 29613, 29664, 29716, 29768, 29820,
		156	29871, 29923, 29974, 30026, 30077, 30129, 30180, 30231, 30283, 30334, 30385, 30436, 30488, 30539, 30590,
		157	30641, 30692, 30743, 30794, 30844, 30895, 30946, 30997, 31047, 31098, 31149, 31199, 31250, 31300, 31351,
		158	31401, 31452, 31502, 31552, 31602, 31653, 31703, 31753, 31803, 31853, 31903, 31953, 32003, 32053, 32103,
		159	32153, 32202, 32252, 32302, 32351, 32401, 32451, 32500, 32550, 32599, 32649, 32698, 32747, 32796, 32846,
		160	32895, 32944, 32993, 33042, 33091, 33140, 33189, 33238, 33287, 33336, 33385, 33434, 33482, 33531, 33580,
		161	33628, 33677, 33725, 33774, 33822, 33871, 33919, 33967, 34015, 34064, 34112, 34160, 34208, 34256, 34304,
		162	34352, 34400, 34448, 34496, 34544, 34592, 34639, 34687, 34735, 34782, 34830, 34877, 34925, 34972, 35020,
		163	35067, 35115, 35162, 35209, 35256, 35303, 35351, 35398, 35445, 35492, 35539, 35586, 35633, 35679, 35726,
		164	35773, 35820, 35866, 35913, 35960, 36006, 36053, 36099, 36146, 36192, 36239, 36285, 36331, 36377, 36424,
		165	36470, 36516, 36562, 36608, 36654, 36700, 36746, 36792, 36838, 36883, 36929, 36975, 37021, 37066, 37112,
		166	37157, 37203, 37248, 37294, 37339, 37385, 37430, 37475, 37520, 37566, 37611, 37656, 37701, 37746, 37791,
		167	37836, 37881, 37926, 37971, 38015, 38060, 38105, 38149, 38194, 38239, 38283, 38328, 38372, 38417, 38461,
		168	38505, 38550, 38594, 38638, 38682, 38727, 38771, 38815, 38859, 38903, 38947, 38991, 39035, 39078, 39122,
		169	39166, 39210, 39253, 39297, 39341, 39384, 39428, 39471, 39515, 39558, 39601, 39645, 39688, 39731, 39774,
		170	39818, 39861, 39904, 39947, 39990, 40033, 40076, 40119, 40161, 40204, 40247, 40290, 40332, 40375, 40418,
		171	40460, 40503, 40545, 40588, 40630, 40673, 40715, 40757, 40799, 40842, 40884, 40926, 40968, 41010, 41052,
		172	41094, 41136, 41178, 41220, 41262, 41303, 41345, 41387, 41429, 41470, 41512, 41553, 41595, 41636, 41678,
		173	41719, 41761, 41802, 41843, 41885, 41926, 41967, 42008, 42049, 42090, 42131, 42172, 42213, 42254, 42295,
		174	42336, 42376, 42417, 42458, 42499, 42539, 42580, 42620, 42661, 42701, 42742, 42782, 42823, 42863, 42903,
		175	42944, 42984, 43024, 43064, 43104, 43144, 43184, 43224, 43264, 43304, 43344, 43384, 43424, 43463, 43503,
		176	43543, 43582, 43622, 43662, 43701, 43741, 43780, 43820, 43859, 43898, 43938, 43977, 44016, 44055, 44094,
		177	44134, 44173, 44212, 44251, 44290, 44329, 44368, 44406, 44445, 44484, 44523, 44562, 44600, 44639, 44677,
		178	44716, 44755, 44793, 44832, 44870, 44908, 44947, 44985, 45023, 45062, 45100, 45138, 45176, 45214, 45252,
		179	45290, 45328, 45366, 45404, 45442, 45480, 45518, 45555, 45593, 45631, 45668, 45706, 45744, 45781, 45819,
		180	45856, 45894, 45931, 45968, 46006, 46043, 46080, 46117, 46155, 46192, 46229, 46266, 46303, 46340, 46377,
		181	46414, 46451, 46488, 46525, 46561, 46598, 46635, 46672, 46708, 46745, 46781, 46818, 46854, 46891, 46927,
		182	46964, 47000, 47037, 47073, 47109, 47145, 47182, 47218, 47254, 47290, 47326, 47362, 47398, 47434, 47470,
		183	47506, 47542, 47577, 47613, 47649, 47685, 47720, 47756, 47792, 47827, 47863, 47898, 47934, 47969, 48004,
		184	48040, 48075, 48110, 48146, 48181, 48216, 48251, 48286, 48322, 48357, 48392, 48427, 48462, 48496, 48531,
		185	48566, 48601, 48636, 48671, 48705, 48740, 48775, 48809, 48844, 48878, 48913, 48947, 48982, 49016, 49051,
		186	49085, 49119, 49154, 49188, 49222, 49256, 49290, 49324, 49359, 49393, 49427, 49461, 49495, 49528, 49562,
		187	49596, 49630, 49664, 49698, 49731, 49765, 49799, 49832, 49866, 49899, 49933, 49966, 50000, 50033, 50067,
		188	50100, 50133, 50167, 50200, 50233, 50266, 50299, 50333, 50366, 50399, 50432, 50465, 50498, 50531, 50564,
		189	50597, 50629, 50662, 50695, 50728, 50760, 50793, 50826, 50858, 50891, 50924, 50956, 50989, 51021, 51053,
		190	51086, 51118, 51151, 51183, 51215, 51247, 51280, 51312, 51344, 51376, 51408, 51440, 51472 };
		191
		192	const uint16_t FACTORY_C2M_LOOKUP[1024] = {
		193	32, 32, 32, 32, 32, 32, 33, 33, 33, 34, 35, 35, 36, 37, 38, 39, 39, 41, 42, 43, 44, 45, 47, 48, 49, 51,
		194	53, 54, 56, 58, 60, 62, 63, 66, 68, 70, 72, 74, 77, 79, 81, 84, 87, 89, 92, 95, 98, 100, 103, 106, 110,
		195	113, 116, 119, 123, 126, 129, 133, 137, 140, 144, 148, 152, 155, 159, 163, 167, 172, 176, 180, 184, 189,
		196	193, 198, 202, 207, 212, 217, 221, 226, 231, 236, 241, 246, 252, 257, 262, 268, 273, 279, 284, 290, 295,
		197	301, 307, 313, 319, 325, 331, 337, 343, 350, 356, 362, 369, 375, 382, 388, 395, 402, 409, 415, 422, 429,
		198	436, 443, 451, 458, 465, 473, 480, 487, 495, 503, 510, 518, 526, 534, 542, 549, 558, 566, 574, 582, 590,
		199	599, 607, 615, 624, 633, 641, 650, 659, 667, 676, 685, 694, 703, 712, 722, 731, 740, 750, 759, 768, 778,
		200	788, 797, 807, 817, 827, 837, 847, 857, 867, 877, 887, 897, 908, 918, 928, 939, 950, 960, 971, 982, 992,
		201	1003, 1014, 1025, 1036, 1047, 1059, 1070, 1081, 1092, 1104, 1115, 1127, 1138, 1150, 1162, 1174, 1185, 1197,
		202	1209, 1221, 1233, 1245, 1258, 1270, 1282, 1294, 1307, 1319, 1332, 1344, 1357, 1370, 1383, 1395, 1408, 1421,
		203	1434, 1447, 1460, 1474, 1487, 1500, 1514, 1527, 1540, 1554, 1568, 1581, 1595, 1609, 1622, 1636, 1650, 1664,
		204	1678, 1692, 1707, 1721, 1735, 1749, 1764, 1778, 1793, 1807, 1822, 1837, 1852, 1866, 1881, 1896, 1911, 1926,
		205	1941, 1956, 1972, 1987, 2002, 2018, 2033, 2048, 2064, 2080, 2095, 2111, 2127, 2143, 2159, 2174, 2190, 2207,
		206	2223, 2239, 2255, 2271, 2288, 2304, 2321, 2337, 2354, 2370, 2387, 2404, 2420, 2437, 2454, 2471, 2488, 2505,
		207	2522, 2540, 2557, 2574, 2592, 2609, 2626, 2644, 2662, 2679, 2697, 2715, 2732, 2750, 2768, 2786, 2804, 2822,
		208	2840, 2859, 2877, 2895, 2913, 2932, 2950, 2969, 2987, 3006, 3025, 3043, 3062, 3081, 3100, 3119, 3138, 3157,
		209	3176, 3195, 3214, 3234, 3253, 3272, 3292, 3311, 3331, 3351, 3370, 3390, 3410, 3430, 3449, 3469, 3489, 3509,
		210	3529, 3550, 3570, 3590, 3610, 3631, 3651, 3672, 3692, 3713, 3733, 3754, 3775, 3795, 3816, 3837, 3858, 3879,
		211	3900, 3921, 3942, 3964, 3985, 4006, 4027, 4049, 4070, 4092, 4113, 4135, 4157, 4178, 4200, 4222, 4244, 4266,
		212	4288, 4310, 4332, 4354, 4376, 4399, 4421, 4443, 4466, 4488, 4510, 4533, 4556, 4578, 4601, 4624, 4647, 4669,
		213	4692, 4715, 4738, 4761, 4784, 4808, 4831, 4854, 4877, 4901, 4924, 4948, 4971, 4995, 5018, 5042, 5066, 5089,
		214	5113, 5137, 5161, 5185, 5209, 5233, 5257, 5281, 5306, 5330, 5354, 5378, 5403, 5427, 5452, 5476, 5501, 5526,
		215	5550, 5575, 5600, 5625, 5650, 5675, 5700, 5725, 5750, 5775, 5800, 5825, 5851, 5876, 5901, 5927, 5952, 5978,
		216	6003, 6029, 6055, 6080, 6106, 6132, 6158, 6184, 6210, 6236, 6262, 6288, 6314, 6340, 6367, 6393, 6419, 6446,
		217	6472, 6499, 6525, 6552, 6578, 6605, 6632, 6658, 6685, 6712, 6739, 6766, 6793, 6820, 6847, 6874, 6901, 6929,
		218	6956, 6983, 7011, 7038, 7066, 7093, 7121, 7148, 7176, 7204, 7231, 7259, 7287, 7315, 7343, 7371, 7399, 7427,
		219	7455, 7483, 7511, 7539, 7568, 7596, 7624, 7653, 7681, 7710, 7738, 7767, 7796, 7824, 7853, 7882, 7911, 7940,
		220	7968, 7997, 8026, 8055, 8085, 8114, 8143, 8172, 8201, 8231, 8260, 8289, 8319, 8348, 8378, 8407, 8437, 8467,
		221	8496, 8526, 8556, 8586, 8616, 8646, 8675, 8705, 8736, 8766, 8796, 8826, 8856, 8886, 8917, 8947, 8977, 9008,
		222	9038, 9069, 9099, 9130, 9161, 9191, 9222, 9253, 9284, 9315, 9345, 9376, 9407, 9438, 9469, 9501, 9532, 9563,
		223	9594, 9625, 9657, 9688, 9719, 9751, 9782, 9814, 9845, 9877, 9909, 9940, 9972, 10004, 10036, 10068, 10099,
		224	10131, 10163, 10195, 10227, 10259, 10292, 10324, 10356, 10388, 10421, 10453, 10485, 10518, 10550, 10583,
		225	10615, 10648, 10680, 10713, 10746, 10778, 10811, 10844, 10877, 10910, 10943, 10976, 11009, 11042, 11075,
		226	11108, 11141, 11174, 11208, 11241, 11274, 11308, 11341, 11374, 11408, 11441, 11475, 11509, 11542, 11576,
		227	11610, 11643, 11677, 11711, 11745, 11779, 11813, 11847, 11881, 11915, 11949, 11983, 12017, 12051, 12085,
		228	12120, 12154, 12188, 12223, 12257, 12292, 12326, 12361, 12395, 12430, 12465, 12499, 12534, 12569, 12604,
		229	12638, 12673, 12708, 12743, 12778, 12813, 12848, 12883, 12918, 12954, 12989, 13024, 13059, 13095, 13130,
		230	13165, 13201, 13236, 13272, 13307, 13343, 13379, 13414, 13450, 13486, 13521, 13557, 13593, 13629, 13665,
		231	13701, 13736, 13772, 13809, 13845, 13881, 13917, 13953, 13989, 14025, 14062, 14098, 14134, 14171, 14207,
		232	14244, 14280, 14317, 14353, 14390, 14426, 14463, 14500, 14536, 14573, 14610, 14647, 14684, 14721, 14758,
		233	14794, 14831, 14869, 14906, 14943, 14980, 15017, 15054, 15091, 15129, 15166, 15203, 15241, 15278, 15316,
		234	15353, 15391, 15428, 15466, 15503, 15541, 15579, 15616, 15654, 15692, 15730, 15767, 15805, 15843, 15881,
		235	15919, 15957, 15995, 16033, 16071, 16109, 16147, 16186, 16224, 16262, 16300, 16339, 16377, 16416, 16454,
		236	16492, 16531, 16569, 16608, 16646, 16685, 16724, 16762, 16801, 16840, 16879, 16917, 16956, 16995, 17034,
		237	17073, 17112, 17151, 17190, 17229, 17268, 17307, 17346, 17385, 17425, 17464, 17503, 17542, 17582, 17621,
		238	17660, 17700, 17739, 17779, 17818, 17858, 17897, 17937, 17977, 18016, 18056, 18096, 18135, 18175, 18215,
		239	18255, 18295, 18335, 18375, 18415, 18455, 18495, 18535, 18575, 18615, 18655, 18695, 18735, 18776, 18816,
		240	18856, 18896, 18937, 18977, 19017, 19058, 19098, 19139, 19179, 19220, 19260, 19301, 19342, 19382, 19423,
		241	19464, 19505, 19545, 19586, 19627, 19668, 19709, 19750, 19791, 19832, 19873, 19914, 19955, 19996, 20037,
		242	20078, 20119, 20160, 20202, 20243, 20284, 20325, 20367, 20408, 20450, 20491, 20532, 20574, 20615, 20657,
		243	20699, 20740, 20782, 20823, 20865, 20907, 20949, 20990, 21032, 21074, 21116, 21158, 21199, 21241, 21283,
		244	21325, 21367, 21409, 21451, 21493, 21536, 21578, 21620, 21662, 21704, 21746, 21789, 21831, 21873, 21916,
		245	21958, 22000, 22043, 22085, 22128, 22170, 22213, 22255, 22298, 22341, 22383, 22426, 22468, 22511, 22554,
		246	22597, 22639, 22682, 22725, 22768, 22811, 22854, 22897, 22940, 22983, 23026, 23069, 23112, 23155, 23198,
		247	23241, 23284, 23328, 23371, 23414, 23457, 23501, 23544, 23587, 23631, 23674, 23717, 23761, 23804, 23848,
		248	23891, 23935, 23978, 24022, 24066, 24109, 24153, 24197, 24240, 24284, 24328, 24372, 24415, 24459, 24503,
		249	24547, 24591, 24635, 24679, 24723, 24767, 24811, 24855, 24899, 24943, 24987, 25031, 25075, 25120, 25164,
		250	25208, 25252, 25297, 25341, 25385, 25430, 25474, 25518, 25563, 25607, 25652, 25696, 25741, 25785, 25830,
		251	25874, 25919, 25964, 26008, 26053, 26098, 26142, 26187, 26232, 26277, 26322, 26366, 26411, 26456, 26501,
		252	26546, 26591, 26636, 26681, 26726, 26771, 26816, 26861, 26906, 26951, 26997, 27042, 27087, 27132 };
		253
		254	// -------------------------------------------------------------------------------------------
		255
379	daniel-mar	256	extern uint8_t slider[];
301	daniel-mar	257	extern value_type cell[], var[];
500	daniel-mar	258	extern unsigned char* image_ptr;
259	daniel-mar	259
294	daniel-mar	260	// -------------------------------------------------------------------------------------------
		261
500	daniel-mar	262	void init_trigtab() {
297	daniel-mar	263	#ifdef PARSERTEST
302	daniel-mar	264	return;
297	daniel-mar	265	#else
259	daniel-mar	266	int i;
500	daniel-mar	267
		268	if (gdata == NULL) return; // should not happen
		269
		270	if (gdata->costab == NULL) {
		271	gdata->costab = (double)malloc(sizeof(double) COSTABSIZE);
		272	if (gdata->costab) {
		273	for (i = 0; i < COSTABSIZE; ++i) {
		274	gdata->costab[i] = cos(FFANGLE(i));
		275	}
		276	}
259	daniel-mar	277	}
500	daniel-mar	278
		279	if (gdata->tantab == NULL) {
		280	gdata->tantab = (double)malloc(sizeof(double) TANTABSIZE);
		281	if (gdata->tantab) {
		282	for (i = 0; i < TANTABSIZE; ++i) {
		283	if (i >= TANTABSIZE / 2) {
		284	/* the last '-1' in the expression '512-i-1' is for FilterFactory compatibility, and to avoid the undefined pi/2 area */
		285	gdata->tantab[i] = -gdata->tantab[TANTABSIZE - i - 1];
		286	}
		287	else {
		288	gdata->tantab[i] = tan(FFANGLE(i));
		289	}
		290	}
259	daniel-mar	291	}
		292	}
297	daniel-mar	293	#endif
259	daniel-mar	294	}
		295
294	daniel-mar	296	// -------------------------------------------------------------------------------------------
		297
259	daniel-mar	298	/* Channel z for the input pixel at coordinates x,y.
		299	* Coordinates are relative to the input image data (pb->inData) */
500	daniel-mar	300	static value_type rawsrc(value_type x, value_type y, value_type z) {
297	daniel-mar	301	#ifdef PARSERTEST
		302	return 0;
		303	#else
259	daniel-mar	304	if (HAS_BIG_DOC(gpb)) {
		305	if (x < BIGDOC_IN_RECT(gpb).left)
		306	x = BIGDOC_IN_RECT(gpb).left;
		307	else if (x >= BIGDOC_IN_RECT(gpb).right)
		308	x = BIGDOC_IN_RECT(gpb).right - 1;
		309	if (y < BIGDOC_IN_RECT(gpb).top)
		310	y = BIGDOC_IN_RECT(gpb).top;
		311	else if (y >= BIGDOC_IN_RECT(gpb).bottom)
		312	y = BIGDOC_IN_RECT(gpb).bottom - 1;
		313	return ((unsigned char)gpb->inData)[(long)gpb->inRowBytes (y - BIGDOC_IN_RECT(gpb).top)
		314	+ (long)nplanes * (x - BIGDOC_IN_RECT(gpb).left) + z];
		315	} else {
		316	if (x < IN_RECT(gpb).left)
		317	x = IN_RECT(gpb).left;
		318	else if (x >= IN_RECT(gpb).right)
		319	x = IN_RECT(gpb).right - 1;
		320	if (y < IN_RECT(gpb).top)
		321	y = IN_RECT(gpb).top;
		322	else if (y >= IN_RECT(gpb).bottom)
		323	y = IN_RECT(gpb).bottom - 1;
		324	return ((unsigned char)gpb->inData)[(long)gpb->inRowBytes (y - IN_RECT(gpb).top)
		325	+ (long)nplanes * (x - IN_RECT(gpb).left) + z];
		326	}
297	daniel-mar	327	#endif
259	daniel-mar	328	}
		329
294	daniel-mar	330	// -------------------------------------------------------------------------------------------
		331
259	daniel-mar	332	/* src(x,y,z) Channel z for the pixel at coordinates x,y.
		333	* Coordinates are relative to filtered area (selection). */
294	daniel-mar	334
500	daniel-mar	335	value_type ff_src(value_type x, value_type y, value_type z) {
297	daniel-mar	336	#ifdef PARSERTEST
259	daniel-mar	337	return 0;
297	daniel-mar	338	#else
500	daniel-mar	339	if (x < 0)
259	daniel-mar	340	x = 0;
500	daniel-mar	341	else if (x >= var['X'])
		342	x = var['X'] - 1;
		343	if (y < 0)
259	daniel-mar	344	y = 0;
500	daniel-mar	345	else if (y >= var['Y'])
		346	y = var['Y'] - 1;
259	daniel-mar	347	return z >= 0 && z < var['Z'] ?
500	daniel-mar	348	image_ptr[(long)gpb->inRowBytes * y + (long)nplanes * x + z] : 0;
297	daniel-mar	349	#endif
259	daniel-mar	350	}
		351
294	daniel-mar	352	// -------------------------------------------------------------------------------------------
		353
295	daniel-mar	354	/* r2x(d,m) x displacement of the pixel m units away, at an angle of d,
		355	from an arbitrary center */
		356
		357	value_type factory_r2x(value_type d, value_type m) {
		358	// https://misc.daniel-marschall.de/projects/filter_factory/function_r2x.html
297	daniel-mar	359	#ifdef PARSERTEST
		360	return 0;
		361	#else
295	daniel-mar	362	int eax = m;
		363	int ebx = d;
		364	ebx &= 1023;
		365	ebx = FACTORY_COS_LOOKUP[ebx];
		366	return (((int64_t)eax * (int64_t)ebx) + 8191) >> 14;
297	daniel-mar	367	#endif
295	daniel-mar	368	}
		369
		370	value_type foundry_r2x(value_type d, value_type m) {
297	daniel-mar	371	#ifdef PARSERTEST
		372	return 0;
		373	#else
500	daniel-mar	374	return (value_type)RINT(m * gdata->costab[abs(d) % COSTABSIZE]);
297	daniel-mar	375	#endif
295	daniel-mar	376	}
		377
		378	value_type ff_r2x(value_type d, value_type m) {
297	daniel-mar	379	#ifdef use_filterfactory_implementation_r2x
295	daniel-mar	380	return factory_r2x(d, m);
297	daniel-mar	381	#else
295	daniel-mar	382	return foundry_r2x(d, m);
297	daniel-mar	383	#endif
295	daniel-mar	384	}
		385
		386	// -------------------------------------------------------------------------------------------
		387
		388	/* r2y(d,m) y displacement of the pixel m units away, at an angle of d,
		389	from an arbitrary center */
		390
		391	value_type factory_r2y(value_type d, value_type m) {
297	daniel-mar	392	#ifdef PARSERTEST
		393	return 0;
		394	#else
295	daniel-mar	395	// https://misc.daniel-marschall.de/projects/filter_factory/function_r2y.html
		396	return factory_r2x(d - 256, m);
297	daniel-mar	397	#endif
295	daniel-mar	398	}
		399
		400	value_type foundry_r2y(value_type d, value_type m) {
297	daniel-mar	401	#ifdef PARSERTEST
		402	return 0;
		403	#else
500	daniel-mar	404	return (value_type)RINT(m * gdata->costab[abs(d - 256) % COSTABSIZE]);
297	daniel-mar	405	#endif
295	daniel-mar	406	}
		407
		408	value_type ff_r2y(value_type d, value_type m) {
297	daniel-mar	409	#ifdef use_filterfactory_implementation_r2y
295	daniel-mar	410	return factory_r2y(d, m);
297	daniel-mar	411	#else
295	daniel-mar	412	return foundry_r2y(d, m);
297	daniel-mar	413	#endif
295	daniel-mar	414	}
		415
		416	// -------------------------------------------------------------------------------------------
		417
259	daniel-mar	418	/* rad(d,m,z) Channel z in the source image, which is m units away,
		419	at an angle of d, from the center of the image */
294	daniel-mar	420
		421	value_type factory_rad(value_type d, value_type m, value_type z) {
297	daniel-mar	422	#ifdef PARSERTEST
		423	return 0;
		424	#else
294	daniel-mar	425	// https://misc.daniel-marschall.de/projects/filter_factory/function_rad.html
		426
		427	const int xmin = 0;
		428	const int ymin = 0;
		429	const int zmin = 0;
		430
		431	int eax, ebx, ecx;
		432
		433	ebx = FACTORY_COS_LOOKUP[d & 1023];
		434	eax = (((int64_t)m * (int64_t)ebx) + 8191) >> 14;
		435	ecx = ((var['X'] - xmin) >> 1) + eax;
		436	if (ecx < 0) {
		437	ecx = 0;
		438	}
		439	else {
		440	eax = var['X'];
		441	if (ecx >= eax) {
		442	ecx = eax - 1;
		443	}
		444	}
		445
		446	ebx = FACTORY_COS_LOOKUP[(d - 256) & 1023];
		447	eax = (((int64_t)m * (int64_t)ebx) + 8191) >> 14;
		448	ebx = ((var['Y'] - ymin) >> 1) + eax;
		449	if (ebx < 0) {
		450	ebx = 0;
		451	}
		452	else {
		453	eax = var['Y'];
		454	if (ebx >= eax) {
		455	ebx = eax - 1;
		456	}
		457	}
		458
		459	// Now return pixel [x=ecx,y=ebx,z=esi] from the source image!
		460	//return ff_src(ecx, ebx, z);
		461	ebx *= gpb->inRowBytes;
		462	ecx *= var['Z'] - zmin;
500	daniel-mar	463	return image_ptr[z + ebx + ecx];
297	daniel-mar	464	#endif
294	daniel-mar	465	}
		466
		467	value_type foundry_rad(value_type d, value_type m, value_type z) {
297	daniel-mar	468	#ifdef PARSERTEST
		469	return 0;
		470	#else
294	daniel-mar	471	return ff_src(foundry_r2x(d, m) + var['X'] / 2, foundry_r2y(d, m) + var['Y'] / 2, z);
297	daniel-mar	472	#endif
294	daniel-mar	473	}
		474
500	daniel-mar	475	value_type ff_rad(value_type d, value_type m, value_type z) {
297	daniel-mar	476	#ifdef use_filterfactory_implementation_rad
294	daniel-mar	477	return factory_rad(d, m, z);
297	daniel-mar	478	#else
294	daniel-mar	479	return foundry_rad(d, m, z);
297	daniel-mar	480	#endif
259	daniel-mar	481	}
		482
294	daniel-mar	483	// -------------------------------------------------------------------------------------------
		484
259	daniel-mar	485	/* ctl(i) Value of slider i, where i is an integer between 0 and 7, inclusive */
500	daniel-mar	486	value_type ff_ctl(value_type i) {
297	daniel-mar	487	#ifdef PARSERTEST
		488	return 0;
		489	#else
500	daniel-mar	490	return i >= 0 && i <= 7 ? slider[i] : 0;
297	daniel-mar	491	#endif
259	daniel-mar	492	}
		493
294	daniel-mar	494	// -------------------------------------------------------------------------------------------
		495
259	daniel-mar	496	/* val(i,a,b) Value of slider i, mapped onto the range a to b */
500	daniel-mar	497	value_type ff_val(value_type i, value_type a, value_type b) {
297	daniel-mar	498	#ifdef PARSERTEST
		499	return 0;
		500	#else
500	daniel-mar	501	return ((long)ff_ctl(i) * (b - a)) / 255 + a;
297	daniel-mar	502	#endif
259	daniel-mar	503	}
		504
294	daniel-mar	505	// -------------------------------------------------------------------------------------------
		506
259	daniel-mar	507	/* map(i,n) Item n from mapping table i, where i is an integer between
		508
		509	inclusive */
500	daniel-mar	510	value_type ff_map(value_type i, value_type n) {
297	daniel-mar	511	#ifdef PARSERTEST
		512	return 0;
		513	#else
500	daniel-mar	514	value_type H, L;
		515	const int i2 = i << 1;
		516
		517	// This is how Filter Factory for Windows implements it:
		518	if (i < 0) return 0;
		519	if (i > 3) return 0;
		520	H = slider[i2]; // ctl(2i)
		521	L = slider[i2 + 1]; // ctl(2i+1)
		522	if (n < 0) n = 0;
		523	if (n > 255) n = 255; // Note: MacFF probably does "return 255" if n>255 (see testcases/map1_factory_win.png)
		524
		525	if (H == L) {
		526	// This is undocumented in Filter Factory! (Taken from Windows implementation)
		527	if (n < H) return 0;
		528	if (n >= L) return 255;
		529	} else if (L > H) {
		530	// This is undocumented in Filter Factory! (Taken from Windows implementation)
		531	if (n <= H) return 255;
		532	if (n >= L) return 0;
		533	} else {
		534	if (n <= L) return 0;
		535	if (n >= H) return 255;
		536	}
		537	return (n - L) * 255 / (H - L);
		538
		539	// This is the original formula used by GIMP User Filter v0.8 (uf-pcode.h).
		540	// It was used in Filter Foundry till version 1.7.0.16, inclusive.
297	daniel-mar	541	/*
500	daniel-mar	542	value_type H = ff_ctl(i * 2);
		543	value_type L = ff_ctl(i * 2 + 1);
		544	return abs(((long)n * (L - H) / 255) + H);
489	daniel-mar	545	*/
297	daniel-mar	546	#endif
500	daniel-mar	547
259	daniel-mar	548	}
		549
294	daniel-mar	550	// -------------------------------------------------------------------------------------------
		551
259	daniel-mar	552	/* min(a,b) Lesser of a and b */
500	daniel-mar	553	value_type ff_min(value_type a, value_type b) {
297	daniel-mar	554	#ifdef PARSERTEST
		555	return 0;
		556	#else
259	daniel-mar	557	return a < b ? a : b;
297	daniel-mar	558	#endif
259	daniel-mar	559	}
		560
294	daniel-mar	561	// -------------------------------------------------------------------------------------------
		562
259	daniel-mar	563	/* max(a,b) Greater of a and b */
500	daniel-mar	564	value_type ff_max(value_type a, value_type b) {
297	daniel-mar	565	#ifdef PARSERTEST
		566	return 0;
		567	#else
259	daniel-mar	568	return a > b ? a : b;
297	daniel-mar	569	#endif
259	daniel-mar	570	}
		571
294	daniel-mar	572	// -------------------------------------------------------------------------------------------
		573
259	daniel-mar	574	/* abs(a) Absolute value of a */
500	daniel-mar	575	value_type ff_abs(value_type a) {
297	daniel-mar	576	#ifdef PARSERTEST
		577	return 0;
		578	#else
259	daniel-mar	579	return abs(a);
297	daniel-mar	580	#endif
259	daniel-mar	581	}
		582
294	daniel-mar	583	// -------------------------------------------------------------------------------------------
		584
259	daniel-mar	585	/* add(a,b,c) Sum of a and b, or c, whichever is lesser */
500	daniel-mar	586	value_type ff_add(value_type a, value_type b, value_type c) {
297	daniel-mar	587	#ifdef PARSERTEST
		588	return 0;
		589	#else
500	daniel-mar	590	return ff_min(a + b, c);
297	daniel-mar	591	#endif
259	daniel-mar	592	}
		593
294	daniel-mar	594	// -------------------------------------------------------------------------------------------
		595
259	daniel-mar	596	/* sub(a,b,c) Difference of a and b, or c, whichever is greater */
500	daniel-mar	597	value_type ff_sub(value_type a, value_type b, value_type c) {
297	daniel-mar	598	#ifdef PARSERTEST
		599	return 0;
		600	#else
500	daniel-mar	601	return ff_max(ff_dif(a, b), c);
297	daniel-mar	602	#endif
259	daniel-mar	603	}
		604
294	daniel-mar	605	// -------------------------------------------------------------------------------------------
		606
259	daniel-mar	607	/* dif(a,b) Absolute value of the difference of a and b */
500	daniel-mar	608	value_type ff_dif(value_type a, value_type b) {
297	daniel-mar	609	#ifdef PARSERTEST
		610	return 0;
		611	#else
500	daniel-mar	612	return abs(a - b);
297	daniel-mar	613	#endif
259	daniel-mar	614	}
		615
294	daniel-mar	616	// -------------------------------------------------------------------------------------------
		617
		618	/* rnd(a,b) Random number between a and b, inclusive */
		619
290	daniel-mar	620	struct factoryRngState {
291	daniel-mar	621	uint16_t index1;
		622	uint16_t index2;
		623	uint32_t seedTable[56];
		624	uint32_t seed;
		625	uint32_t seedSave;
		626	} gFactoryRngState;
286	daniel-mar	627
290	daniel-mar	628	void factory_fill_rnd_lookup(uint32_t seed, struct factoryRngState* state) {
297	daniel-mar	629	#ifdef PARSERTEST
302	daniel-mar	630	return;
297	daniel-mar	631	#else
290	daniel-mar	632	// Algorithm of Filter Factory
		633	// Filter Factory uses Donald E.Knuth's subtractive
		634	// random number generator algorithm ("ran3"), which has been published
		635	// in Page 283 of "The Art of Computer Programming, volume 2: Seminumerical Algorithms",
		636	// Addison-Wesley, Reading, MA, second edition, 1981.
		637	// https://www.cec.uchile.cl/cinetica/pcordero/MC_libros/NumericalRecipesinC.pdf (PDF Page 307)
286	daniel-mar	638
290	daniel-mar	639	long mj, mk;
		640	int i, ii, k;
		641
		642	// 161803398 = 1.61803398 * 10^8 ~= phi * 10^8
		643	mj = 161803398 - (seed & 0x7fff);
291	daniel-mar	644	state->seedTable[55] = mj;
290	daniel-mar	645
		646	mk = 1;
		647	ii = 0;
500	daniel-mar	648	for (i = 1; i <= 54; ++i) {
290	daniel-mar	649	if ((ii += 21) >= 55) ii -= 55; // ii = (21*i)%55;
291	daniel-mar	650	state->seedTable[ii] = mk;
290	daniel-mar	651	mk = mj - mk;
291	daniel-mar	652	mj = state->seedTable[ii];
290	daniel-mar	653	}
		654
500	daniel-mar	655	for (k = 1; k <= 4; ++k) {
290	daniel-mar	656	ii = 30;
500	daniel-mar	657	for (i = 1; i <= 55; ++i) {
290	daniel-mar	658	if ((ii += 1) >= 55) ii -= 55;
291	daniel-mar	659	state->seedTable[i] -= state->seedTable[1 + ii]; // 1 + (i+30)%55
290	daniel-mar	660	}
		661	}
		662
291	daniel-mar	663	state->seedSave = seed;
290	daniel-mar	664
		665	return;
297	daniel-mar	666	#endif
290	daniel-mar	667	}
		668
		669	uint32_t factory_rnd(uint32_t a, uint32_t b, struct factoryRngState* state) {
297	daniel-mar	670	#ifdef PARSERTEST
		671	return 0;
		672	#else
289	daniel-mar	673	uint32_t mj; // Note: This must be "uint32_t". With "long" (as described by Knuth), it won't match FilterFactory's algorithm
		674	int range;
286	daniel-mar	675
291	daniel-mar	676	if (state->seed != state->seedSave) {
288	daniel-mar	677	// (Intentional) behavior of Filter Foundry
291	daniel-mar	678	factory_fill_rnd_lookup(state->seed, &gFactoryRngState);
		679	state->index1 = 0;
		680	state->index2 = 31;
288	daniel-mar	681	}
		682
		683	// Algorithm of Filter Factory
289	daniel-mar	684	// Filter Factory uses Donald E.Knuth's subtractive
		685	// random number generator algorithm ("ran3"), which has been published
		686	// in Page 283 of "The Art of Computer Programming, volume 2: Seminumerical Algorithms",
		687	// Addison-Wesley, Reading, MA, second edition, 1981.
		688	// https://www.cec.uchile.cl/cinetica/pcordero/MC_libros/NumericalRecipesinC.pdf (PDF Page 307)
288	daniel-mar	689
291	daniel-mar	690	if (++state->index1 == 56) state->index1 = 1;
		691	if (++state->index2 == 56) state->index2 = 1;
286	daniel-mar	692
291	daniel-mar	693	mj = state->seedTable[state->index1] -
		694	state->seedTable[state->index2];
		695	state->seedTable[state->index1] = mj;
286	daniel-mar	696
289	daniel-mar	697	// This is Filter Factory specific:
290	daniel-mar	698	// Reduce result into interval [a..b] by applying (a + (mj % (b - a + 1))
		699	// Try to avoid modulo in order to increase performance
		700	range = b - a;
		701	if (range < 0) return 0;
		702	switch (range) {
500	daniel-mar	703	case 255:
		704	return a + (mj & 0xFF);
		705	case 127:
		706	return a + (mj & 0x7F);
		707	case 63:
		708	return a + (mj & 0x3F);
		709	case 31:
		710	return a + (mj & 0x1F);
		711	case 15:
		712	return a + (mj & 0xF);
		713	case 7:
		714	return a + (mj & 0x7);
		715	case 3:
		716	return a + (mj & 0x3);
		717	case 1:
		718	return a + (mj & 0x1);
		719	case 0:
		720	return a;
		721	default:
		722	return a + (mj % (range + 1));
289	daniel-mar	723	}
297	daniel-mar	724	#endif
286	daniel-mar	725	}
		726
294	daniel-mar	727	value_type foundry_rnd(value_type a, value_type b) {
297	daniel-mar	728	#ifdef PARSERTEST
		729	return 0;
		730	#else
500	daniel-mar	731	return (int)((abs(a - b) + 1) * (rand() / (RAND_MAX + 1.))) + ff_min(a, b);
294	daniel-mar	732	// return ((unsigned)rand() % (ff_dif(a,b)+1)) + ff_min(a,b);
297	daniel-mar	733	#endif
294	daniel-mar	734	}
		735
500	daniel-mar	736	value_type ff_rnd(value_type a, value_type b) {
297	daniel-mar	737	#ifdef use_filterfactory_implementation_rnd
294	daniel-mar	738	return factory_rnd(a, b, &gFactoryRngState);
297	daniel-mar	739	#else
294	daniel-mar	740	return foundry_rnd(a, b);
297	daniel-mar	741	#endif
294	daniel-mar	742	}
		743
		744	// -------------------------------------------------------------------------------------------
		745
		746	/* rst(i) sets a random seed and returns 0. (undocumented Filter Factory function).
		747	Added by DM, 18 Dec 2018 */
		748
290	daniel-mar	749	int32_t factory_rst(uint32_t seed, struct factoryRngState* state) {
297	daniel-mar	750	#ifdef PARSERTEST
		751	return 0;
		752	#else
294	daniel-mar	753	// Attention: This is NOT the FilterFactory rst() implementation!
		754
290	daniel-mar	755	// We implement rst(i) completely differently in Filter Foundry:
		756	// Every call of rst() will renew the lookup table.
		757	// In Filter Factory, there are strange/buggy things going
		758	// on: rst(i) only sets a seed and the lookup table is renewed
		759	// at the NEXT invocation of the filter. Furthermore, in FilterFactory,
		760	// the state is not reset between invocations, therefore, the preview image
		761	// will influence the PRNG state of the final image...
		762	// More information at "Filter Factory Compatibility.md"
286	daniel-mar	763
291	daniel-mar	764	state->seed = seed;
286	daniel-mar	765
290	daniel-mar	766	// Force renewal of the PRNG state in the next rnd(a,b) call.
		767	// This allows us to use:
		768	// (x==0?rst(1):0), rnd(0,255)
		769	// But it is slower and this won't work anymore:
		770	// rst(0), rnd(0,255)
294	daniel-mar	771	state->seedSave = seed + 1;
286	daniel-mar	772
287	daniel-mar	773	return 0;
297	daniel-mar	774	#endif
286	daniel-mar	775	}
		776
294	daniel-mar	777	value_type foundry_rst(value_type seed) {
297	daniel-mar	778	#ifdef PARSERTEST
		779	return 0;
		780	#else
294	daniel-mar	781	srand(seed);
		782	return 0;
297	daniel-mar	783	#endif
287	daniel-mar	784	}
		785
294	daniel-mar	786	value_type ff_rst(value_type seed) {
297	daniel-mar	787	#ifdef use_filterfactory_implementation_rnd
294	daniel-mar	788	return factory_rst(seed, &gFactoryRngState);
297	daniel-mar	789	#else
294	daniel-mar	790	return foundry_rst(seed);
297	daniel-mar	791	#endif
259	daniel-mar	792	}
		793
294	daniel-mar	794	// -------------------------------------------------------------------------------------------
		795
298	daniel-mar	796	void factory_initialize_rnd_variables() {
		797	#ifdef PARSERTEST
302	daniel-mar	798	return;
298	daniel-mar	799	#else
		800	gFactoryRngState.seed = 0; // default seed
		801	gFactoryRngState.seedSave = gFactoryRngState.seed + 1; // force rnd() to call factory_fill_rnd_lookup()
		802	#endif
		803	}
		804
		805	void foundry_initialize_rnd_variables() {
		806	#ifdef PARSERTEST
302	daniel-mar	807	return;
298	daniel-mar	808	#else
		809	foundry_rst(691204);
		810	#endif
		811	}
		812
		813	void initialize_rnd_variables() {
		814	#ifdef use_filterfactory_implementation_rnd
		815	factory_initialize_rnd_variables();
		816	#else
		817	foundry_initialize_rnd_variables();
		818	#endif
		819	}
		820
		821	// -------------------------------------------------------------------------------------------
		822
259	daniel-mar	823	/* mix(a,b,n,d) Mixture of a and b by fraction n/d, an/d+b(d-n)/d */
500	daniel-mar	824	value_type ff_mix(value_type a, value_type b, value_type n, value_type d) {
297	daniel-mar	825	#ifdef PARSERTEST
		826	return 0;
		827	#else
500	daniel-mar	828	return d ? ((long)a * n) / d + ((long)b * (d - n)) / d : 0;
297	daniel-mar	829	#endif
259	daniel-mar	830	}
		831
294	daniel-mar	832	// -------------------------------------------------------------------------------------------
		833
259	daniel-mar	834	/* scl(a,il,ih,ol,oh) Scale a from input range (il to ih)
500	daniel-mar	835	to output range (ol to oh) */
300	daniel-mar	836	value_type ff_scl(value_type a, value_type il, value_type ih,
		837	value_type ol, value_type oh) {
297	daniel-mar	838	#ifdef PARSERTEST
		839	return 0;
		840	#else
300	daniel-mar	841	return ih == il ? 0 : ol + ((long)(oh - ol) * (a - il)) / (ih - il);
297	daniel-mar	842	#endif
259	daniel-mar	843	}
		844
294	daniel-mar	845	// -------------------------------------------------------------------------------------------
		846
300	daniel-mar	847	/* pow(b,e) Calculates the base to the exponent power, that is, b^e. */
		848
		849	value_type ff_pow(value_type b, value_type e) {
		850	#ifdef PARSERTEST
		851	return 0;
		852	#else
301	daniel-mar	853	double a = pow((double)b, (double)e);
		854	if (a - floor(a) >= 0.5)
		855	return (value_type)(floor(a) + 1);
		856	else
		857	return (value_type)(floor(a));
300	daniel-mar	858	#endif
		859	}
		860
		861	// -------------------------------------------------------------------------------------------
		862
294	daniel-mar	863	/* sqr(x) Square root of x */
		864
259	daniel-mar	865	static uint32_t isqrt(uint32_t x) {
297	daniel-mar	866	#ifdef PARSERTEST
		867	return 0;
		868	#else
259	daniel-mar	869	// based on https://gist.github.com/orlp/3481770
		870
		871	static uint32_t lkpSquares[65535];
		872	static int lkpInitialized = 0;
500	daniel-mar	873	const uint32_t* p;
259	daniel-mar	874	int i;
		875
		876	while (lkpInitialized == 1) { /* If other thread is currently creating the lookup table, then wait */ }
		877	if (!lkpInitialized) {
		878	lkpInitialized = 1;
		879	for (i = 0; i < 65535; ++i) {
		880	lkpSquares[i] = i * i;
		881	}
		882	lkpInitialized = 2;
		883	}
		884
		885	p = lkpSquares;
		886
		887	if (p[32768] <= x) p += 32768;
		888	if (p[16384] <= x) p += 16384;
		889	if (p[8192] <= x) p += 8192;
		890	if (p[4096] <= x) p += 4096;
		891	if (p[2048] <= x) p += 2048;
		892	if (p[1024] <= x) p += 1024;
		893	if (p[512] <= x) p += 512;
		894	if (p[256] <= x) p += 256;
		895	if (p[128] <= x) p += 128;
		896	if (p[64] <= x) p += 64;
		897	if (p[32] <= x) p += 32;
		898	if (p[16] <= x) p += 16;
		899	if (p[8] <= x) p += 8;
		900	if (p[4] <= x) p += 4;
		901	if (p[2] <= x) p += 2;
		902	if (p[1] <= x) p += 1;
		903
		904	return (uint32_t)(p - lkpSquares);
297	daniel-mar	905	#endif
259	daniel-mar	906	}
		907
294	daniel-mar	908	value_type factory_sqr(value_type x) {
297	daniel-mar	909	#ifdef PARSERTEST
		910	return 0;
		911	#else
294	daniel-mar	912	// https://misc.daniel-marschall.de/projects/filter_factory/function_sqr.html
		913
295	daniel-mar	914	int eax, ebx, ecx;
		915
		916	ebx = x;
294	daniel-mar	917	if (ebx > 1) {
295	daniel-mar	918	ecx = ebx;
294	daniel-mar	919	ebx = ebx >> 1;
295	daniel-mar	920	eax = 2;
294	daniel-mar	921	while (ebx > eax) {
		922	eax = ecx;
		923	eax /= ebx;
		924	ebx += eax;
		925	ebx = ebx >> 1;
		926	}
		927	}
		928	return ebx;
297	daniel-mar	929	#endif
294	daniel-mar	930	}
		931
		932	value_type foundry_sqr(value_type x) {
297	daniel-mar	933	#ifdef PARSERTEST
		934	return 0;
		935	#else
294	daniel-mar	936	// Note: FilterFactory has sqr(x)=x if x<0 . Here we set sqr(x)=0 for x<0
259	daniel-mar	937	return x < 0 ? 0 : isqrt(x);
297	daniel-mar	938	#endif
259	daniel-mar	939	}
		940
500	daniel-mar	941	value_type ff_sqr(value_type x) {
297	daniel-mar	942	#ifdef use_filterfactory_implementation_sqr
294	daniel-mar	943	return factory_sqr(x);
297	daniel-mar	944	#else
294	daniel-mar	945	return foundry_sqr(x);
297	daniel-mar	946	#endif
294	daniel-mar	947	}
		948
		949	// -------------------------------------------------------------------------------------------
		950
		951	/* cos(x) Cosine function of x, where x is an integer between 0 and
259	daniel-mar	952	1024, inclusive, and the value returned is an integer
		953	between -512 and 512, inclusive (Windows) or -1024 and
		954	1024, inclusive (Mac OS) */
294	daniel-mar	955
		956	value_type factory_cos(value_type x) {
297	daniel-mar	957	#ifdef PARSERTEST
		958	return 0;
		959	#else
294	daniel-mar	960	// https://misc.daniel-marschall.de/projects/filter_factory/function_cos.html
		961	int res;
		962	if (x < 0) x = -x;
		963	x &= 0x3ff; // 1023
		964	res = FACTORY_COS_LOOKUP[x];
		965	return res >= 0 ? (res / 32) : res / 32 - 1;
297	daniel-mar	966	#endif
259	daniel-mar	967	}
		968
294	daniel-mar	969	value_type foundry_cos(value_type x) {
297	daniel-mar	970	#ifdef PARSERTEST
		971	return 0;
		972	#else
294	daniel-mar	973	//return RINT(TRIGAMP*cos(FFANGLE(x)));
500	daniel-mar	974	return (value_type)RINT(TRIGAMP * gdata->costab[abs(x) % COSTABSIZE]);
297	daniel-mar	975	#endif
294	daniel-mar	976	}
		977
500	daniel-mar	978	value_type ff_cos(value_type x) {
297	daniel-mar	979	#ifdef use_filterfactory_implementation_cos
294	daniel-mar	980	return factory_cos(x);
297	daniel-mar	981	#else
294	daniel-mar	982	return foundry_cos(x);
297	daniel-mar	983	#endif
294	daniel-mar	984	}
		985
		986	// -------------------------------------------------------------------------------------------
		987
		988	/* sin(x) Sine function of x, where x is an integer between 0 and
259	daniel-mar	989	1024, inclusive, and the value returned is an integer
		990	between -512 and 512, inclusive (Windows) or -1024 and
		991	1024, inclusive (Mac OS) */
294	daniel-mar	992
		993	value_type factory_sin(value_type x) {
297	daniel-mar	994	#ifdef PARSERTEST
		995	return 0;
		996	#else
294	daniel-mar	997	// https://misc.daniel-marschall.de/projects/filter_factory/function_sin.html
		998	return factory_cos(x - 256);
297	daniel-mar	999	#endif
259	daniel-mar	1000	}
		1001
294	daniel-mar	1002	value_type foundry_sin(value_type x) {
297	daniel-mar	1003	#ifdef PARSERTEST
		1004	return 0;
		1005	#else
294	daniel-mar	1006	//return RINT(TRIGAMP*sin(FFANGLE(x)));
		1007	return foundry_cos(x - 256);
297	daniel-mar	1008	#endif
294	daniel-mar	1009	}
		1010
		1011	value_type ff_sin(value_type x) {
297	daniel-mar	1012	#ifdef use_filterfactory_implementation_sin
294	daniel-mar	1013	return factory_sin(x);
297	daniel-mar	1014	#else
294	daniel-mar	1015	return foundry_sin(x);
297	daniel-mar	1016	#endif
294	daniel-mar	1017	}
		1018
		1019	// -------------------------------------------------------------------------------------------
		1020
259	daniel-mar	1021	/* tan(x) Tangent function of x, where x is an integer
		1022	between -256 and 256, inclusive. Althought the Filter Factory manual
		1023	stated that the return value is bounded to -512 and 512, inclusive (Windows) or
		1024	-1024 and 1024, inclusive (Mac OS), the output is actually NOT bounded! */
294	daniel-mar	1025
		1026	value_type factory_tan(value_type x) {
297	daniel-mar	1027	#ifdef PARSERTEST
		1028	return 0;
		1029	#else
294	daniel-mar	1030	// https://misc.daniel-marschall.de/projects/filter_factory/function_tan.html
		1031	int v1 = x;
		1032	int v2 = v1 < 0 ? -v1 : v1;
		1033	v2 &= 0x3ff; // 1023
		1034	v2 = FACTORY_COS_LOOKUP[v2];
		1035	v1 -= 256;
		1036	if (v1 < 0) v1 = -v1;
		1037	v1 &= 0x3ff; // 1023
		1038	v1 = FACTORY_COS_LOOKUP[v1];
		1039	if (v2 == 0) return 0;
		1040	v1 = v1 << 10; // v1 *= 1024;
		1041	return v1 / v2;
297	daniel-mar	1042	#endif
294	daniel-mar	1043	}
		1044
500	daniel-mar	1045	value_type foundry_tan(value_type x) {
297	daniel-mar	1046	#ifdef PARSERTEST
		1047	return 0;
		1048	#else
259	daniel-mar	1049	// Following filter shows that the Filter Factory manual differs from the implementation.
291	daniel-mar	1050	// R = cos(x) > 1024 \|\| cos(x) < -1024 \|\| cos(-x) > 1024 \|\| cos(-x) < -1024 ? 255 : 0
259	daniel-mar	1051	// G = tan(x) > 1024 \|\| tan(x) < -1024 \|\| tan(-x) > 1024 \|\| tan(-x) < -1024 ? 255 : 0
		1052	// B = sin(x) > 1024 \|\| sin(x) < -1024 \|\| sin(-x) > 1024 \|\| sin(-x) < -1024 ? 255 : 0
		1053	// It outputs green stripes, showing that the output of tan() is not bounded.
		1054	// So, we do it the same way to stay compatible.
		1055	if (x < 0) x--; /* required for Filter Factory compatibility */
		1056	while (x < 0) x += TANTABSIZE;
500	daniel-mar	1057	return (value_type)RINT(2 * TRIGAMP * gdata->tantab[x % TANTABSIZE]); // We need the x2 multiplicator for some reason
297	daniel-mar	1058	#endif
259	daniel-mar	1059	}
		1060
294	daniel-mar	1061	value_type ff_tan(value_type x) {
297	daniel-mar	1062	#ifdef use_filterfactory_implementation_tan
294	daniel-mar	1063	return factory_tan(x);
297	daniel-mar	1064	#else
294	daniel-mar	1065	return foundry_tan(x);
297	daniel-mar	1066	#endif
294	daniel-mar	1067	}
		1068
		1069	// -------------------------------------------------------------------------------------------
		1070
295	daniel-mar	1071	/* c2d(x,y) Angle displacement of the pixel at coordinates x,y */
294	daniel-mar	1072
295	daniel-mar	1073	value_type factory_c2d(value_type x, value_type y) {
297	daniel-mar	1074	#ifdef PARSERTEST
		1075	return 0;
		1076	#else
295	daniel-mar	1077	// https://misc.daniel-marschall.de/projects/filter_factory/function_c2d.html
		1078	int32_t eax, ebx, ecx;
		1079	eax = y;
		1080	ebx = x;
		1081	ecx = 0;
		1082	if (eax < 0) {
		1083	eax = -eax;
		1084	ecx \|= 4/0b0100/;
		1085	}
		1086	if (ebx < 0) {
		1087	ebx = -ebx;
		1088	ecx \|= 3/0b0011/;
		1089	}
		1090	if (eax > ebx) {
		1091	int tmp;
		1092	ecx ^= 1/0b0001/;
		1093	tmp = eax;
		1094	eax = ebx;
		1095	ebx = tmp;
		1096	}
		1097	if (eax > 0) {
		1098	eax = eax << 10;
		1099	eax /= ebx;
		1100	if (eax != 0) {
		1101	eax = (eax & 0xFFFF0000) \| (FACTORY_C2D_LOOKUP[eax - 1] & 0xFFFF);
		1102	eax = eax << 9;
		1103	ebx = 205888; // 205888/65536 == pi
		1104	eax /= ebx;
		1105	}
		1106	}
		1107	if ((ecx & 1/0b0001/) != 0) {
		1108	eax = -eax;
		1109	eax += 256;
		1110	}
		1111	if ((ecx & 2/0b0010/) != 0) {
		1112	eax += 256;
		1113	}
		1114	if ((ecx & 4/0b0100/) != 0) {
		1115	eax = -eax;
		1116	}
		1117	return eax;
297	daniel-mar	1118	#endif
294	daniel-mar	1119	}
		1120
295	daniel-mar	1121	value_type foundry_c2d(value_type x, value_type y) {
297	daniel-mar	1122	#ifdef PARSERTEST
		1123	return 0;
		1124	#else
295	daniel-mar	1125	// Behavior of FilterFoundry <1.7:
		1126	//return foundry_c2d_negated(x,y);
		1127
		1128	// Behavior in FilterFoundry 1.7+: Matches FilterFactory
		1129	return (value_type)RINT(TO_FFANGLE(atan2(y, x)));
297	daniel-mar	1130	#endif
294	daniel-mar	1131	}
		1132
295	daniel-mar	1133	value_type ff_c2d(value_type x, value_type y) {
297	daniel-mar	1134	#ifdef use_filterfactory_implementation_c2d
295	daniel-mar	1135	return factory_c2d(x, y);
297	daniel-mar	1136	#else
295	daniel-mar	1137	return foundry_c2d(x, y);
297	daniel-mar	1138	#endif
259	daniel-mar	1139	}
		1140
294	daniel-mar	1141	// -------------------------------------------------------------------------------------------
		1142
295	daniel-mar	1143	/* c2m(x,y) Magnitude displacement of the pixel at coordinates x,y */
294	daniel-mar	1144
295	daniel-mar	1145	value_type factory_c2m(value_type x, value_type y) {
297	daniel-mar	1146	#ifdef PARSERTEST
		1147	return 0;
		1148	#else
295	daniel-mar	1149	// https://misc.daniel-marschall.de/projects/filter_factory/function_c2m.html
		1150	int32_t eax, ebx;
		1151	ebx = y < 0 ? -y : y;
		1152	eax = x < 0 ? -x : x;
		1153	if (eax == ebx) {
473	daniel-mar	1154	eax = 27146; // 27146/65536 == sqrt(2)-1
295	daniel-mar	1155	}
		1156	else {
		1157	if (eax > ebx) {
		1158	int tmp = eax;
		1159	eax = ebx;
		1160	ebx = tmp;
		1161	}
		1162	eax = eax << 10;
		1163	eax /= ebx;
		1164	eax = FACTORY_C2M_LOOKUP[eax];
		1165	}
		1166	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1167	eax += ebx;
		1168	return eax;
297	daniel-mar	1169	#endif
294	daniel-mar	1170	}
		1171
295	daniel-mar	1172	value_type foundry_c2m(value_type x, value_type y) {
297	daniel-mar	1173	#ifdef PARSERTEST
		1174	return 0;
		1175	#else
295	daniel-mar	1176	return isqrt((long)x * x + (long)y * y);
297	daniel-mar	1177	#endif
294	daniel-mar	1178	}
		1179
295	daniel-mar	1180	value_type ff_c2m(value_type x, value_type y) {
297	daniel-mar	1181	#ifdef use_filterfactory_implementation_c2m
295	daniel-mar	1182	return factory_c2m(x, y);
297	daniel-mar	1183	#else
295	daniel-mar	1184	return foundry_c2m(x, y);
297	daniel-mar	1185	#endif
259	daniel-mar	1186	}
		1187
294	daniel-mar	1188	// -------------------------------------------------------------------------------------------
		1189
295	daniel-mar	1190	/* Direction(angle) of the current pixel from the center of the image,
335	daniel-mar	1191	where d is an integer between -512 and 512 inclusive */
295	daniel-mar	1192
294	daniel-mar	1193	value_type factory_d() {
297	daniel-mar	1194	#ifdef PARSERTEST
		1195	return 0;
		1196	#else
295	daniel-mar	1197	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_d_lowercase.html
		1198
		1199	int eax, ebx, ecx;
296	daniel-mar	1200	const int xmin = 0, ymin = 0;
295	daniel-mar	1201
		1202	eax = -(var['Y'] - ymin) / 2;
		1203	ebx = -(var['X'] - xmin) / 2;
		1204	ecx = 0;
		1205	eax += var['y'];
		1206	if (eax < 0) {
		1207	eax = -eax;
		1208	ecx \|= 4/0b0100/;
		1209	}
		1210	ebx += var['x'];
		1211	if (ebx < 0) {
		1212	ebx = -ebx;
		1213	ecx \|= 3/0b0011/;
		1214	}
		1215	if (eax > ebx) {
		1216	int tmp;
		1217	ecx ^= 1/0b0001/;
		1218	tmp = eax;
		1219	eax = ebx;
		1220	ebx = tmp;
		1221	}
		1222	if (eax > 0) {
		1223	eax = eax << 10;
		1224	eax /= ebx;
		1225	if (eax != 0) { // C2D_LOOKUP[-1] will never be called. Good!
		1226	eax = (eax & 0xFFFF0000) + (FACTORY_C2D_LOOKUP[eax - 1] & 0xFFFF);
		1227	eax = eax << 9;
		1228	ebx = 205888; // 205888/65536 == pi
		1229	eax /= ebx;
		1230	}
		1231	}
		1232	if ((ecx & 1/0b0001/) != 0) {
		1233	eax = -eax;
		1234	eax += 256;
		1235	}
		1236	if ((ecx & 2/0b0010/) != 0) {
		1237	eax += 256;
		1238	}
		1239	if ((ecx & 4/0b0100/) != 0) {
		1240	eax = -eax;
		1241	}
		1242	return eax;
297	daniel-mar	1243	#endif
294	daniel-mar	1244	}
		1245
		1246	value_type foundry_c2d_negated(int x, int y) {
297	daniel-mar	1247	#ifdef PARSERTEST
		1248	return 0;
		1249	#else
294	daniel-mar	1250	return (value_type)RINT(TO_FFANGLE(atan2(-y, -x)));
297	daniel-mar	1251	#endif
294	daniel-mar	1252	}
		1253
		1254	value_type foundry_d() {
297	daniel-mar	1255	#ifdef PARSERTEST
		1256	return 0;
		1257	#else
259	daniel-mar	1258	// NOTE: FilterFactory uses c2d(x,y):=atan2(y,x), but d:=atan2(-y,-x)
		1259	// Due to compatibility reasons, we implement it the same way!
		1260	// Sign of y difference is negated, as we are dealing with top-down coordinates angle is "observed"
294	daniel-mar	1261	int x = var['X'] / 2 - var['x'];
		1262	int y = var['Y'] / 2 - var['y'];
295	daniel-mar	1263	return foundry_c2d_negated(x, y);
297	daniel-mar	1264	#endif
259	daniel-mar	1265	}
		1266
294	daniel-mar	1267	value_type ff_d() {
297	daniel-mar	1268	#ifdef use_filterfactory_implementation_d
491	daniel-mar	1269	// Output range: -512 ... 512
294	daniel-mar	1270	return factory_d();
297	daniel-mar	1271	#else
491	daniel-mar	1272	// Output range: -511 ... 512
294	daniel-mar	1273	return foundry_d();
297	daniel-mar	1274	#endif
294	daniel-mar	1275	}
		1276
		1277	// -------------------------------------------------------------------------------------------
		1278
295	daniel-mar	1279	/* Range of magnitudes with the image, where M is one half the diagonal size of the image */
		1280
294	daniel-mar	1281	value_type factory_M() {
297	daniel-mar	1282	#ifdef PARSERTEST
		1283	return 0;
		1284	#else
295	daniel-mar	1285	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_uppercase.html
		1286
		1287	int eax, ebx;
		1288	const int xmin = 0, ymin = 0;
		1289
		1290	eax = (var['X'] - xmin) >> 1;
		1291	ebx = (var['Y'] - ymin) >> 1;
		1292	if (eax == ebx) {
473	daniel-mar	1293	eax = 27146; // 27146/65536 == sqrt(2)-1
295	daniel-mar	1294	}
		1295	else {
		1296	if (eax > ebx) {
		1297	int tmp = eax;
		1298	eax = ebx;
		1299	ebx = tmp;
		1300	}
		1301	eax = eax << 10;
		1302	eax /= ebx;
		1303	eax = FACTORY_C2M_LOOKUP[eax];
		1304	}
		1305	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1306	eax += ebx;
		1307	return eax;
297	daniel-mar	1308	#endif
294	daniel-mar	1309	}
		1310
		1311	value_type foundry_M() {
297	daniel-mar	1312	#ifdef PARSERTEST
		1313	return 0;
		1314	#else
294	daniel-mar	1315	return foundry_c2m(var['X'], var['Y']) / 2;
297	daniel-mar	1316	#endif
294	daniel-mar	1317	}
		1318
		1319	value_type ff_M() {
297	daniel-mar	1320	#ifdef use_filterfactory_implementation_M
294	daniel-mar	1321	return factory_M();
297	daniel-mar	1322	#else
294	daniel-mar	1323	return foundry_M();
297	daniel-mar	1324	#endif
294	daniel-mar	1325	}
		1326
		1327	// -------------------------------------------------------------------------------------------
		1328
295	daniel-mar	1329	/* Distance (magnitude) from the center of the image to the current pixel */
		1330
294	daniel-mar	1331	value_type factory_m() {
297	daniel-mar	1332	#ifdef PARSERTEST
		1333	return 0;
		1334	#else
295	daniel-mar	1335	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_lowercase.html
		1336
		1337	int eax, ebx;
		1338	const int xmin = 0, ymin = 0;
		1339
		1340	eax = ((xmin - var['X']) >> 1) + var['x'];
		1341	ebx = ((ymin - var['Y']) >> 1) + var['y'];
		1342	eax = eax < 0 ? -eax : eax;
		1343	ebx = ebx < 0 ? -ebx : ebx;
		1344
		1345	if (eax == ebx) {
473	daniel-mar	1346	eax = 27146; // 27146/65536 == sqrt(2)-1
295	daniel-mar	1347	}
		1348	else {
		1349	if (eax > ebx) {
		1350	int tmp = eax;
		1351	eax = ebx;
		1352	ebx = tmp;
		1353	}
		1354	eax = FACTORY_C2M_LOOKUP[1024 * eax / ebx];
		1355	}
		1356	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1357	eax += ebx;
		1358	return eax;
297	daniel-mar	1359	#endif
294	daniel-mar	1360	}
		1361
		1362	value_type foundry_m() {
297	daniel-mar	1363	#ifdef PARSERTEST
		1364	return 0;
		1365	#else
294	daniel-mar	1366	return foundry_c2m(var['X'] / 2 - var['x'], var['Y'] / 2 - var['y']);
297	daniel-mar	1367	#endif
294	daniel-mar	1368	}
		1369
		1370	value_type ff_m() {
297	daniel-mar	1371	#ifdef use_filterfactory_implementation_m
294	daniel-mar	1372	return factory_m();
297	daniel-mar	1373	#else
294	daniel-mar	1374	return foundry_m();
297	daniel-mar	1375	#endif
294	daniel-mar	1376	}
		1377
		1378	// -------------------------------------------------------------------------------------------
		1379
295	daniel-mar	1380	/* "Y" value of the YUV color-space */
		1381
294	daniel-mar	1382	value_type factory_i() {
297	daniel-mar	1383	#ifdef PARSERTEST
		1384	return 0;
		1385	#else
294	daniel-mar	1386	return ((76L * var['r']) + (150L * var['g']) + (29L * var['b'])) / 256; // range: [0..254]
297	daniel-mar	1387	#endif
294	daniel-mar	1388	}
		1389
		1390	value_type foundry_i() {
297	daniel-mar	1391	#ifdef PARSERTEST
		1392	return 0;
		1393	#else
294	daniel-mar	1394	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1395	return ((299L * var['r']) + (587L * var['g']) + (114L * var['b'])) / 1000; // range: [0..255]
297	daniel-mar	1396	#endif
294	daniel-mar	1397	}
		1398
		1399	value_type ff_i() {
297	daniel-mar	1400	#ifdef use_filterfactory_implementation_i
294	daniel-mar	1401	return factory_i();
297	daniel-mar	1402	#else
294	daniel-mar	1403	return foundry_i();
297	daniel-mar	1404	#endif
294	daniel-mar	1405	}
		1406
		1407	// -------------------------------------------------------------------------------------------
		1408
295	daniel-mar	1409	/* "U" value of the YUV color-space */
		1410
294	daniel-mar	1411	value_type factory_u() {
297	daniel-mar	1412	#ifdef PARSERTEST
		1413	return 0;
		1414	#else
294	daniel-mar	1415	return ((-19L * var['r']) + (-37L * var['g']) + (56L * var['b'])) / 256; // range: [-55..55]
297	daniel-mar	1416	#endif
294	daniel-mar	1417	}
		1418
		1419	value_type foundry_u() {
297	daniel-mar	1420	#ifdef PARSERTEST
		1421	return 0;
		1422	#else
294	daniel-mar	1423	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1424	return ((-147407L * var['r']) + (-289391L * var['g']) + (436798L * var['b'])) / 2000000; // range: [-55..55]
297	daniel-mar	1425	#endif
294	daniel-mar	1426	}
		1427
		1428	value_type ff_u() {
297	daniel-mar	1429	#ifdef use_filterfactory_implementation_u
294	daniel-mar	1430	return factory_u();
297	daniel-mar	1431	#else
294	daniel-mar	1432	return foundry_u();
297	daniel-mar	1433	#endif
294	daniel-mar	1434	}
		1435
		1436	// -------------------------------------------------------------------------------------------
		1437
295	daniel-mar	1438	/* "V" value of the YUV color-space */
		1439
294	daniel-mar	1440	value_type factory_v() {
297	daniel-mar	1441	#ifdef PARSERTEST
		1442	return 0;
		1443	#else
294	daniel-mar	1444	return ((78L * var['r']) + (-65L * var['g']) + (-13L * var['b'])) / 256; // range: [-77..77]
297	daniel-mar	1445	#endif
294	daniel-mar	1446	}
		1447
		1448	value_type foundry_v() {
297	daniel-mar	1449	#ifdef PARSERTEST
		1450	return 0;
		1451	#else
294	daniel-mar	1452	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1453	return ((614777L * var['r']) + (-514799L * var['g']) + (-99978L * var['b'])) / 2000000; // range: [-78..78]
297	daniel-mar	1454	#endif
294	daniel-mar	1455	}
		1456
		1457	value_type ff_v() {
297	daniel-mar	1458	#ifdef use_filterfactory_implementation_v
294	daniel-mar	1459	return factory_v();
297	daniel-mar	1460	#else
294	daniel-mar	1461	return foundry_v();
297	daniel-mar	1462	#endif
294	daniel-mar	1463	}
		1464
		1465	// -------------------------------------------------------------------------------------------
		1466
259	daniel-mar	1467	/* get(i) Returns the current cell value at i */
		1468
297	daniel-mar	1469	value_type factory_get(value_type i) {
		1470	#ifdef PARSERTEST
		1471	return 0;
		1472	#else
500	daniel-mar	1473	return i >= 0 && i < NUM_CELLS ? cell[i] : i;
297	daniel-mar	1474	#endif
259	daniel-mar	1475	}
		1476
297	daniel-mar	1477	value_type foundry_get(value_type i) {
		1478	#ifdef PARSERTEST
		1479	return 0;
		1480	#else
		1481	return i >= 0 && i < NUM_CELLS ? cell[i] : 0;
		1482	#endif
		1483	}
		1484
		1485	value_type ff_get(value_type i) {
		1486	#ifdef use_filterfactory_implementation_get
		1487	return factory_get(i);
		1488	#else
		1489	return foundry_get(i);
		1490	#endif
		1491	}
		1492
294	daniel-mar	1493	// -------------------------------------------------------------------------------------------
		1494
259	daniel-mar	1495	/* put(v,i) Puts the new value v into cell i */
500	daniel-mar	1496	value_type ff_put(value_type v, value_type i) {
297	daniel-mar	1497	#ifdef PARSERTEST
		1498	return 0;
		1499	#else
500	daniel-mar	1500	if (i >= 0 && i < NUM_CELLS)
259	daniel-mar	1501	cell[i] = v;
		1502	return v;
297	daniel-mar	1503	#endif
259	daniel-mar	1504	}
		1505
294	daniel-mar	1506	// -------------------------------------------------------------------------------------------
		1507
259	daniel-mar	1508	/* Convolve. Applies a convolution matrix and divides with d. */
500	daniel-mar	1509	value_type ff_cnv(value_type m11, value_type m12, value_type m13,
		1510	value_type m21, value_type m22, value_type m23,
		1511	value_type m31, value_type m32, value_type m33,
		1512	value_type d)
259	daniel-mar	1513	{
297	daniel-mar	1514	#ifdef PARSERTEST
259	daniel-mar	1515	return 0;
297	daniel-mar	1516	#else
259	daniel-mar	1517	long total;
		1518	int x, y, z;
500	daniel-mar	1519	// shift x,y from selection-relative to image relative required by rawsrc()
259	daniel-mar	1520	if (HAS_BIG_DOC(gpb)) {
		1521	x = var['x'] + BIGDOC_FILTER_RECT(gpb).left;
		1522	y = var['y'] + BIGDOC_FILTER_RECT(gpb).top;
		1523	} else {
		1524	x = var['x'] + FILTER_RECT(gpb).left;
		1525	y = var['y'] + FILTER_RECT(gpb).top;
		1526	}
		1527	z = var['z'];
		1528
500	daniel-mar	1529	// rawsrc() will choose the neighbor pixels if x/y goes out-of-bounds (outer border pixels)
		1530	if (z >= 0 && z < var['Z'])
		1531	total = m11 * rawsrc(x - 1, y - 1, z) + m12 * rawsrc(x, y - 1, z) + m13 * rawsrc(x + 1, y - 1, z)
		1532	+ m21 * rawsrc(x - 1, y, z) + m22 * rawsrc(x, y, z) + m23 * rawsrc(x + 1, y, z)
		1533	+ m31 * rawsrc(x - 1, y + 1, z) + m32 * rawsrc(x, y + 1, z) + m33 * rawsrc(x + 1, y + 1, z);
259	daniel-mar	1534	else
500	daniel-mar	1535	total = 0; // ... can this happen at all ?!
259	daniel-mar	1536
500	daniel-mar	1537	return d ? total / d : 0;
297	daniel-mar	1538	#endif
259	daniel-mar	1539	}
		1540
294	daniel-mar	1541	// -------------------------------------------------------------------------------------------
259	daniel-mar	1542
		1543	value_type zero_val = 0;
		1544	value_type one_val = 1;
		1545
335	daniel-mar	1546	value_type min_val_i = 0;
		1547	value_type max_val_i = 255;
		1548	value_type val_I = 255;
304	daniel-mar	1549
335	daniel-mar	1550	#ifdef use_filterfactory_implementation_u_minmax
		1551	value_type min_val_u = 0;
		1552	value_type max_val_u = 255;
304	daniel-mar	1553	#else
335	daniel-mar	1554	value_type min_val_u = -55;
		1555	value_type max_val_u = 55;
304	daniel-mar	1556	#endif
		1557
335	daniel-mar	1558	#ifdef use_filterfactory_implementation_U
		1559	value_type val_U = 255;
		1560	#else
		1561	value_type val_U = 110; // max_val_u - min_val_u;
		1562	#endif
		1563
304	daniel-mar	1564	#ifdef use_filterfactory_implementation_v_minmax
335	daniel-mar	1565	value_type min_val_v = 0;
		1566	value_type max_val_v = 255;
304	daniel-mar	1567	#else
335	daniel-mar	1568	value_type min_val_v = -78;
		1569	value_type max_val_v = 78;
304	daniel-mar	1570	#endif
		1571
335	daniel-mar	1572	#ifdef use_filterfactory_implementation_V
		1573	value_type val_V = 255;
		1574	#else
		1575	value_type val_V = 156; // max_val_v - min_val_v;
		1576	#endif
		1577
		1578	#ifdef use_filterfactory_implementation_d_minmax
		1579	value_type min_val_d = 0;
		1580	value_type max_val_d = 1024;
		1581	#else
		1582	value_type min_val_d = -512;
		1583	value_type max_val_d = 512;
		1584	#endif
		1585
		1586	#ifdef use_filterfactory_implementation_D
		1587	value_type val_D = 1024;
		1588	#else
		1589	value_type val_D = 1024; // max_val_d - min_val_d;
		1590	#endif
		1591
259	daniel-mar	1592	/* predefined symbols */
500	daniel-mar	1593	struct sym_rec predefs[] = {
259	daniel-mar	1594	/* functions */
		1595
		1596	{0,TOK_FN3,"src", (pfunc_type)ff_src, 0},
		1597	{0,TOK_FN3,"rad", (pfunc_type)ff_rad, 0},
		1598	{0,TOK_FN1,"ctl", (pfunc_type)ff_ctl, 0},
		1599	{0,TOK_FN3,"val", (pfunc_type)ff_val, 0},
		1600	{0,TOK_FN2,"map", (pfunc_type)ff_map, 0},
		1601	{0,TOK_FN2,"min", (pfunc_type)ff_min, 0},
		1602	{0,TOK_FN2,"max", (pfunc_type)ff_max, 0},
		1603	{0,TOK_FN1,"abs", (pfunc_type)ff_abs, 0},
		1604	{0,TOK_FN3,"add", (pfunc_type)ff_add, 0},
		1605	{0,TOK_FN3,"sub", (pfunc_type)ff_sub, 0},
		1606	{0,TOK_FN2,"dif", (pfunc_type)ff_dif, 0},
		1607	{0,TOK_FN2,"rnd", (pfunc_type)ff_rnd, 0},
		1608	{0,TOK_FN4,"mix", (pfunc_type)ff_mix, 0},
		1609	{0,TOK_FN5,"scl", (pfunc_type)ff_scl, 0},
		1610	{0,TOK_FN1,"sqr", (pfunc_type)ff_sqr, 0},
		1611	{0,TOK_FN1,"sqrt", (pfunc_type)ff_sqr, 0}, // sqrt() is synonym to sqr() in Premiere
		1612	{0,TOK_FN1,"sin", (pfunc_type)ff_sin, 0},
		1613	{0,TOK_FN1,"cos", (pfunc_type)ff_cos, 0},
		1614	{0,TOK_FN1,"tan", (pfunc_type)ff_tan, 0},
		1615	{0,TOK_FN2,"r2x", (pfunc_type)ff_r2x, 0},
		1616	{0,TOK_FN2,"r2y", (pfunc_type)ff_r2y, 0},
		1617	{0,TOK_FN2,"c2d", (pfunc_type)ff_c2d, 0},
		1618	{0,TOK_FN2,"c2m", (pfunc_type)ff_c2m, 0},
		1619	{0,TOK_FN1,"get", (pfunc_type)ff_get, 0},
		1620	{0,TOK_FN2,"put", (pfunc_type)ff_put, 0},
		1621	{0,TOK_FN10,"cnv",(pfunc_type)ff_cnv, 0},
		1622	{0,TOK_FN1,"rst", (pfunc_type)ff_rst, 0}, // undocumented FilterFactory function
300	daniel-mar	1623	{0,TOK_FN2,"pow", (pfunc_type)ff_pow, 0}, // new function, also added in inofficial Filter Factory 3.1.0 patch
259	daniel-mar	1624
304	daniel-mar	1625	/* Predefined variables (names with more than 1 character); most of them are undocumented in Filter Factory */
		1626	/* The predefined variables with 1 character are defined in lexer.l and process.c */
		1627	/* In this table, you must not add TOK_VAR with only 1 character (since this case is not defined in parser.y) */
259	daniel-mar	1628
335	daniel-mar	1629	{0,TOK_VAR,"rmax",0, &var['R']}, // alias of R (defined in lexer.l and set by process.c)
		1630	{0,TOK_VAR,"gmax",0, &var['G']}, // alias of G (defined in lexer.l and set by process.c)
		1631	{0,TOK_VAR,"bmax",0, &var['B']}, // alias of B (defined in lexer.l and set by process.c)
		1632	{0,TOK_VAR,"amax",0, &var['A']}, // alias of A (defined in lexer.l and set by process.c)
		1633	{0,TOK_VAR,"cmax",0, &var['C']}, // alias of C (defined in lexer.l and set by process.c)
		1634	{0,TOK_VAR,"imax",0, &max_val_i},
		1635	{0,TOK_VAR,"umax",0, &max_val_u},
		1636	{0,TOK_VAR,"vmax",0, &max_val_v},
		1637	{0,TOK_VAR,"dmax",0, &max_val_d},
		1638	{0,TOK_VAR,"mmax",0, &var['M']}, // alias of M (defined in lexer.l and set by process.c)
		1639	{0,TOK_VAR,"pmax",0, &var['Z']}, // alias of P (defined in lexer.l and set by process.c)
		1640	{0,TOK_VAR,"xmax",0, &var['X']}, // alias of X (defined in lexer.l and set by process.c)
		1641	{0,TOK_VAR,"ymax",0, &var['Y']}, // alias of Y (defined in lexer.l and set by process.c)
		1642	{0,TOK_VAR,"zmax",0, &var['Z']}, // alias of Z (defined in lexer.l and set by process.c)
259	daniel-mar	1643
		1644	{0,TOK_VAR,"rmin",0, &zero_val},
		1645	{0,TOK_VAR,"gmin",0, &zero_val},
		1646	{0,TOK_VAR,"bmin",0, &zero_val},
		1647	{0,TOK_VAR,"amin",0, &zero_val},
		1648	{0,TOK_VAR,"cmin",0, &zero_val},
335	daniel-mar	1649	{0,TOK_VAR,"imin",0, &min_val_i},
		1650	{0,TOK_VAR,"umin",0, &min_val_u},
		1651	{0,TOK_VAR,"vmin",0, &min_val_v},
		1652	{0,TOK_VAR,"dmin",0, &min_val_d},
259	daniel-mar	1653	{0,TOK_VAR,"mmin",0, &zero_val},
		1654	{0,TOK_VAR,"pmin",0, &zero_val},
		1655	{0,TOK_VAR,"xmin",0, &zero_val},
		1656	{0,TOK_VAR,"ymin",0, &zero_val},
		1657	{0,TOK_VAR,"zmin",0, &zero_val},
		1658
		1659	/* Undocumented synonyms of FilterFactory for compatibility with Premiere */
		1660	{0,TOK_FN10,"cnv0",(pfunc_type)ff_cnv, 0},
		1661	{0,TOK_FN3,"src0", (pfunc_type)ff_src, 0},
		1662	{0,TOK_FN3,"rad0", (pfunc_type)ff_rad, 0},
		1663	{0,TOK_FN10,"cnv1",(pfunc_type)ff_cnv, 0},
		1664	{0,TOK_FN3,"src1", (pfunc_type)ff_src, 0},
		1665	{0,TOK_FN3,"rad1", (pfunc_type)ff_rad, 0},
		1666	{0,TOK_VAR,"r0",0, &var['r']},
		1667	{0,TOK_VAR,"g0",0, &var['g']},
		1668	{0,TOK_VAR,"b0",0, &var['b']},
		1669	{0,TOK_VAR,"a0",0, &var['a']},
		1670	{0,TOK_VAR,"c0",0, &var['c']},
		1671	{0,TOK_VAR,"i0",0, &var['i']},
		1672	{0,TOK_VAR,"u0",0, &var['u']},
		1673	{0,TOK_VAR,"v0",0, &var['v']},
		1674	{0,TOK_VAR,"d0",0, &var['d']},
		1675	{0,TOK_VAR,"m0",0, &var['m']},
		1676	{0,TOK_VAR,"r1",0, &var['r']},
		1677	{0,TOK_VAR,"g1",0, &var['g']},
		1678	{0,TOK_VAR,"b1",0, &var['b']},
		1679	{0,TOK_VAR,"a1",0, &var['a']},
		1680	{0,TOK_VAR,"c1",0, &var['c']},
		1681	{0,TOK_VAR,"i1",0, &var['i']},
		1682	{0,TOK_VAR,"u1",0, &var['u']},
		1683	{0,TOK_VAR,"v1",0, &var['v']},
		1684	{0,TOK_VAR,"d1",0, &var['d']},
		1685	{0,TOK_VAR,"m1",0, &var['m']},
		1686	{0,TOK_VAR,"tmin",0, &zero_val},
		1687	{0,TOK_VAR,"tmax",0, &one_val},
		1688	{0,TOK_VAR,"total",0, &one_val},
		1689
		1690	{0,0,0,0,0}
		1691	};

Subversion Repositories filter_foundry

filter_foundry/trunk/funcs.c – Rev 500