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

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

Subversion Repositories filter_foundry

filter_foundry/trunk/funcs.c – Rev 503