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
259	daniel-mar	279	extern value_type slider[],cell[],var[],map[][0x100];
		280	extern unsigned char *image_ptr;
		281
294	daniel-mar	282	// -------------------------------------------------------------------------------------------
		283
259	daniel-mar	284	double costab[COSTABSIZE];
		285	double tantab[TANTABSIZE];
		286	void init_trigtab(){
297	daniel-mar	287	#ifdef PARSERTEST
		288	return 0;
		289	#else
259	daniel-mar	290	int i;
		291	for(i=0;i<COSTABSIZE;++i){
		292	costab[i] = cos(FFANGLE(i));
		293	}
		294	for(i=0;i<TANTABSIZE;++i){
		295	if (i>=TANTABSIZE/2) {
		296	/* the last '-1' in the expression '512-i-1' is for FilterFactory compatibility, and to avoid the undefined pi/2 area */
		297	tantab[i] = -tantab[TANTABSIZE-i-1];
		298	} else {
		299	tantab[i] = tan(FFANGLE(i));
		300	}
		301	}
297	daniel-mar	302	#endif
259	daniel-mar	303	}
		304
294	daniel-mar	305	// -------------------------------------------------------------------------------------------
		306
259	daniel-mar	307	/* Channel z for the input pixel at coordinates x,y.
		308	* Coordinates are relative to the input image data (pb->inData) */
		309	static value_type rawsrc(value_type x,value_type y,value_type z){
297	daniel-mar	310	#ifdef PARSERTEST
		311	return 0;
		312	#else
259	daniel-mar	313	if (HAS_BIG_DOC(gpb)) {
		314	if (x < BIGDOC_IN_RECT(gpb).left)
		315	x = BIGDOC_IN_RECT(gpb).left;
		316	else if (x >= BIGDOC_IN_RECT(gpb).right)
		317	x = BIGDOC_IN_RECT(gpb).right - 1;
		318	if (y < BIGDOC_IN_RECT(gpb).top)
		319	y = BIGDOC_IN_RECT(gpb).top;
		320	else if (y >= BIGDOC_IN_RECT(gpb).bottom)
		321	y = BIGDOC_IN_RECT(gpb).bottom - 1;
		322	return ((unsigned char)gpb->inData)[(long)gpb->inRowBytes (y - BIGDOC_IN_RECT(gpb).top)
		323	+ (long)nplanes * (x - BIGDOC_IN_RECT(gpb).left) + z];
		324	} else {
		325	if (x < IN_RECT(gpb).left)
		326	x = IN_RECT(gpb).left;
		327	else if (x >= IN_RECT(gpb).right)
		328	x = IN_RECT(gpb).right - 1;
		329	if (y < IN_RECT(gpb).top)
		330	y = IN_RECT(gpb).top;
		331	else if (y >= IN_RECT(gpb).bottom)
		332	y = IN_RECT(gpb).bottom - 1;
		333	return ((unsigned char)gpb->inData)[(long)gpb->inRowBytes (y - IN_RECT(gpb).top)
		334	+ (long)nplanes * (x - IN_RECT(gpb).left) + z];
		335	}
297	daniel-mar	336	#endif
259	daniel-mar	337	}
		338
294	daniel-mar	339	// -------------------------------------------------------------------------------------------
		340
259	daniel-mar	341	/* src(x,y,z) Channel z for the pixel at coordinates x,y.
		342	* Coordinates are relative to filtered area (selection). */
294	daniel-mar	343
259	daniel-mar	344	value_type ff_src(value_type x,value_type y,value_type z){
297	daniel-mar	345	#ifdef PARSERTEST
259	daniel-mar	346	return 0;
297	daniel-mar	347	#else
259	daniel-mar	348	if(x < 0)
		349	x = 0;
		350	else if(x >= var['X'])
		351	x = var['X']-1;
		352	if(y < 0)
		353	y = 0;
		354	else if(y >= var['Y'])
		355	y = var['Y']-1;
		356	return z >= 0 && z < var['Z'] ?
		357	image_ptr[(long)gpb->inRowBytesy + (long)nplanesx + z] : 0;
297	daniel-mar	358	#endif
259	daniel-mar	359	}
		360
294	daniel-mar	361	// -------------------------------------------------------------------------------------------
		362
295	daniel-mar	363	/* r2x(d,m) x displacement of the pixel m units away, at an angle of d,
		364	from an arbitrary center */
		365
		366	value_type factory_r2x(value_type d, value_type m) {
		367	// https://misc.daniel-marschall.de/projects/filter_factory/function_r2x.html
297	daniel-mar	368	#ifdef PARSERTEST
		369	return 0;
		370	#else
295	daniel-mar	371	int eax = m;
		372	int ebx = d;
		373	ebx &= 1023;
		374	ebx = FACTORY_COS_LOOKUP[ebx];
		375	return (((int64_t)eax * (int64_t)ebx) + 8191) >> 14;
297	daniel-mar	376	#endif
295	daniel-mar	377	}
		378
		379	value_type foundry_r2x(value_type d, value_type m) {
297	daniel-mar	380	#ifdef PARSERTEST
		381	return 0;
		382	#else
295	daniel-mar	383	return (value_type)RINT(m * costab[abs(d) % COSTABSIZE]);
297	daniel-mar	384	#endif
295	daniel-mar	385	}
		386
		387	value_type ff_r2x(value_type d, value_type m) {
297	daniel-mar	388	#ifdef use_filterfactory_implementation_r2x
295	daniel-mar	389	return factory_r2x(d, m);
297	daniel-mar	390	#else
295	daniel-mar	391	return foundry_r2x(d, m);
297	daniel-mar	392	#endif
295	daniel-mar	393	}
		394
		395	// -------------------------------------------------------------------------------------------
		396
		397	/* r2y(d,m) y displacement of the pixel m units away, at an angle of d,
		398	from an arbitrary center */
		399
		400	value_type factory_r2y(value_type d, value_type m) {
297	daniel-mar	401	#ifdef PARSERTEST
		402	return 0;
		403	#else
295	daniel-mar	404	// https://misc.daniel-marschall.de/projects/filter_factory/function_r2y.html
		405	return factory_r2x(d - 256, m);
297	daniel-mar	406	#endif
295	daniel-mar	407	}
		408
		409	value_type foundry_r2y(value_type d, value_type m) {
297	daniel-mar	410	#ifdef PARSERTEST
		411	return 0;
		412	#else
295	daniel-mar	413	return (value_type)RINT(m * costab[abs(d - 256) % COSTABSIZE]);
297	daniel-mar	414	#endif
295	daniel-mar	415	}
		416
		417	value_type ff_r2y(value_type d, value_type m) {
297	daniel-mar	418	#ifdef use_filterfactory_implementation_r2y
295	daniel-mar	419	return factory_r2y(d, m);
297	daniel-mar	420	#else
295	daniel-mar	421	return foundry_r2y(d, m);
297	daniel-mar	422	#endif
295	daniel-mar	423	}
		424
		425	// -------------------------------------------------------------------------------------------
		426
259	daniel-mar	427	/* rad(d,m,z) Channel z in the source image, which is m units away,
		428	at an angle of d, from the center of the image */
294	daniel-mar	429
		430	value_type factory_rad(value_type d, value_type m, value_type z) {
297	daniel-mar	431	#ifdef PARSERTEST
		432	return 0;
		433	#else
294	daniel-mar	434	// https://misc.daniel-marschall.de/projects/filter_factory/function_rad.html
		435
		436	const int xmin = 0;
		437	const int ymin = 0;
		438	const int zmin = 0;
		439
		440	int eax, ebx, ecx;
		441
		442	ebx = FACTORY_COS_LOOKUP[d & 1023];
		443	eax = (((int64_t)m * (int64_t)ebx) + 8191) >> 14;
		444	ecx = ((var['X'] - xmin) >> 1) + eax;
		445	if (ecx < 0) {
		446	ecx = 0;
		447	}
		448	else {
		449	eax = var['X'];
		450	if (ecx >= eax) {
		451	ecx = eax - 1;
		452	}
		453	}
		454
		455	ebx = FACTORY_COS_LOOKUP[(d - 256) & 1023];
		456	eax = (((int64_t)m * (int64_t)ebx) + 8191) >> 14;
		457	ebx = ((var['Y'] - ymin) >> 1) + eax;
		458	if (ebx < 0) {
		459	ebx = 0;
		460	}
		461	else {
		462	eax = var['Y'];
		463	if (ebx >= eax) {
		464	ebx = eax - 1;
		465	}
		466	}
		467
		468	// Now return pixel [x=ecx,y=ebx,z=esi] from the source image!
		469	//return ff_src(ecx, ebx, z);
		470	ebx *= gpb->inRowBytes;
		471	ecx *= var['Z'] - zmin;
		472	return image_ptr[z+ebx+ecx];
297	daniel-mar	473	#endif
294	daniel-mar	474	}
		475
		476	value_type foundry_rad(value_type d, value_type m, value_type z) {
297	daniel-mar	477	#ifdef PARSERTEST
		478	return 0;
		479	#else
294	daniel-mar	480	return ff_src(foundry_r2x(d, m) + var['X'] / 2, foundry_r2y(d, m) + var['Y'] / 2, z);
297	daniel-mar	481	#endif
294	daniel-mar	482	}
		483
259	daniel-mar	484	value_type ff_rad(value_type d,value_type m,value_type z){
297	daniel-mar	485	#ifdef use_filterfactory_implementation_rad
294	daniel-mar	486	return factory_rad(d, m, z);
297	daniel-mar	487	#else
294	daniel-mar	488	return foundry_rad(d, m, z);
297	daniel-mar	489	#endif
259	daniel-mar	490	}
		491
294	daniel-mar	492	// -------------------------------------------------------------------------------------------
		493
259	daniel-mar	494	/* ctl(i) Value of slider i, where i is an integer between 0 and 7, inclusive */
		495	value_type ff_ctl(value_type i){
297	daniel-mar	496	#ifdef PARSERTEST
		497	return 0;
		498	#else
259	daniel-mar	499	return i>=0 && i<=7 ? slider[i] : 0;
297	daniel-mar	500	#endif
259	daniel-mar	501	}
		502
294	daniel-mar	503	// -------------------------------------------------------------------------------------------
		504
259	daniel-mar	505	/* val(i,a,b) Value of slider i, mapped onto the range a to b */
		506	value_type ff_val(value_type i,value_type a,value_type b){
297	daniel-mar	507	#ifdef PARSERTEST
		508	return 0;
		509	#else
259	daniel-mar	510	return ((long)ff_ctl(i)*(b-a))/255 + a;
297	daniel-mar	511	#endif
259	daniel-mar	512	}
		513
294	daniel-mar	514	// -------------------------------------------------------------------------------------------
		515
259	daniel-mar	516	/* map(i,n) Item n from mapping table i, where i is an integer between
		517
		518	inclusive */
		519	value_type ff_map(value_type i,value_type n){
297	daniel-mar	520	#ifdef PARSERTEST
		521	return 0;
		522	#else
		523	/*
259	daniel-mar	524	if( i>=0 && i<=3 && n>=0 && n<=255 ){
		525	int H = slider[i2],L = slider[i2+1];
		526	return n<=L \|\| H==L ? 0 : ( n>=H ? 255 : ((n-L)*255L)/(H-L) );
		527	}else
		528	return 0;
		529	*/
		530	// this code is from GIMP User Filter
		531	value_type x = ff_ctl(i*2),
		532	y = ff_ctl(i*2+1);
		533	return abs(((long)n*(y-x) / 255)+x);
297	daniel-mar	534	#endif
259	daniel-mar	535	}
		536
294	daniel-mar	537	// -------------------------------------------------------------------------------------------
		538
259	daniel-mar	539	/* min(a,b) Lesser of a and b */
		540	value_type ff_min(value_type a,value_type b){
297	daniel-mar	541	#ifdef PARSERTEST
		542	return 0;
		543	#else
259	daniel-mar	544	return a < b ? a : b;
297	daniel-mar	545	#endif
259	daniel-mar	546	}
		547
294	daniel-mar	548	// -------------------------------------------------------------------------------------------
		549
259	daniel-mar	550	/* max(a,b) Greater of a and b */
		551	value_type ff_max(value_type a,value_type b){
297	daniel-mar	552	#ifdef PARSERTEST
		553	return 0;
		554	#else
259	daniel-mar	555	return a > b ? a : b;
297	daniel-mar	556	#endif
259	daniel-mar	557	}
		558
294	daniel-mar	559	// -------------------------------------------------------------------------------------------
		560
259	daniel-mar	561	/* abs(a) Absolute value of a */
		562	value_type ff_abs(value_type a){
297	daniel-mar	563	#ifdef PARSERTEST
		564	return 0;
		565	#else
259	daniel-mar	566	return abs(a);
297	daniel-mar	567	#endif
259	daniel-mar	568	}
		569
294	daniel-mar	570	// -------------------------------------------------------------------------------------------
		571
259	daniel-mar	572	/* add(a,b,c) Sum of a and b, or c, whichever is lesser */
		573	value_type ff_add(value_type a,value_type b,value_type c){
297	daniel-mar	574	#ifdef PARSERTEST
		575	return 0;
		576	#else
259	daniel-mar	577	return ff_min(a+b,c);
297	daniel-mar	578	#endif
259	daniel-mar	579	}
		580
294	daniel-mar	581	// -------------------------------------------------------------------------------------------
		582
259	daniel-mar	583	/* sub(a,b,c) Difference of a and b, or c, whichever is greater */
		584	value_type ff_sub(value_type a,value_type b,value_type c){
297	daniel-mar	585	#ifdef PARSERTEST
		586	return 0;
		587	#else
259	daniel-mar	588	return ff_max(ff_dif(a,b),c);
297	daniel-mar	589	#endif
259	daniel-mar	590	}
		591
294	daniel-mar	592	// -------------------------------------------------------------------------------------------
		593
259	daniel-mar	594	/* dif(a,b) Absolute value of the difference of a and b */
		595	value_type ff_dif(value_type a,value_type b){
297	daniel-mar	596	#ifdef PARSERTEST
		597	return 0;
		598	#else
259	daniel-mar	599	return abs(a-b);
297	daniel-mar	600	#endif
259	daniel-mar	601	}
		602
294	daniel-mar	603	// -------------------------------------------------------------------------------------------
		604
		605	/* rnd(a,b) Random number between a and b, inclusive */
		606
290	daniel-mar	607	struct factoryRngState {
291	daniel-mar	608	uint16_t index1;
		609	uint16_t index2;
		610	uint32_t seedTable[56];
		611	uint32_t seed;
		612	uint32_t seedSave;
		613	} gFactoryRngState;
286	daniel-mar	614
290	daniel-mar	615	void factory_fill_rnd_lookup(uint32_t seed, struct factoryRngState* state) {
297	daniel-mar	616	#ifdef PARSERTEST
		617	return 0;
		618	#else
290	daniel-mar	619	// Algorithm of Filter Factory
		620	// Filter Factory uses Donald E.Knuth's subtractive
		621	// random number generator algorithm ("ran3"), which has been published
		622	// in Page 283 of "The Art of Computer Programming, volume 2: Seminumerical Algorithms",
		623	// Addison-Wesley, Reading, MA, second edition, 1981.
		624	// https://www.cec.uchile.cl/cinetica/pcordero/MC_libros/NumericalRecipesinC.pdf (PDF Page 307)
286	daniel-mar	625
290	daniel-mar	626	long mj, mk;
		627	int i, ii, k;
		628
		629	// 161803398 = 1.61803398 * 10^8 ~= phi * 10^8
		630	mj = 161803398 - (seed & 0x7fff);
291	daniel-mar	631	state->seedTable[55] = mj;
290	daniel-mar	632
		633	mk = 1;
		634	ii = 0;
		635	for (i=1; i<=54; ++i) {
		636	if ((ii += 21) >= 55) ii -= 55; // ii = (21*i)%55;
291	daniel-mar	637	state->seedTable[ii] = mk;
290	daniel-mar	638	mk = mj - mk;
291	daniel-mar	639	mj = state->seedTable[ii];
290	daniel-mar	640	}
		641
		642	for (k=1; k<=4; ++k) {
		643	ii = 30;
		644	for (i=1; i<=55; ++i) {
		645	if ((ii += 1) >= 55) ii -= 55;
291	daniel-mar	646	state->seedTable[i] -= state->seedTable[1 + ii]; // 1 + (i+30)%55
290	daniel-mar	647	}
		648	}
		649
291	daniel-mar	650	state->seedSave = seed;
290	daniel-mar	651
		652	return;
297	daniel-mar	653	#endif
290	daniel-mar	654	}
		655
		656	uint32_t factory_rnd(uint32_t a, uint32_t b, struct factoryRngState* state) {
297	daniel-mar	657	#ifdef PARSERTEST
		658	return 0;
		659	#else
289	daniel-mar	660	uint32_t mj; // Note: This must be "uint32_t". With "long" (as described by Knuth), it won't match FilterFactory's algorithm
		661	int range;
286	daniel-mar	662
291	daniel-mar	663	if (state->seed != state->seedSave) {
288	daniel-mar	664	// (Intentional) behavior of Filter Foundry
291	daniel-mar	665	factory_fill_rnd_lookup(state->seed, &gFactoryRngState);
		666	state->index1 = 0;
		667	state->index2 = 31;
288	daniel-mar	668	}
		669
		670	// Algorithm of Filter Factory
289	daniel-mar	671	// Filter Factory uses Donald E.Knuth's subtractive
		672	// random number generator algorithm ("ran3"), which has been published
		673	// in Page 283 of "The Art of Computer Programming, volume 2: Seminumerical Algorithms",
		674	// Addison-Wesley, Reading, MA, second edition, 1981.
		675	// https://www.cec.uchile.cl/cinetica/pcordero/MC_libros/NumericalRecipesinC.pdf (PDF Page 307)
288	daniel-mar	676
291	daniel-mar	677	if (++state->index1 == 56) state->index1 = 1;
		678	if (++state->index2 == 56) state->index2 = 1;
286	daniel-mar	679
291	daniel-mar	680	mj = state->seedTable[state->index1] -
		681	state->seedTable[state->index2];
		682	state->seedTable[state->index1] = mj;
286	daniel-mar	683
289	daniel-mar	684	// This is Filter Factory specific:
290	daniel-mar	685	// Reduce result into interval [a..b] by applying (a + (mj % (b - a + 1))
		686	// Try to avoid modulo in order to increase performance
		687	range = b - a;
		688	if (range < 0) return 0;
		689	switch (range) {
289	daniel-mar	690	case 255:
290	daniel-mar	691	return a + (mj & 0xFF);
289	daniel-mar	692	case 127:
290	daniel-mar	693	return a + (mj & 0x7F);
289	daniel-mar	694	case 63:
290	daniel-mar	695	return a + (mj & 0x3F);
289	daniel-mar	696	case 31:
290	daniel-mar	697	return a + (mj & 0x1F);
289	daniel-mar	698	case 15:
290	daniel-mar	699	return a + (mj & 0xF);
289	daniel-mar	700	case 7:
290	daniel-mar	701	return a + (mj & 0x7);
289	daniel-mar	702	case 3:
290	daniel-mar	703	return a + (mj & 0x3);
289	daniel-mar	704	case 1:
290	daniel-mar	705	return a + (mj & 0x1);
		706	case 0:
		707	return a;
		708	default:
		709	return a + (mj % (range + 1));
289	daniel-mar	710	}
297	daniel-mar	711	#endif
286	daniel-mar	712	}
		713
294	daniel-mar	714	value_type foundry_rnd(value_type a, value_type b) {
297	daniel-mar	715	#ifdef PARSERTEST
		716	return 0;
		717	#else
294	daniel-mar	718	return (int)((abs(a-b)+1)*(rand()/(RAND_MAX+1.))) + ff_min(a,b);
		719	// return ((unsigned)rand() % (ff_dif(a,b)+1)) + ff_min(a,b);
297	daniel-mar	720	#endif
294	daniel-mar	721	}
		722
		723	value_type ff_rnd(value_type a,value_type b){
297	daniel-mar	724	#ifdef use_filterfactory_implementation_rnd
294	daniel-mar	725	return factory_rnd(a, b, &gFactoryRngState);
297	daniel-mar	726	#else
294	daniel-mar	727	return foundry_rnd(a, b);
297	daniel-mar	728	#endif
294	daniel-mar	729	}
		730
		731	// -------------------------------------------------------------------------------------------
		732
		733	void factory_initialize_rnd_variables() {
297	daniel-mar	734	#ifdef PARSERTEST
		735	return 0;
		736	#else
294	daniel-mar	737	gFactoryRngState.seed = 0; // default seed
		738	gFactoryRngState.seedSave = gFactoryRngState.seed + 1; // force rnd() to call factory_fill_rnd_lookup()
297	daniel-mar	739	#endif
294	daniel-mar	740	}
		741
		742	void foundry_initialize_rnd_variables() {
297	daniel-mar	743	#ifdef PARSERTEST
		744	return 0;
		745	#else
		746	foundry_rst(691204);
		747	#endif
294	daniel-mar	748	}
		749
		750	void initialize_rnd_variables() {
297	daniel-mar	751	#ifdef use_filterfactory_implementation_rnd
294	daniel-mar	752	factory_initialize_rnd_variables();
297	daniel-mar	753	#else
294	daniel-mar	754	foundry_initialize_rnd_variables();
297	daniel-mar	755	#endif
294	daniel-mar	756	}
		757
		758	// -------------------------------------------------------------------------------------------
		759
		760	/* rst(i) sets a random seed and returns 0. (undocumented Filter Factory function).
		761	Added by DM, 18 Dec 2018 */
		762
290	daniel-mar	763	int32_t factory_rst(uint32_t seed, struct factoryRngState* state) {
297	daniel-mar	764	#ifdef PARSERTEST
		765	return 0;
		766	#else
294	daniel-mar	767	// Attention: This is NOT the FilterFactory rst() implementation!
		768
290	daniel-mar	769	// We implement rst(i) completely differently in Filter Foundry:
		770	// Every call of rst() will renew the lookup table.
		771	// In Filter Factory, there are strange/buggy things going
		772	// on: rst(i) only sets a seed and the lookup table is renewed
		773	// at the NEXT invocation of the filter. Furthermore, in FilterFactory,
		774	// the state is not reset between invocations, therefore, the preview image
		775	// will influence the PRNG state of the final image...
		776	// More information at "Filter Factory Compatibility.md"
286	daniel-mar	777
291	daniel-mar	778	state->seed = seed;
286	daniel-mar	779
290	daniel-mar	780	// Force renewal of the PRNG state in the next rnd(a,b) call.
		781	// This allows us to use:
		782	// (x==0?rst(1):0), rnd(0,255)
		783	// But it is slower and this won't work anymore:
		784	// rst(0), rnd(0,255)
294	daniel-mar	785	state->seedSave = seed + 1;
286	daniel-mar	786
287	daniel-mar	787	return 0;
297	daniel-mar	788	#endif
286	daniel-mar	789	}
		790
294	daniel-mar	791	value_type foundry_rst(value_type seed) {
297	daniel-mar	792	#ifdef PARSERTEST
		793	return 0;
		794	#else
294	daniel-mar	795	srand(seed);
		796	return 0;
297	daniel-mar	797	#endif
287	daniel-mar	798	}
		799
294	daniel-mar	800	value_type ff_rst(value_type seed) {
297	daniel-mar	801	#ifdef use_filterfactory_implementation_rnd
294	daniel-mar	802	return factory_rst(seed, &gFactoryRngState);
297	daniel-mar	803	#else
294	daniel-mar	804	return foundry_rst(seed);
297	daniel-mar	805	#endif
259	daniel-mar	806	}
		807
294	daniel-mar	808	// -------------------------------------------------------------------------------------------
		809
259	daniel-mar	810	/* mix(a,b,n,d) Mixture of a and b by fraction n/d, an/d+b(d-n)/d */
		811	value_type ff_mix(value_type a,value_type b,value_type n,value_type d){
297	daniel-mar	812	#ifdef PARSERTEST
		813	return 0;
		814	#else
259	daniel-mar	815	return d ? ((long)an)/d + ((long)b(d-n))/d : 0;
297	daniel-mar	816	#endif
259	daniel-mar	817	}
		818
294	daniel-mar	819	// -------------------------------------------------------------------------------------------
		820
259	daniel-mar	821	/* scl(a,il,ih,ol,oh) Scale a from input range (il to ih)
		822	to output range (ol to oh) */
		823	value_type ff_scl(value_type a,value_type il,value_type ih,
		824	value_type ol,value_type oh){
297	daniel-mar	825	#ifdef PARSERTEST
		826	return 0;
		827	#else
259	daniel-mar	828	return ih==il ? 0 : ol + ((long)(oh-ol)*(a-il))/(ih-il);
297	daniel-mar	829	#endif
259	daniel-mar	830	}
		831
294	daniel-mar	832	// -------------------------------------------------------------------------------------------
		833
		834	/* sqr(x) Square root of x */
		835
259	daniel-mar	836	static uint32_t isqrt(uint32_t x) {
297	daniel-mar	837	#ifdef PARSERTEST
		838	return 0;
		839	#else
259	daniel-mar	840	// based on https://gist.github.com/orlp/3481770
		841
		842	static uint32_t lkpSquares[65535];
		843	static int lkpInitialized = 0;
		844	const uint32_t *p;
		845	int i;
		846
		847	while (lkpInitialized == 1) { /* If other thread is currently creating the lookup table, then wait */ }
		848	if (!lkpInitialized) {
		849	lkpInitialized = 1;
		850	for (i = 0; i < 65535; ++i) {
		851	lkpSquares[i] = i * i;
		852	}
		853	lkpInitialized = 2;
		854	}
		855
		856	p = lkpSquares;
		857
		858	if (p[32768] <= x) p += 32768;
		859	if (p[16384] <= x) p += 16384;
		860	if (p[8192] <= x) p += 8192;
		861	if (p[4096] <= x) p += 4096;
		862	if (p[2048] <= x) p += 2048;
		863	if (p[1024] <= x) p += 1024;
		864	if (p[512] <= x) p += 512;
		865	if (p[256] <= x) p += 256;
		866	if (p[128] <= x) p += 128;
		867	if (p[64] <= x) p += 64;
		868	if (p[32] <= x) p += 32;
		869	if (p[16] <= x) p += 16;
		870	if (p[8] <= x) p += 8;
		871	if (p[4] <= x) p += 4;
		872	if (p[2] <= x) p += 2;
		873	if (p[1] <= x) p += 1;
		874
		875	return (uint32_t)(p - lkpSquares);
297	daniel-mar	876	#endif
259	daniel-mar	877	}
		878
294	daniel-mar	879	value_type factory_sqr(value_type x) {
297	daniel-mar	880	#ifdef PARSERTEST
		881	return 0;
		882	#else
294	daniel-mar	883	// https://misc.daniel-marschall.de/projects/filter_factory/function_sqr.html
		884
295	daniel-mar	885	int eax, ebx, ecx;
		886
		887	ebx = x;
294	daniel-mar	888	if (ebx > 1) {
295	daniel-mar	889	ecx = ebx;
294	daniel-mar	890	ebx = ebx >> 1;
295	daniel-mar	891	eax = 2;
294	daniel-mar	892	while (ebx > eax) {
		893	eax = ecx;
		894	eax /= ebx;
		895	ebx += eax;
		896	ebx = ebx >> 1;
		897	}
		898	}
		899	return ebx;
297	daniel-mar	900	#endif
294	daniel-mar	901	}
		902
		903	value_type foundry_sqr(value_type x) {
297	daniel-mar	904	#ifdef PARSERTEST
		905	return 0;
		906	#else
294	daniel-mar	907	// Note: FilterFactory has sqr(x)=x if x<0 . Here we set sqr(x)=0 for x<0
259	daniel-mar	908	return x < 0 ? 0 : isqrt(x);
297	daniel-mar	909	#endif
259	daniel-mar	910	}
		911
294	daniel-mar	912	value_type ff_sqr(value_type x){
297	daniel-mar	913	#ifdef use_filterfactory_implementation_sqr
294	daniel-mar	914	return factory_sqr(x);
297	daniel-mar	915	#else
294	daniel-mar	916	return foundry_sqr(x);
297	daniel-mar	917	#endif
294	daniel-mar	918	}
		919
		920	// -------------------------------------------------------------------------------------------
		921
		922	/* cos(x) Cosine function of x, where x is an integer between 0 and
259	daniel-mar	923	1024, inclusive, and the value returned is an integer
		924	between -512 and 512, inclusive (Windows) or -1024 and
		925	1024, inclusive (Mac OS) */
294	daniel-mar	926
		927	value_type factory_cos(value_type x) {
297	daniel-mar	928	#ifdef PARSERTEST
		929	return 0;
		930	#else
294	daniel-mar	931	// https://misc.daniel-marschall.de/projects/filter_factory/function_cos.html
		932	int res;
		933	if (x < 0) x = -x;
		934	x &= 0x3ff; // 1023
		935	res = FACTORY_COS_LOOKUP[x];
		936	return res >= 0 ? (res / 32) : res / 32 - 1;
297	daniel-mar	937	#endif
259	daniel-mar	938	}
		939
294	daniel-mar	940	value_type foundry_cos(value_type x) {
297	daniel-mar	941	#ifdef PARSERTEST
		942	return 0;
		943	#else
294	daniel-mar	944	//return RINT(TRIGAMP*cos(FFANGLE(x)));
		945	return (value_type)RINT(TRIGAMP * costab[abs(x) % COSTABSIZE]);
297	daniel-mar	946	#endif
294	daniel-mar	947	}
		948
		949	value_type ff_cos(value_type x){
297	daniel-mar	950	#ifdef use_filterfactory_implementation_cos
294	daniel-mar	951	return factory_cos(x);
297	daniel-mar	952	#else
294	daniel-mar	953	return foundry_cos(x);
297	daniel-mar	954	#endif
294	daniel-mar	955	}
		956
		957	// -------------------------------------------------------------------------------------------
		958
		959	/* sin(x) Sine function of x, where x is an integer between 0 and
259	daniel-mar	960	1024, inclusive, and the value returned is an integer
		961	between -512 and 512, inclusive (Windows) or -1024 and
		962	1024, inclusive (Mac OS) */
294	daniel-mar	963
		964	value_type factory_sin(value_type x) {
297	daniel-mar	965	#ifdef PARSERTEST
		966	return 0;
		967	#else
294	daniel-mar	968	// https://misc.daniel-marschall.de/projects/filter_factory/function_sin.html
		969	return factory_cos(x - 256);
297	daniel-mar	970	#endif
259	daniel-mar	971	}
		972
294	daniel-mar	973	value_type foundry_sin(value_type x) {
297	daniel-mar	974	#ifdef PARSERTEST
		975	return 0;
		976	#else
294	daniel-mar	977	//return RINT(TRIGAMP*sin(FFANGLE(x)));
		978	return foundry_cos(x - 256);
297	daniel-mar	979	#endif
294	daniel-mar	980	}
		981
		982	value_type ff_sin(value_type x) {
297	daniel-mar	983	#ifdef use_filterfactory_implementation_sin
294	daniel-mar	984	return factory_sin(x);
297	daniel-mar	985	#else
294	daniel-mar	986	return foundry_sin(x);
297	daniel-mar	987	#endif
294	daniel-mar	988	}
		989
		990	// -------------------------------------------------------------------------------------------
		991
259	daniel-mar	992	/* tan(x) Tangent function of x, where x is an integer
		993	between -256 and 256, inclusive. Althought the Filter Factory manual
		994	stated that the return value is bounded to -512 and 512, inclusive (Windows) or
		995	-1024 and 1024, inclusive (Mac OS), the output is actually NOT bounded! */
294	daniel-mar	996
		997	value_type factory_tan(value_type x) {
297	daniel-mar	998	#ifdef PARSERTEST
		999	return 0;
		1000	#else
294	daniel-mar	1001	// https://misc.daniel-marschall.de/projects/filter_factory/function_tan.html
		1002	int v1 = x;
		1003	int v2 = v1 < 0 ? -v1 : v1;
		1004	v2 &= 0x3ff; // 1023
		1005	v2 = FACTORY_COS_LOOKUP[v2];
		1006	v1 -= 256;
		1007	if (v1 < 0) v1 = -v1;
		1008	v1 &= 0x3ff; // 1023
		1009	v1 = FACTORY_COS_LOOKUP[v1];
		1010	if (v2 == 0) return 0;
		1011	v1 = v1 << 10; // v1 *= 1024;
		1012	return v1 / v2;
297	daniel-mar	1013	#endif
294	daniel-mar	1014	}
		1015
		1016	value_type foundry_tan(value_type x){
297	daniel-mar	1017	#ifdef PARSERTEST
		1018	return 0;
		1019	#else
259	daniel-mar	1020	// Following filter shows that the Filter Factory manual differs from the implementation.
291	daniel-mar	1021	// R = cos(x) > 1024 \|\| cos(x) < -1024 \|\| cos(-x) > 1024 \|\| cos(-x) < -1024 ? 255 : 0
259	daniel-mar	1022	// G = tan(x) > 1024 \|\| tan(x) < -1024 \|\| tan(-x) > 1024 \|\| tan(-x) < -1024 ? 255 : 0
		1023	// B = sin(x) > 1024 \|\| sin(x) < -1024 \|\| sin(-x) > 1024 \|\| sin(-x) < -1024 ? 255 : 0
		1024	// It outputs green stripes, showing that the output of tan() is not bounded.
		1025	// So, we do it the same way to stay compatible.
		1026	if (x < 0) x--; /* required for Filter Factory compatibility */
		1027	while (x < 0) x += TANTABSIZE;
		1028	return (value_type)RINT(2TRIGAMPtantab[x % TANTABSIZE]); // We need the x2 multiplicator for some reason
297	daniel-mar	1029	#endif
259	daniel-mar	1030	}
		1031
294	daniel-mar	1032	value_type ff_tan(value_type x) {
297	daniel-mar	1033	#ifdef use_filterfactory_implementation_tan
294	daniel-mar	1034	return factory_tan(x);
297	daniel-mar	1035	#else
294	daniel-mar	1036	return foundry_tan(x);
297	daniel-mar	1037	#endif
294	daniel-mar	1038	}
		1039
		1040	// -------------------------------------------------------------------------------------------
		1041
295	daniel-mar	1042	/* c2d(x,y) Angle displacement of the pixel at coordinates x,y */
294	daniel-mar	1043
295	daniel-mar	1044	value_type factory_c2d(value_type x, value_type y) {
297	daniel-mar	1045	#ifdef PARSERTEST
		1046	return 0;
		1047	#else
295	daniel-mar	1048	// https://misc.daniel-marschall.de/projects/filter_factory/function_c2d.html
		1049	int32_t eax, ebx, ecx;
		1050	eax = y;
		1051	ebx = x;
		1052	ecx = 0;
		1053	if (eax < 0) {
		1054	eax = -eax;
		1055	ecx \|= 4/0b0100/;
		1056	}
		1057	if (ebx < 0) {
		1058	ebx = -ebx;
		1059	ecx \|= 3/0b0011/;
		1060	}
		1061	if (eax > ebx) {
		1062	int tmp;
		1063	ecx ^= 1/0b0001/;
		1064	tmp = eax;
		1065	eax = ebx;
		1066	ebx = tmp;
		1067	}
		1068	if (eax > 0) {
		1069	eax = eax << 10;
		1070	eax /= ebx;
		1071	if (eax != 0) {
		1072	eax = (eax & 0xFFFF0000) \| (FACTORY_C2D_LOOKUP[eax - 1] & 0xFFFF);
		1073	eax = eax << 9;
		1074	ebx = 205888; // 205888/65536 == pi
		1075	eax /= ebx;
		1076	}
		1077	}
		1078	if ((ecx & 1/0b0001/) != 0) {
		1079	eax = -eax;
		1080	eax += 256;
		1081	}
		1082	if ((ecx & 2/0b0010/) != 0) {
		1083	eax += 256;
		1084	}
		1085	if ((ecx & 4/0b0100/) != 0) {
		1086	eax = -eax;
		1087	}
		1088	return eax;
297	daniel-mar	1089	#endif
294	daniel-mar	1090	}
		1091
295	daniel-mar	1092	value_type foundry_c2d(value_type x, value_type y) {
297	daniel-mar	1093	#ifdef PARSERTEST
		1094	return 0;
		1095	#else
295	daniel-mar	1096	// Behavior of FilterFoundry <1.7:
		1097	//return foundry_c2d_negated(x,y);
		1098
		1099	// Behavior in FilterFoundry 1.7+: Matches FilterFactory
		1100	return (value_type)RINT(TO_FFANGLE(atan2(y, x)));
297	daniel-mar	1101	#endif
294	daniel-mar	1102	}
		1103
295	daniel-mar	1104	value_type ff_c2d(value_type x, value_type y) {
297	daniel-mar	1105	#ifdef use_filterfactory_implementation_c2d
295	daniel-mar	1106	return factory_c2d(x, y);
297	daniel-mar	1107	#else
295	daniel-mar	1108	return foundry_c2d(x, y);
297	daniel-mar	1109	#endif
259	daniel-mar	1110	}
		1111
294	daniel-mar	1112	// -------------------------------------------------------------------------------------------
		1113
295	daniel-mar	1114	/* c2m(x,y) Magnitude displacement of the pixel at coordinates x,y */
294	daniel-mar	1115
295	daniel-mar	1116	value_type factory_c2m(value_type x, value_type y) {
297	daniel-mar	1117	#ifdef PARSERTEST
		1118	return 0;
		1119	#else
295	daniel-mar	1120	// https://misc.daniel-marschall.de/projects/filter_factory/function_c2m.html
		1121	int32_t eax, ebx;
		1122	ebx = y < 0 ? -y : y;
		1123	eax = x < 0 ? -x : x;
		1124	if (eax == ebx) {
		1125	eax = 27146; // 27146/65536 == sqrt(1)-1
		1126	}
		1127	else {
		1128	if (eax > ebx) {
		1129	int tmp = eax;
		1130	eax = ebx;
		1131	ebx = tmp;
		1132	}
		1133	eax = eax << 10;
		1134	eax /= ebx;
		1135	eax = FACTORY_C2M_LOOKUP[eax];
		1136	}
		1137	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1138	eax += ebx;
		1139	return eax;
297	daniel-mar	1140	#endif
294	daniel-mar	1141	}
		1142
295	daniel-mar	1143	value_type foundry_c2m(value_type x, value_type y) {
297	daniel-mar	1144	#ifdef PARSERTEST
		1145	return 0;
		1146	#else
295	daniel-mar	1147	return isqrt((long)x * x + (long)y * y);
297	daniel-mar	1148	#endif
294	daniel-mar	1149	}
		1150
295	daniel-mar	1151	value_type ff_c2m(value_type x, value_type y) {
297	daniel-mar	1152	#ifdef use_filterfactory_implementation_c2m
295	daniel-mar	1153	return factory_c2m(x, y);
297	daniel-mar	1154	#else
295	daniel-mar	1155	return foundry_c2m(x, y);
297	daniel-mar	1156	#endif
259	daniel-mar	1157	}
		1158
294	daniel-mar	1159	// -------------------------------------------------------------------------------------------
		1160
295	daniel-mar	1161	/* Range of angles within the image, where D is always 1024 */
		1162
294	daniel-mar	1163	value_type ff_D() {
		1164	return 1024;
		1165	}
		1166
		1167	// -------------------------------------------------------------------------------------------
		1168
295	daniel-mar	1169	/* Direction(angle) of the current pixel from the center of the image,
		1170	where d is an integer between 0 and 1024 inclusive */
		1171
294	daniel-mar	1172	value_type factory_d() {
297	daniel-mar	1173	#ifdef PARSERTEST
		1174	return 0;
		1175	#else
295	daniel-mar	1176	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_d_lowercase.html
		1177
		1178	int eax, ebx, ecx;
296	daniel-mar	1179	const int xmin = 0, ymin = 0;
295	daniel-mar	1180
		1181	eax = -(var['Y'] - ymin) / 2;
		1182	ebx = -(var['X'] - xmin) / 2;
		1183	ecx = 0;
		1184	eax += var['y'];
		1185	if (eax < 0) {
		1186	eax = -eax;
		1187	ecx \|= 4/0b0100/;
		1188	}
		1189	ebx += var['x'];
		1190	if (ebx < 0) {
		1191	ebx = -ebx;
		1192	ecx \|= 3/0b0011/;
		1193	}
		1194	if (eax > ebx) {
		1195	int tmp;
		1196	ecx ^= 1/0b0001/;
		1197	tmp = eax;
		1198	eax = ebx;
		1199	ebx = tmp;
		1200	}
		1201	if (eax > 0) {
		1202	eax = eax << 10;
		1203	eax /= ebx;
		1204	if (eax != 0) { // C2D_LOOKUP[-1] will never be called. Good!
		1205	eax = (eax & 0xFFFF0000) + (FACTORY_C2D_LOOKUP[eax - 1] & 0xFFFF);
		1206	eax = eax << 9;
		1207	ebx = 205888; // 205888/65536 == pi
		1208	eax /= ebx;
		1209	}
		1210	}
		1211	if ((ecx & 1/0b0001/) != 0) {
		1212	eax = -eax;
		1213	eax += 256;
		1214	}
		1215	if ((ecx & 2/0b0010/) != 0) {
		1216	eax += 256;
		1217	}
		1218	if ((ecx & 4/0b0100/) != 0) {
		1219	eax = -eax;
		1220	}
		1221	return eax;
297	daniel-mar	1222	#endif
294	daniel-mar	1223	}
		1224
		1225	value_type foundry_c2d_negated(int x, int y) {
297	daniel-mar	1226	#ifdef PARSERTEST
		1227	return 0;
		1228	#else
294	daniel-mar	1229	return (value_type)RINT(TO_FFANGLE(atan2(-y, -x)));
297	daniel-mar	1230	#endif
294	daniel-mar	1231	}
		1232
		1233	value_type foundry_d() {
297	daniel-mar	1234	#ifdef PARSERTEST
		1235	return 0;
		1236	#else
259	daniel-mar	1237	// NOTE: FilterFactory uses c2d(x,y):=atan2(y,x), but d:=atan2(-y,-x)
		1238	// Due to compatibility reasons, we implement it the same way!
		1239	// Sign of y difference is negated, as we are dealing with top-down coordinates angle is "observed"
294	daniel-mar	1240	int x = var['X'] / 2 - var['x'];
		1241	int y = var['Y'] / 2 - var['y'];
295	daniel-mar	1242	return foundry_c2d_negated(x, y);
297	daniel-mar	1243	#endif
259	daniel-mar	1244	}
		1245
294	daniel-mar	1246	value_type ff_d() {
297	daniel-mar	1247	#ifdef use_filterfactory_implementation_d
294	daniel-mar	1248	return factory_d();
297	daniel-mar	1249	#else
294	daniel-mar	1250	return foundry_d();
297	daniel-mar	1251	#endif
294	daniel-mar	1252	}
		1253
		1254	// -------------------------------------------------------------------------------------------
		1255
295	daniel-mar	1256	/* Range of magnitudes with the image, where M is one half the diagonal size of the image */
		1257
294	daniel-mar	1258	value_type factory_M() {
297	daniel-mar	1259	#ifdef PARSERTEST
		1260	return 0;
		1261	#else
295	daniel-mar	1262	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_uppercase.html
		1263
		1264	int eax, ebx;
		1265	const int xmin = 0, ymin = 0;
		1266
		1267	eax = (var['X'] - xmin) >> 1;
		1268	ebx = (var['Y'] - ymin) >> 1;
		1269	if (eax == ebx) {
		1270	eax = 27146; // 27146/65536 == sqrt(1)-1
		1271	}
		1272	else {
		1273	if (eax > ebx) {
		1274	int tmp = eax;
		1275	eax = ebx;
		1276	ebx = tmp;
		1277	}
		1278	eax = eax << 10;
		1279	eax /= ebx;
		1280	eax = FACTORY_C2M_LOOKUP[eax];
		1281	}
		1282	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1283	eax += ebx;
		1284	return eax;
297	daniel-mar	1285	#endif
294	daniel-mar	1286	}
		1287
		1288	value_type foundry_M() {
297	daniel-mar	1289	#ifdef PARSERTEST
		1290	return 0;
		1291	#else
294	daniel-mar	1292	return foundry_c2m(var['X'], var['Y']) / 2;
297	daniel-mar	1293	#endif
294	daniel-mar	1294	}
		1295
		1296	value_type ff_M() {
297	daniel-mar	1297	#ifdef use_filterfactory_implementation_M
294	daniel-mar	1298	return factory_M();
297	daniel-mar	1299	#else
294	daniel-mar	1300	return foundry_M();
297	daniel-mar	1301	#endif
294	daniel-mar	1302	}
		1303
		1304	// -------------------------------------------------------------------------------------------
		1305
295	daniel-mar	1306	/* Distance (magnitude) from the center of the image to the current pixel */
		1307
294	daniel-mar	1308	value_type factory_m() {
297	daniel-mar	1309	#ifdef PARSERTEST
		1310	return 0;
		1311	#else
295	daniel-mar	1312	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_lowercase.html
		1313
		1314	int eax, ebx;
		1315	const int xmin = 0, ymin = 0;
		1316
		1317	eax = ((xmin - var['X']) >> 1) + var['x'];
		1318	ebx = ((ymin - var['Y']) >> 1) + var['y'];
		1319	eax = eax < 0 ? -eax : eax;
		1320	ebx = ebx < 0 ? -ebx : ebx;
		1321
		1322	if (eax == ebx) {
		1323	eax = 27146; // 27146/65536 == sqrt(1)-1
		1324	}
		1325	else {
		1326	if (eax > ebx) {
		1327	int tmp = eax;
		1328	eax = ebx;
		1329	ebx = tmp;
		1330	}
		1331	eax = FACTORY_C2M_LOOKUP[1024 * eax / ebx];
		1332	}
		1333	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1334	eax += ebx;
		1335	return eax;
297	daniel-mar	1336	#endif
294	daniel-mar	1337	}
		1338
		1339	value_type foundry_m() {
297	daniel-mar	1340	#ifdef PARSERTEST
		1341	return 0;
		1342	#else
294	daniel-mar	1343	return foundry_c2m(var['X'] / 2 - var['x'], var['Y'] / 2 - var['y']);
297	daniel-mar	1344	#endif
294	daniel-mar	1345	}
		1346
		1347	value_type ff_m() {
297	daniel-mar	1348	#ifdef use_filterfactory_implementation_m
294	daniel-mar	1349	return factory_m();
297	daniel-mar	1350	#else
294	daniel-mar	1351	return foundry_m();
297	daniel-mar	1352	#endif
294	daniel-mar	1353	}
		1354
		1355	// -------------------------------------------------------------------------------------------
		1356
295	daniel-mar	1357	/* "Y" value of the YUV color-space */
		1358
294	daniel-mar	1359	value_type factory_i() {
297	daniel-mar	1360	#ifdef PARSERTEST
		1361	return 0;
		1362	#else
294	daniel-mar	1363	return ((76L * var['r']) + (150L * var['g']) + (29L * var['b'])) / 256; // range: [0..254]
297	daniel-mar	1364	#endif
294	daniel-mar	1365	}
		1366
		1367	value_type foundry_i() {
297	daniel-mar	1368	#ifdef PARSERTEST
		1369	return 0;
		1370	#else
294	daniel-mar	1371	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1372	return ((299L * var['r']) + (587L * var['g']) + (114L * var['b'])) / 1000; // range: [0..255]
297	daniel-mar	1373	#endif
294	daniel-mar	1374	}
		1375
		1376	value_type ff_i() {
297	daniel-mar	1377	#ifdef use_filterfactory_implementation_i
294	daniel-mar	1378	return factory_i();
297	daniel-mar	1379	#else
294	daniel-mar	1380	return foundry_i();
297	daniel-mar	1381	#endif
294	daniel-mar	1382	}
		1383
		1384	// -------------------------------------------------------------------------------------------
		1385
295	daniel-mar	1386	/* "U" value of the YUV color-space */
		1387
294	daniel-mar	1388	value_type factory_u() {
297	daniel-mar	1389	#ifdef PARSERTEST
		1390	return 0;
		1391	#else
294	daniel-mar	1392	return ((-19L * var['r']) + (-37L * var['g']) + (56L * var['b'])) / 256; // range: [-55..55]
297	daniel-mar	1393	#endif
294	daniel-mar	1394	}
		1395
		1396	value_type foundry_u() {
297	daniel-mar	1397	#ifdef PARSERTEST
		1398	return 0;
		1399	#else
294	daniel-mar	1400	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1401	return ((-147407L * var['r']) + (-289391L * var['g']) + (436798L * var['b'])) / 2000000; // range: [-55..55]
297	daniel-mar	1402	#endif
294	daniel-mar	1403	}
		1404
		1405	value_type ff_u() {
297	daniel-mar	1406	#ifdef use_filterfactory_implementation_u
294	daniel-mar	1407	return factory_u();
297	daniel-mar	1408	#else
294	daniel-mar	1409	return foundry_u();
297	daniel-mar	1410	#endif
294	daniel-mar	1411	}
		1412
		1413	// -------------------------------------------------------------------------------------------
		1414
295	daniel-mar	1415	/* "V" value of the YUV color-space */
		1416
294	daniel-mar	1417	value_type factory_v() {
297	daniel-mar	1418	#ifdef PARSERTEST
		1419	return 0;
		1420	#else
294	daniel-mar	1421	return ((78L * var['r']) + (-65L * var['g']) + (-13L * var['b'])) / 256; // range: [-77..77]
297	daniel-mar	1422	#endif
294	daniel-mar	1423	}
		1424
		1425	value_type foundry_v() {
297	daniel-mar	1426	#ifdef PARSERTEST
		1427	return 0;
		1428	#else
294	daniel-mar	1429	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1430	return ((614777L * var['r']) + (-514799L * var['g']) + (-99978L * var['b'])) / 2000000; // range: [-78..78]
297	daniel-mar	1431	#endif
294	daniel-mar	1432	}
		1433
		1434	value_type ff_v() {
297	daniel-mar	1435	#ifdef use_filterfactory_implementation_v
294	daniel-mar	1436	return factory_v();
297	daniel-mar	1437	#else
294	daniel-mar	1438	return foundry_v();
297	daniel-mar	1439	#endif
294	daniel-mar	1440	}
		1441
		1442	// -------------------------------------------------------------------------------------------
		1443
259	daniel-mar	1444	/* get(i) Returns the current cell value at i */
		1445
297	daniel-mar	1446	value_type factory_get(value_type i) {
		1447	#ifdef PARSERTEST
		1448	return 0;
		1449	#else
		1450	return i>=0 && i<NUM_CELLS ? cell[i] : i;
		1451	#endif
259	daniel-mar	1452	}
		1453
297	daniel-mar	1454	value_type foundry_get(value_type i) {
		1455	#ifdef PARSERTEST
		1456	return 0;
		1457	#else
		1458	return i >= 0 && i < NUM_CELLS ? cell[i] : 0;
		1459	#endif
		1460	}
		1461
		1462	value_type ff_get(value_type i) {
		1463	#ifdef use_filterfactory_implementation_get
		1464	return factory_get(i);
		1465	#else
		1466	return foundry_get(i);
		1467	#endif
		1468	}
		1469
294	daniel-mar	1470	// -------------------------------------------------------------------------------------------
		1471
259	daniel-mar	1472	/* put(v,i) Puts the new value v into cell i */
		1473	value_type ff_put(value_type v,value_type i){
297	daniel-mar	1474	#ifdef PARSERTEST
		1475	return 0;
		1476	#else
259	daniel-mar	1477	if(i>=0 && i<NUM_CELLS)
		1478	cell[i] = v;
		1479	return v;
297	daniel-mar	1480	#endif
259	daniel-mar	1481	}
		1482
294	daniel-mar	1483	// -------------------------------------------------------------------------------------------
		1484
259	daniel-mar	1485	/* Convolve. Applies a convolution matrix and divides with d. */
		1486	value_type ff_cnv(value_type m11,value_type m12,value_type m13,
291	daniel-mar	1487	value_type m21,value_type m22,value_type m23,
		1488	value_type m31,value_type m32,value_type m33,
		1489	value_type d)
259	daniel-mar	1490	{
297	daniel-mar	1491	#ifdef PARSERTEST
259	daniel-mar	1492	return 0;
297	daniel-mar	1493	#else
259	daniel-mar	1494	long total;
		1495	int x, y, z;
		1496	// shift x,y from selection-relative to image relative
		1497	if (HAS_BIG_DOC(gpb)) {
		1498	x = var['x'] + BIGDOC_FILTER_RECT(gpb).left;
		1499	y = var['y'] + BIGDOC_FILTER_RECT(gpb).top;
		1500	} else {
		1501	x = var['x'] + FILTER_RECT(gpb).left;
		1502	y = var['y'] + FILTER_RECT(gpb).top;
		1503	}
		1504	z = var['z'];
		1505
		1506	if(z >= 0 && z < var['Z'])
		1507	total = m11rawsrc(x-1,y-1,z) + m12rawsrc(x,y-1,z) + m13*rawsrc(x+1,y-1,z)
		1508	+ m21rawsrc(x-1,y, z) + m22rawsrc(x,y, z) + m23*rawsrc(x+1,y, z)
		1509	+ m31rawsrc(x-1,y+1,z) + m32rawsrc(x,y+1,z) + m33*rawsrc(x+1,y+1,z);
		1510	else
		1511	total = 0;
		1512
		1513	return d ? total/d : 0;
297	daniel-mar	1514	#endif
259	daniel-mar	1515	}
		1516
294	daniel-mar	1517	// -------------------------------------------------------------------------------------------
259	daniel-mar	1518
		1519	value_type zero_val = 0;
		1520	value_type one_val = 1;
		1521	value_type max_channel_val = 255;
		1522
		1523	/* predefined symbols */
		1524	struct sym_rec predefs[]={
		1525	/* functions */
		1526
		1527	{0,TOK_FN3,"src", (pfunc_type)ff_src, 0},
		1528	{0,TOK_FN3,"rad", (pfunc_type)ff_rad, 0},
		1529	{0,TOK_FN1,"ctl", (pfunc_type)ff_ctl, 0},
		1530	{0,TOK_FN3,"val", (pfunc_type)ff_val, 0},
		1531	{0,TOK_FN2,"map", (pfunc_type)ff_map, 0},
		1532	{0,TOK_FN2,"min", (pfunc_type)ff_min, 0},
		1533	{0,TOK_FN2,"max", (pfunc_type)ff_max, 0},
		1534	{0,TOK_FN1,"abs", (pfunc_type)ff_abs, 0},
		1535	{0,TOK_FN3,"add", (pfunc_type)ff_add, 0},
		1536	{0,TOK_FN3,"sub", (pfunc_type)ff_sub, 0},
		1537	{0,TOK_FN2,"dif", (pfunc_type)ff_dif, 0},
		1538	{0,TOK_FN2,"rnd", (pfunc_type)ff_rnd, 0},
		1539	{0,TOK_FN4,"mix", (pfunc_type)ff_mix, 0},
		1540	{0,TOK_FN5,"scl", (pfunc_type)ff_scl, 0},
		1541	{0,TOK_FN1,"sqr", (pfunc_type)ff_sqr, 0},
		1542	{0,TOK_FN1,"sqrt", (pfunc_type)ff_sqr, 0}, // sqrt() is synonym to sqr() in Premiere
		1543	{0,TOK_FN1,"sin", (pfunc_type)ff_sin, 0},
		1544	{0,TOK_FN1,"cos", (pfunc_type)ff_cos, 0},
		1545	{0,TOK_FN1,"tan", (pfunc_type)ff_tan, 0},
		1546	{0,TOK_FN2,"r2x", (pfunc_type)ff_r2x, 0},
		1547	{0,TOK_FN2,"r2y", (pfunc_type)ff_r2y, 0},
		1548	{0,TOK_FN2,"c2d", (pfunc_type)ff_c2d, 0},
		1549	{0,TOK_FN2,"c2m", (pfunc_type)ff_c2m, 0},
		1550	{0,TOK_FN1,"get", (pfunc_type)ff_get, 0},
		1551	{0,TOK_FN2,"put", (pfunc_type)ff_put, 0},
		1552	{0,TOK_FN10,"cnv",(pfunc_type)ff_cnv, 0},
		1553	{0,TOK_FN1,"rst", (pfunc_type)ff_rst, 0}, // undocumented FilterFactory function
		1554
		1555	/* predefined variables (names with more than 1 character); most of them are undocumented in FilterFactory */
		1556	/* the predefined variables with 1 character are defined in lexer.l and process.c */
		1557	/* in this table, you must not add TOK_VAR with only 1 character (since this case is not defined in parser.y) */
		1558
		1559	{0,TOK_VAR,"rmax",0, &max_channel_val}, // alias of 'R' (defined in lexer.l, line 129)
		1560	{0,TOK_VAR,"gmax",0, &max_channel_val}, // alias of 'G' (defined in lexer.l, line 129)
		1561	{0,TOK_VAR,"bmax",0, &max_channel_val}, // alias of 'B' (defined in lexer.l, line 129)
		1562	{0,TOK_VAR,"amax",0, &max_channel_val}, // alias of 'A' (defined in lexer.l, line 129)
		1563	{0,TOK_VAR,"cmax",0, &max_channel_val}, // alias of 'C' (defined in lexer.l, line 129)
		1564	{0,TOK_VAR,"imax",0, &max_channel_val}, // alias of 'I' (defined in lexer.l, line 129)
		1565	{0,TOK_VAR,"umax",0, &max_channel_val}, // alias of 'U' (defined in lexer.l, line 129)
		1566	{0,TOK_VAR,"vmax",0, &max_channel_val}, // alias of 'V' (defined in lexer.l, line 129)
		1567	{0,TOK_VAR,"dmax",0, &var['D']},
		1568	{0,TOK_VAR,"mmax",0, &var['M']},
		1569	{0,TOK_VAR,"pmax",0, &var['Z']},
		1570	{0,TOK_VAR,"xmax",0, &var['X']},
		1571	{0,TOK_VAR,"ymax",0, &var['Y']},
		1572	{0,TOK_VAR,"zmax",0, &var['Z']},
		1573
		1574	{0,TOK_VAR,"rmin",0, &zero_val},
		1575	{0,TOK_VAR,"gmin",0, &zero_val},
		1576	{0,TOK_VAR,"bmin",0, &zero_val},
		1577	{0,TOK_VAR,"amin",0, &zero_val},
		1578	{0,TOK_VAR,"cmin",0, &zero_val},
		1579	{0,TOK_VAR,"imin",0, &zero_val},
		1580	{0,TOK_VAR,"umin",0, &zero_val},
		1581	{0,TOK_VAR,"vmin",0, &zero_val},
		1582	{0,TOK_VAR,"dmin",0, &zero_val},
		1583	{0,TOK_VAR,"mmin",0, &zero_val},
		1584	{0,TOK_VAR,"pmin",0, &zero_val},
		1585	{0,TOK_VAR,"xmin",0, &zero_val},
		1586	{0,TOK_VAR,"ymin",0, &zero_val},
		1587	{0,TOK_VAR,"zmin",0, &zero_val},
		1588
		1589	/* Undocumented synonyms of FilterFactory for compatibility with Premiere */
		1590	{0,TOK_FN10,"cnv0",(pfunc_type)ff_cnv, 0},
		1591	{0,TOK_FN3,"src0", (pfunc_type)ff_src, 0},
		1592	{0,TOK_FN3,"rad0", (pfunc_type)ff_rad, 0},
		1593	{0,TOK_FN10,"cnv1",(pfunc_type)ff_cnv, 0},
		1594	{0,TOK_FN3,"src1", (pfunc_type)ff_src, 0},
		1595	{0,TOK_FN3,"rad1", (pfunc_type)ff_rad, 0},
		1596	{0,TOK_VAR,"r0",0, &var['r']},
		1597	{0,TOK_VAR,"g0",0, &var['g']},
		1598	{0,TOK_VAR,"b0",0, &var['b']},
		1599	{0,TOK_VAR,"a0",0, &var['a']},
		1600	{0,TOK_VAR,"c0",0, &var['c']},
		1601	{0,TOK_VAR,"i0",0, &var['i']},
		1602	{0,TOK_VAR,"u0",0, &var['u']},
		1603	{0,TOK_VAR,"v0",0, &var['v']},
		1604	{0,TOK_VAR,"d0",0, &var['d']},
		1605	{0,TOK_VAR,"m0",0, &var['m']},
		1606	{0,TOK_VAR,"r1",0, &var['r']},
		1607	{0,TOK_VAR,"g1",0, &var['g']},
		1608	{0,TOK_VAR,"b1",0, &var['b']},
		1609	{0,TOK_VAR,"a1",0, &var['a']},
		1610	{0,TOK_VAR,"c1",0, &var['c']},
		1611	{0,TOK_VAR,"i1",0, &var['i']},
		1612	{0,TOK_VAR,"u1",0, &var['u']},
		1613	{0,TOK_VAR,"v1",0, &var['v']},
		1614	{0,TOK_VAR,"d1",0, &var['d']},
		1615	{0,TOK_VAR,"m1",0, &var['m']},
		1616	{0,TOK_VAR,"tmin",0, &zero_val},
		1617	{0,TOK_VAR,"tmax",0, &one_val},
		1618	{0,TOK_VAR,"total",0, &one_val},
		1619
		1620	{0,0,0,0,0}
		1621	};

Subversion Repositories filter_foundry

filter_foundry/trunk/funcs.c @ 503 – Rev 297