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

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

Subversion Repositories filter_foundry

filter_foundry/trunk/funcs.c – Rev 301