doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / blender / blenpluginapi / intern / pluginapi.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (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 Foundation,
18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
19  *
20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  * Wrappers for the plugin api. This api is up for removal.
29  */
30
31 /* There are four headers making up the plugin api:
32  * - floatpatch.h : Wraps math functions for mips platforms, no code
33  *                  required.
34  * - iff.h        : Defines, macros and functions for dealing
35  *                  with image buffer things.
36  * - plugin.h     : Wraps some plugin handling types, accesses noise
37  *                  functions.
38  * - util.h       : Useful defines, memory management.
39  */
40
41 #define PLUGIN_INTERN /* This tells the LIBEXPORT macro to compile with
42         dll export set on windows */
43
44 #ifdef WIN32
45 #include "blenpluginapi/util.h"
46 #else
47 #include "blenpluginapi/util.h"
48 #endif
49 #include "iff.h"
50 #include "plugin.h"
51 #include "MEM_guardedalloc.h"
52
53 #include "BLO_sys_types.h" // needed for intptr_t
54
55 #include "BLI_blenlib.h"  /* util and noise functions */
56 #include "BLI_threads.h"  /* For threadsfe guardedalloc malloc/calloc/free */
57 #include "IMB_imbuf.h"    /* image buffer stuff       */
58 #define GET_INT_FROM_POINTER(i) ((int)(intptr_t)(i)) /* should use BKE_utildefines.h */
59
60 /* -------------------------------------------------------------------------- */
61 /* stuff from util.h                                                          */ 
62 /* -------------------------------------------------------------------------- */
63
64 LIBEXPORT void *mallocN(int len, char *str)
65 {
66         return MEM_mallocN(len, str);
67 }
68
69 LIBEXPORT void *callocN(int len, char *str)
70 {
71         return MEM_callocN(len, str);
72 }
73
74 LIBEXPORT short freeN(void *vmemh)
75 {
76         return MEM_freeN(vmemh);
77 }
78
79 /* these are not needed anymore, mallocN/callocN/freeN is now threadsafe */
80 LIBEXPORT void *mallocT(int len, char *str)
81 {
82         return MEM_mallocN(len, str);
83 }
84
85 LIBEXPORT void *callocT(int len, char *str)
86 {
87         return MEM_callocN(len, str);
88 }
89
90 LIBEXPORT void freeT(void *vmemh)
91 {
92         MEM_freeN(vmemh);
93         return;
94 }
95
96
97 /* -------------------------------------------------------------------------- */
98 /* stuff from iff.h                                                           */ 
99 /* -------------------------------------------------------------------------- */
100
101 LIBEXPORT struct ImBuf *allocImBuf(short x,
102                                                  short y,
103                                                  uchar d,
104                                                  uint flags)
105 {
106         return IMB_allocImBuf(x, y, d, flags);
107 }
108
109
110 LIBEXPORT struct ImBuf *dupImBuf(struct ImBuf *ib)
111 {
112         return IMB_dupImBuf(ib);
113 }
114         
115 LIBEXPORT void freeImBuf(struct ImBuf* ib)
116 {
117         IMB_freeImBuf(ib);
118 }
119
120 LIBEXPORT short saveiff(struct ImBuf *ib,
121                           char *c,
122                           int i)
123 {
124         return IMB_saveiff(ib, c, i);
125 }
126
127 LIBEXPORT struct ImBuf *loadifffile(int a,
128                                                   int b)
129 {
130         return IMB_loadifffile(a, b);
131 }
132
133 LIBEXPORT struct ImBuf *loadiffname(char *n,
134                                                   int flags)
135 {
136         return IMB_loadiffname(n, flags);
137 }
138         
139 LIBEXPORT struct ImBuf *testiffname(char *n,
140                                                   int flags)
141 {
142         return IMB_testiffname(n, flags);
143 }
144
145 LIBEXPORT struct ImBuf *onehalf(struct ImBuf *ib)
146 {
147         return IMB_onehalf(ib);
148 }
149
150 LIBEXPORT struct ImBuf *half_x(struct ImBuf *ib)
151 {
152         return IMB_half_x(ib);
153 }
154
155 LIBEXPORT struct ImBuf *half_y(struct ImBuf *ib)
156 {
157         return IMB_half_y(ib);
158 }
159
160 LIBEXPORT struct ImBuf *double_x(struct ImBuf *ib)
161 {
162         return IMB_double_x(ib);
163 }
164
165 LIBEXPORT struct ImBuf *double_y(struct ImBuf *ib)
166 {
167         return IMB_double_y(ib);
168 }
169
170 LIBEXPORT struct ImBuf *double_fast_x(struct ImBuf *ib)
171 {
172         return IMB_double_fast_x(ib);
173 }
174
175 LIBEXPORT struct ImBuf *double_fast_y(struct ImBuf *ib)
176 {
177         return IMB_double_fast_y(ib);
178 }
179
180 LIBEXPORT int ispic(char * name)
181 {
182         return IMB_ispic(name);
183 }
184
185 /* still the same name */
186 /*  void (*ditherfunc)(struct ImBuf *, short, short){} */
187
188 LIBEXPORT struct ImBuf *scaleImBuf(struct ImBuf *ib,
189                                                  short nx,
190                                                  short ny)
191 {
192         return IMB_scaleImBuf(ib, nx, ny);
193 }
194
195 LIBEXPORT struct ImBuf *scalefastImBuf(struct ImBuf *ib,
196                                                          short x,
197                                                          short y)
198 {
199         return IMB_scalefastImBuf(ib, x, y);
200 }
201
202         /* Extra ones that some NaN (read Ton) plugins use,
203          * even though they aren't in the header
204          */
205
206 LIBEXPORT void interlace(struct ImBuf *ibuf)
207 {
208         IMB_interlace(ibuf);
209 }
210
211 LIBEXPORT void de_interlace(struct ImBuf *ib)
212 {
213         IMB_de_interlace(ib);
214 }
215
216 /* -------------------------------------------------------------------------- */
217 /* stuff from plugin.h                                                        */ 
218 /* -------------------------------------------------------------------------- */
219
220 /* These three need to be defined in the plugion itself. The plugin
221  * loader looks for these functions to check whether it can use the
222  * plugin. For sequences, something similar exists. */
223 /*  int plugin_tex_getversion(void); */
224 /*  int plugin_seq_getversion(void); */
225 /*  void plugin_getinfo(PluginInfo *); */
226
227 LIBEXPORT float hnoise(float noisesize,
228                          float x,
229                          float y,
230                          float z)
231 {
232         return BLI_hnoise(noisesize, x, y, z);
233 }
234
235 LIBEXPORT float hnoisep(float noisesize,
236                           float x,
237                           float y,
238                           float z)
239 {
240         return BLI_hnoisep(noisesize, x, y, z);
241 }
242
243 LIBEXPORT float turbulence(float noisesize,
244                                  float x,
245                                  float y,
246                                  float z,
247                                  int depth)
248 {
249         return BLI_turbulence(noisesize, x, y, z, depth);
250 }
251
252 LIBEXPORT float turbulence1(float noisesize,
253                                   float x,
254                                   float y,
255                                   float z,
256                                   int depth)
257 {
258         return BLI_turbulence1(noisesize, x, y, z, depth);
259 }
260
261 /* -------------------------------------------------------------------------- */
262
263         /* Stupid hack - force the inclusion of all of the
264          * above functions in the binary by 'using' each one...
265          * Otherwise they will not be imported from the archive
266          * library on Unix. -zr
267          */
268 int pluginapi_force_ref(void); 
269
270 int pluginapi_force_ref(void) 
271 {
272         return 
273                 GET_INT_FROM_POINTER( mallocN ) +
274                 GET_INT_FROM_POINTER( callocN ) +
275                 GET_INT_FROM_POINTER( freeN ) +
276                 GET_INT_FROM_POINTER( mallocT ) +
277                 GET_INT_FROM_POINTER( callocT ) +
278                 GET_INT_FROM_POINTER( freeT ) +
279                 GET_INT_FROM_POINTER( allocImBuf ) +
280                 GET_INT_FROM_POINTER( dupImBuf ) +
281                 GET_INT_FROM_POINTER( freeImBuf ) +
282                 GET_INT_FROM_POINTER( saveiff ) +
283                 GET_INT_FROM_POINTER( loadifffile ) +
284                 GET_INT_FROM_POINTER( loadiffname ) +
285                 GET_INT_FROM_POINTER( testiffname ) +
286                 GET_INT_FROM_POINTER( onehalf ) +
287                 GET_INT_FROM_POINTER( half_x ) +
288                 GET_INT_FROM_POINTER( half_y ) +
289                 GET_INT_FROM_POINTER( double_x ) +
290                 GET_INT_FROM_POINTER( double_y ) +
291                 GET_INT_FROM_POINTER( double_fast_x ) +
292                 GET_INT_FROM_POINTER( double_fast_y ) +
293                 GET_INT_FROM_POINTER( ispic ) +
294                 GET_INT_FROM_POINTER( scaleImBuf ) +
295                 GET_INT_FROM_POINTER( scalefastImBuf ) +
296                 GET_INT_FROM_POINTER( hnoise ) +
297                 GET_INT_FROM_POINTER( hnoisep ) +
298                 GET_INT_FROM_POINTER( turbulence ) +
299                 GET_INT_FROM_POINTER( turbulence1 ) +
300                 GET_INT_FROM_POINTER( de_interlace ) +
301                 GET_INT_FROM_POINTER( interlace );
302 }