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
301	daniel-mar	256	extern uint8_t slider[],map[][0x100];
		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;
		507	*/
		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) {
		1119	eax = 27146; // 27146/65536 == sqrt(1)-1
		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
294	daniel-mar	1234	return factory_d();
297	daniel-mar	1235	#else
294	daniel-mar	1236	return foundry_d();
297	daniel-mar	1237	#endif
294	daniel-mar	1238	}
		1239
		1240	// -------------------------------------------------------------------------------------------
		1241
295	daniel-mar	1242	/* Range of magnitudes with the image, where M is one half the diagonal size of the image */
		1243
294	daniel-mar	1244	value_type factory_M() {
297	daniel-mar	1245	#ifdef PARSERTEST
		1246	return 0;
		1247	#else
295	daniel-mar	1248	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_uppercase.html
		1249
		1250	int eax, ebx;
		1251	const int xmin = 0, ymin = 0;
		1252
		1253	eax = (var['X'] - xmin) >> 1;
		1254	ebx = (var['Y'] - ymin) >> 1;
		1255	if (eax == ebx) {
		1256	eax = 27146; // 27146/65536 == sqrt(1)-1
		1257	}
		1258	else {
		1259	if (eax > ebx) {
		1260	int tmp = eax;
		1261	eax = ebx;
		1262	ebx = tmp;
		1263	}
		1264	eax = eax << 10;
		1265	eax /= ebx;
		1266	eax = FACTORY_C2M_LOOKUP[eax];
		1267	}
		1268	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1269	eax += ebx;
		1270	return eax;
297	daniel-mar	1271	#endif
294	daniel-mar	1272	}
		1273
		1274	value_type foundry_M() {
297	daniel-mar	1275	#ifdef PARSERTEST
		1276	return 0;
		1277	#else
294	daniel-mar	1278	return foundry_c2m(var['X'], var['Y']) / 2;
297	daniel-mar	1279	#endif
294	daniel-mar	1280	}
		1281
		1282	value_type ff_M() {
297	daniel-mar	1283	#ifdef use_filterfactory_implementation_M
294	daniel-mar	1284	return factory_M();
297	daniel-mar	1285	#else
294	daniel-mar	1286	return foundry_M();
297	daniel-mar	1287	#endif
294	daniel-mar	1288	}
		1289
		1290	// -------------------------------------------------------------------------------------------
		1291
295	daniel-mar	1292	/* Distance (magnitude) from the center of the image to the current pixel */
		1293
294	daniel-mar	1294	value_type factory_m() {
297	daniel-mar	1295	#ifdef PARSERTEST
		1296	return 0;
		1297	#else
295	daniel-mar	1298	// https://misc.daniel-marschall.de/projects/filter_factory/symbol_m_lowercase.html
		1299
		1300	int eax, ebx;
		1301	const int xmin = 0, ymin = 0;
		1302
		1303	eax = ((xmin - var['X']) >> 1) + var['x'];
		1304	ebx = ((ymin - var['Y']) >> 1) + var['y'];
		1305	eax = eax < 0 ? -eax : eax;
		1306	ebx = ebx < 0 ? -ebx : ebx;
		1307
		1308	if (eax == ebx) {
		1309	eax = 27146; // 27146/65536 == sqrt(1)-1
		1310	}
		1311	else {
		1312	if (eax > ebx) {
		1313	int tmp = eax;
		1314	eax = ebx;
		1315	ebx = tmp;
		1316	}
		1317	eax = FACTORY_C2M_LOOKUP[1024 * eax / ebx];
		1318	}
		1319	eax = ((int64_t)eax * (int64_t)ebx) >> 16;
		1320	eax += ebx;
		1321	return eax;
297	daniel-mar	1322	#endif
294	daniel-mar	1323	}
		1324
		1325	value_type foundry_m() {
297	daniel-mar	1326	#ifdef PARSERTEST
		1327	return 0;
		1328	#else
294	daniel-mar	1329	return foundry_c2m(var['X'] / 2 - var['x'], var['Y'] / 2 - var['y']);
297	daniel-mar	1330	#endif
294	daniel-mar	1331	}
		1332
		1333	value_type ff_m() {
297	daniel-mar	1334	#ifdef use_filterfactory_implementation_m
294	daniel-mar	1335	return factory_m();
297	daniel-mar	1336	#else
294	daniel-mar	1337	return foundry_m();
297	daniel-mar	1338	#endif
294	daniel-mar	1339	}
		1340
		1341	// -------------------------------------------------------------------------------------------
		1342
295	daniel-mar	1343	/* "Y" value of the YUV color-space */
		1344
294	daniel-mar	1345	value_type factory_i() {
297	daniel-mar	1346	#ifdef PARSERTEST
		1347	return 0;
		1348	#else
294	daniel-mar	1349	return ((76L * var['r']) + (150L * var['g']) + (29L * var['b'])) / 256; // range: [0..254]
297	daniel-mar	1350	#endif
294	daniel-mar	1351	}
		1352
		1353	value_type foundry_i() {
297	daniel-mar	1354	#ifdef PARSERTEST
		1355	return 0;
		1356	#else
294	daniel-mar	1357	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1358	return ((299L * var['r']) + (587L * var['g']) + (114L * var['b'])) / 1000; // range: [0..255]
297	daniel-mar	1359	#endif
294	daniel-mar	1360	}
		1361
		1362	value_type ff_i() {
297	daniel-mar	1363	#ifdef use_filterfactory_implementation_i
294	daniel-mar	1364	return factory_i();
297	daniel-mar	1365	#else
294	daniel-mar	1366	return foundry_i();
297	daniel-mar	1367	#endif
294	daniel-mar	1368	}
		1369
		1370	// -------------------------------------------------------------------------------------------
		1371
295	daniel-mar	1372	/* "U" value of the YUV color-space */
		1373
294	daniel-mar	1374	value_type factory_u() {
297	daniel-mar	1375	#ifdef PARSERTEST
		1376	return 0;
		1377	#else
294	daniel-mar	1378	return ((-19L * var['r']) + (-37L * var['g']) + (56L * var['b'])) / 256; // range: [-55..55]
297	daniel-mar	1379	#endif
294	daniel-mar	1380	}
		1381
		1382	value_type foundry_u() {
297	daniel-mar	1383	#ifdef PARSERTEST
		1384	return 0;
		1385	#else
294	daniel-mar	1386	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1387	return ((-147407L * var['r']) + (-289391L * var['g']) + (436798L * var['b'])) / 2000000; // range: [-55..55]
297	daniel-mar	1388	#endif
294	daniel-mar	1389	}
		1390
		1391	value_type ff_u() {
297	daniel-mar	1392	#ifdef use_filterfactory_implementation_u
294	daniel-mar	1393	return factory_u();
297	daniel-mar	1394	#else
294	daniel-mar	1395	return foundry_u();
297	daniel-mar	1396	#endif
294	daniel-mar	1397	}
		1398
		1399	// -------------------------------------------------------------------------------------------
		1400
295	daniel-mar	1401	/* "V" value of the YUV color-space */
		1402
294	daniel-mar	1403	value_type factory_v() {
297	daniel-mar	1404	#ifdef PARSERTEST
		1405	return 0;
		1406	#else
294	daniel-mar	1407	return ((78L * var['r']) + (-65L * var['g']) + (-13L * var['b'])) / 256; // range: [-77..77]
297	daniel-mar	1408	#endif
294	daniel-mar	1409	}
		1410
		1411	value_type foundry_v() {
297	daniel-mar	1412	#ifdef PARSERTEST
		1413	return 0;
		1414	#else
294	daniel-mar	1415	// These formulas are more accurate, e.g. pure white has now i=255 instead of 254
		1416	return ((614777L * var['r']) + (-514799L * var['g']) + (-99978L * var['b'])) / 2000000; // range: [-78..78]
297	daniel-mar	1417	#endif
294	daniel-mar	1418	}
		1419
		1420	value_type ff_v() {
297	daniel-mar	1421	#ifdef use_filterfactory_implementation_v
294	daniel-mar	1422	return factory_v();
297	daniel-mar	1423	#else
294	daniel-mar	1424	return foundry_v();
297	daniel-mar	1425	#endif
294	daniel-mar	1426	}
		1427
		1428	// -------------------------------------------------------------------------------------------
		1429
259	daniel-mar	1430	/* get(i) Returns the current cell value at i */
		1431
297	daniel-mar	1432	value_type factory_get(value_type i) {
		1433	#ifdef PARSERTEST
		1434	return 0;
		1435	#else
		1436	return i>=0 && i<NUM_CELLS ? cell[i] : i;
		1437	#endif
259	daniel-mar	1438	}
		1439
297	daniel-mar	1440	value_type foundry_get(value_type i) {
		1441	#ifdef PARSERTEST
		1442	return 0;
		1443	#else
		1444	return i >= 0 && i < NUM_CELLS ? cell[i] : 0;
		1445	#endif
		1446	}
		1447
		1448	value_type ff_get(value_type i) {
		1449	#ifdef use_filterfactory_implementation_get
		1450	return factory_get(i);
		1451	#else
		1452	return foundry_get(i);
		1453	#endif
		1454	}
		1455
294	daniel-mar	1456	// -------------------------------------------------------------------------------------------
		1457
259	daniel-mar	1458	/* put(v,i) Puts the new value v into cell i */
		1459	value_type ff_put(value_type v,value_type i){
297	daniel-mar	1460	#ifdef PARSERTEST
		1461	return 0;
		1462	#else
259	daniel-mar	1463	if(i>=0 && i<NUM_CELLS)
		1464	cell[i] = v;
		1465	return v;
297	daniel-mar	1466	#endif
259	daniel-mar	1467	}
		1468
294	daniel-mar	1469	// -------------------------------------------------------------------------------------------
		1470
259	daniel-mar	1471	/* Convolve. Applies a convolution matrix and divides with d. */
		1472	value_type ff_cnv(value_type m11,value_type m12,value_type m13,
291	daniel-mar	1473	value_type m21,value_type m22,value_type m23,
		1474	value_type m31,value_type m32,value_type m33,
		1475	value_type d)
259	daniel-mar	1476	{
297	daniel-mar	1477	#ifdef PARSERTEST
259	daniel-mar	1478	return 0;
297	daniel-mar	1479	#else
259	daniel-mar	1480	long total;
		1481	int x, y, z;
		1482	// shift x,y from selection-relative to image relative
		1483	if (HAS_BIG_DOC(gpb)) {
		1484	x = var['x'] + BIGDOC_FILTER_RECT(gpb).left;
		1485	y = var['y'] + BIGDOC_FILTER_RECT(gpb).top;
		1486	} else {
		1487	x = var['x'] + FILTER_RECT(gpb).left;
		1488	y = var['y'] + FILTER_RECT(gpb).top;
		1489	}
		1490	z = var['z'];
		1491
		1492	if(z >= 0 && z < var['Z'])
		1493	total = m11rawsrc(x-1,y-1,z) + m12rawsrc(x,y-1,z) + m13*rawsrc(x+1,y-1,z)
		1494	+ m21rawsrc(x-1,y, z) + m22rawsrc(x,y, z) + m23*rawsrc(x+1,y, z)
		1495	+ m31rawsrc(x-1,y+1,z) + m32rawsrc(x,y+1,z) + m33*rawsrc(x+1,y+1,z);
		1496	else
		1497	total = 0;
		1498
		1499	return d ? total/d : 0;
297	daniel-mar	1500	#endif
259	daniel-mar	1501	}
		1502
294	daniel-mar	1503	// -------------------------------------------------------------------------------------------
259	daniel-mar	1504
		1505	value_type zero_val = 0;
		1506	value_type one_val = 1;
		1507
335	daniel-mar	1508	value_type min_val_i = 0;
		1509	value_type max_val_i = 255;
		1510	value_type val_I = 255;
304	daniel-mar	1511
335	daniel-mar	1512	#ifdef use_filterfactory_implementation_u_minmax
		1513	value_type min_val_u = 0;
		1514	value_type max_val_u = 255;
304	daniel-mar	1515	#else
335	daniel-mar	1516	value_type min_val_u = -55;
		1517	value_type max_val_u = 55;
304	daniel-mar	1518	#endif
		1519
335	daniel-mar	1520	#ifdef use_filterfactory_implementation_U
		1521	value_type val_U = 255;
		1522	#else
		1523	value_type val_U = 110; // max_val_u - min_val_u;
		1524	#endif
		1525
304	daniel-mar	1526	#ifdef use_filterfactory_implementation_v_minmax
335	daniel-mar	1527	value_type min_val_v = 0;
		1528	value_type max_val_v = 255;
304	daniel-mar	1529	#else
335	daniel-mar	1530	value_type min_val_v = -78;
		1531	value_type max_val_v = 78;
304	daniel-mar	1532	#endif
		1533
335	daniel-mar	1534	#ifdef use_filterfactory_implementation_V
		1535	value_type val_V = 255;
		1536	#else
		1537	value_type val_V = 156; // max_val_v - min_val_v;
		1538	#endif
		1539
		1540	#ifdef use_filterfactory_implementation_d_minmax
		1541	value_type min_val_d = 0;
		1542	value_type max_val_d = 1024;
		1543	#else
		1544	value_type min_val_d = -512;
		1545	value_type max_val_d = 512;
		1546	#endif
		1547
		1548	#ifdef use_filterfactory_implementation_D
		1549	value_type val_D = 1024;
		1550	#else
		1551	value_type val_D = 1024; // max_val_d - min_val_d;
		1552	#endif
		1553
259	daniel-mar	1554	/* predefined symbols */
		1555	struct sym_rec predefs[]={
		1556	/* functions */
		1557
		1558	{0,TOK_FN3,"src", (pfunc_type)ff_src, 0},
		1559	{0,TOK_FN3,"rad", (pfunc_type)ff_rad, 0},
		1560	{0,TOK_FN1,"ctl", (pfunc_type)ff_ctl, 0},
		1561	{0,TOK_FN3,"val", (pfunc_type)ff_val, 0},
		1562	{0,TOK_FN2,"map", (pfunc_type)ff_map, 0},
		1563	{0,TOK_FN2,"min", (pfunc_type)ff_min, 0},
		1564	{0,TOK_FN2,"max", (pfunc_type)ff_max, 0},
		1565	{0,TOK_FN1,"abs", (pfunc_type)ff_abs, 0},
		1566	{0,TOK_FN3,"add", (pfunc_type)ff_add, 0},
		1567	{0,TOK_FN3,"sub", (pfunc_type)ff_sub, 0},
		1568	{0,TOK_FN2,"dif", (pfunc_type)ff_dif, 0},
		1569	{0,TOK_FN2,"rnd", (pfunc_type)ff_rnd, 0},
		1570	{0,TOK_FN4,"mix", (pfunc_type)ff_mix, 0},
		1571	{0,TOK_FN5,"scl", (pfunc_type)ff_scl, 0},
		1572	{0,TOK_FN1,"sqr", (pfunc_type)ff_sqr, 0},
		1573	{0,TOK_FN1,"sqrt", (pfunc_type)ff_sqr, 0}, // sqrt() is synonym to sqr() in Premiere
		1574	{0,TOK_FN1,"sin", (pfunc_type)ff_sin, 0},
		1575	{0,TOK_FN1,"cos", (pfunc_type)ff_cos, 0},
		1576	{0,TOK_FN1,"tan", (pfunc_type)ff_tan, 0},
		1577	{0,TOK_FN2,"r2x", (pfunc_type)ff_r2x, 0},
		1578	{0,TOK_FN2,"r2y", (pfunc_type)ff_r2y, 0},
		1579	{0,TOK_FN2,"c2d", (pfunc_type)ff_c2d, 0},
		1580	{0,TOK_FN2,"c2m", (pfunc_type)ff_c2m, 0},
		1581	{0,TOK_FN1,"get", (pfunc_type)ff_get, 0},
		1582	{0,TOK_FN2,"put", (pfunc_type)ff_put, 0},
		1583	{0,TOK_FN10,"cnv",(pfunc_type)ff_cnv, 0},
		1584	{0,TOK_FN1,"rst", (pfunc_type)ff_rst, 0}, // undocumented FilterFactory function
300	daniel-mar	1585	{0,TOK_FN2,"pow", (pfunc_type)ff_pow, 0}, // new function, also added in inofficial Filter Factory 3.1.0 patch
259	daniel-mar	1586
304	daniel-mar	1587	/* Predefined variables (names with more than 1 character); most of them are undocumented in Filter Factory */
		1588	/* The predefined variables with 1 character are defined in lexer.l and process.c */
		1589	/* 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	1590
335	daniel-mar	1591	{0,TOK_VAR,"rmax",0, &var['R']}, // alias of R (defined in lexer.l and set by process.c)
		1592	{0,TOK_VAR,"gmax",0, &var['G']}, // alias of G (defined in lexer.l and set by process.c)
		1593	{0,TOK_VAR,"bmax",0, &var['B']}, // alias of B (defined in lexer.l and set by process.c)
		1594	{0,TOK_VAR,"amax",0, &var['A']}, // alias of A (defined in lexer.l and set by process.c)
		1595	{0,TOK_VAR,"cmax",0, &var['C']}, // alias of C (defined in lexer.l and set by process.c)
		1596	{0,TOK_VAR,"imax",0, &max_val_i},
		1597	{0,TOK_VAR,"umax",0, &max_val_u},
		1598	{0,TOK_VAR,"vmax",0, &max_val_v},
		1599	{0,TOK_VAR,"dmax",0, &max_val_d},
		1600	{0,TOK_VAR,"mmax",0, &var['M']}, // alias of M (defined in lexer.l and set by process.c)
		1601	{0,TOK_VAR,"pmax",0, &var['Z']}, // alias of P (defined in lexer.l and set by process.c)
		1602	{0,TOK_VAR,"xmax",0, &var['X']}, // alias of X (defined in lexer.l and set by process.c)
		1603	{0,TOK_VAR,"ymax",0, &var['Y']}, // alias of Y (defined in lexer.l and set by process.c)
		1604	{0,TOK_VAR,"zmax",0, &var['Z']}, // alias of Z (defined in lexer.l and set by process.c)
259	daniel-mar	1605
		1606	{0,TOK_VAR,"rmin",0, &zero_val},
		1607	{0,TOK_VAR,"gmin",0, &zero_val},
		1608	{0,TOK_VAR,"bmin",0, &zero_val},
		1609	{0,TOK_VAR,"amin",0, &zero_val},
		1610	{0,TOK_VAR,"cmin",0, &zero_val},
335	daniel-mar	1611	{0,TOK_VAR,"imin",0, &min_val_i},
		1612	{0,TOK_VAR,"umin",0, &min_val_u},
		1613	{0,TOK_VAR,"vmin",0, &min_val_v},
		1614	{0,TOK_VAR,"dmin",0, &min_val_d},
259	daniel-mar	1615	{0,TOK_VAR,"mmin",0, &zero_val},
		1616	{0,TOK_VAR,"pmin",0, &zero_val},
		1617	{0,TOK_VAR,"xmin",0, &zero_val},
		1618	{0,TOK_VAR,"ymin",0, &zero_val},
		1619	{0,TOK_VAR,"zmin",0, &zero_val},
		1620
		1621	/* Undocumented synonyms of FilterFactory for compatibility with Premiere */
		1622	{0,TOK_FN10,"cnv0",(pfunc_type)ff_cnv, 0},
		1623	{0,TOK_FN3,"src0", (pfunc_type)ff_src, 0},
		1624	{0,TOK_FN3,"rad0", (pfunc_type)ff_rad, 0},
		1625	{0,TOK_FN10,"cnv1",(pfunc_type)ff_cnv, 0},
		1626	{0,TOK_FN3,"src1", (pfunc_type)ff_src, 0},
		1627	{0,TOK_FN3,"rad1", (pfunc_type)ff_rad, 0},
		1628	{0,TOK_VAR,"r0",0, &var['r']},
		1629	{0,TOK_VAR,"g0",0, &var['g']},
		1630	{0,TOK_VAR,"b0",0, &var['b']},
		1631	{0,TOK_VAR,"a0",0, &var['a']},
		1632	{0,TOK_VAR,"c0",0, &var['c']},
		1633	{0,TOK_VAR,"i0",0, &var['i']},
		1634	{0,TOK_VAR,"u0",0, &var['u']},
		1635	{0,TOK_VAR,"v0",0, &var['v']},
		1636	{0,TOK_VAR,"d0",0, &var['d']},
		1637	{0,TOK_VAR,"m0",0, &var['m']},
		1638	{0,TOK_VAR,"r1",0, &var['r']},
		1639	{0,TOK_VAR,"g1",0, &var['g']},
		1640	{0,TOK_VAR,"b1",0, &var['b']},
		1641	{0,TOK_VAR,"a1",0, &var['a']},
		1642	{0,TOK_VAR,"c1",0, &var['c']},
		1643	{0,TOK_VAR,"i1",0, &var['i']},
		1644	{0,TOK_VAR,"u1",0, &var['u']},
		1645	{0,TOK_VAR,"v1",0, &var['v']},
		1646	{0,TOK_VAR,"d1",0, &var['d']},
		1647	{0,TOK_VAR,"m1",0, &var['m']},
		1648	{0,TOK_VAR,"tmin",0, &zero_val},
		1649	{0,TOK_VAR,"tmax",0, &one_val},
		1650	{0,TOK_VAR,"total",0, &one_val},
		1651
		1652	{0,0,0,0,0}
		1653	};

Subversion Repositories filter_foundry

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