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

Subversion Repositories filter_foundry

filter_foundry/trunk/funcs.c – Rev 491