svn merge -r 14236:14505 https://svn.blender.org/svnroot/bf-blender/trunk/blender
[blender-staging.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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, 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 "BLI_blenlib.h"  /* util and noise functions */
54 #include "BLI_threads.h"  /* For threadsfe guardedalloc malloc/calloc/free */
55 #include "IMB_imbuf.h"    /* image buffer stuff       */
56
57 /* -------------------------------------------------------------------------- */
58 /* stuff from util.h                                                          */ 
59 /* -------------------------------------------------------------------------- */
60
61 LIBEXPORT void *mallocN(int len, char *str)
62 {
63         return MEM_mallocN(len, str);
64 }
65
66 LIBEXPORT void *callocN(int len, char *str)
67 {
68         return MEM_callocN(len, str);
69 }
70
71 LIBEXPORT short freeN(void *vmemh)
72 {
73         return MEM_freeN(vmemh);
74 }
75
76 /* these are not needed anymore, mallocN/callocN/freeN is now threadsafe */
77 LIBEXPORT void *mallocT(int len, char *str)
78 {
79         return MEM_mallocN(len, str);
80 }
81
82 LIBEXPORT void *callocT(int len, char *str)
83 {
84         return MEM_callocN(len, str);
85 }
86
87 LIBEXPORT void freeT(void *vmemh)
88 {
89         MEM_freeN(vmemh);
90         return;
91 }
92
93
94 /* -------------------------------------------------------------------------- */
95 /* stuff from iff.h                                                           */ 
96 /* -------------------------------------------------------------------------- */
97
98 LIBEXPORT struct ImBuf *allocImBuf(short x,
99                                                  short y,
100                                                  uchar d,
101                                                  uint flags,
102                                                  uchar bitmap)
103 {
104         return IMB_allocImBuf(x, y, d, flags, bitmap);
105 }
106
107
108 LIBEXPORT struct ImBuf *dupImBuf(struct ImBuf *ib)
109 {
110         return IMB_dupImBuf(ib);
111 }
112         
113 LIBEXPORT void freeImBuf(struct ImBuf* ib)
114 {
115         IMB_freeImBuf(ib);
116 }
117
118 LIBEXPORT short converttocmap(struct ImBuf* ibuf)
119 {
120         return IMB_converttocmap(ibuf);
121 }
122
123 LIBEXPORT short saveiff(struct ImBuf *ib,
124                           char *c,
125                           int i)
126 {
127         return IMB_saveiff(ib, c, i);
128 }
129
130 LIBEXPORT struct ImBuf *loadiffmem(int *mem,int flags)
131 {
132         return IMB_loadiffmem(mem, flags);
133 }
134         
135 LIBEXPORT struct ImBuf *loadifffile(int a,
136                                                   int b)
137 {
138         return IMB_loadifffile(a, b);
139 }
140
141 LIBEXPORT struct ImBuf *loadiffname(char *n,
142                                                   int flags)
143 {
144         return IMB_loadiffname(n, flags);
145 }
146         
147 LIBEXPORT struct ImBuf *testiffname(char *n,
148                                                   int flags)
149 {
150         return IMB_testiffname(n, flags);
151 }
152
153 LIBEXPORT struct ImBuf *onehalf(struct ImBuf *ib)
154 {
155         return IMB_onehalf(ib);
156 }
157
158 LIBEXPORT struct ImBuf *onethird(struct ImBuf *ib)
159 {
160         return IMB_onethird(ib);
161 }
162
163 LIBEXPORT struct ImBuf *halflace(struct ImBuf *ib)
164 {
165         return IMB_halflace(ib);
166 }
167
168 LIBEXPORT struct ImBuf *half_x(struct ImBuf *ib)
169 {
170         return IMB_half_x(ib);
171 }
172
173 LIBEXPORT struct ImBuf *half_y(struct ImBuf *ib)
174 {
175         return IMB_half_y(ib);
176 }
177
178 LIBEXPORT struct ImBuf *double_x(struct ImBuf *ib)
179 {
180         return IMB_double_x(ib);
181 }
182
183 LIBEXPORT struct ImBuf *double_y(struct ImBuf *ib)
184 {
185         return IMB_double_y(ib);
186 }
187
188 LIBEXPORT struct ImBuf *double_fast_x(struct ImBuf *ib)
189 {
190         return IMB_double_fast_x(ib);
191 }
192
193 LIBEXPORT struct ImBuf *double_fast_y(struct ImBuf *ib)
194 {
195         return IMB_double_fast_y(ib);
196 }
197
198 LIBEXPORT int ispic(char * name)
199 {
200         return IMB_ispic(name);
201 }
202
203 LIBEXPORT void dit2(struct ImBuf *ib,
204                    short a,
205                    short b)
206 {
207         IMB_dit2(ib, a, b);
208 }
209
210 LIBEXPORT void dit0(struct ImBuf *ib,
211                    short a,
212                    short b)
213 {
214         IMB_dit0(ib, a, b);
215 }
216
217 /* still the same name */
218 /*  void (*ditherfunc)(struct ImBuf *, short, short){} */
219
220 LIBEXPORT struct ImBuf *scaleImBuf(struct ImBuf *ib,
221                                                  short nx,
222                                                  short ny)
223 {
224         return IMB_scaleImBuf(ib, nx, ny);
225 }
226
227 LIBEXPORT struct ImBuf *scalefastImBuf(struct ImBuf *ib,
228                                                          short x,
229                                                          short y)
230 {
231         return IMB_scalefastImBuf(ib, x, y);
232 }
233
234
235 LIBEXPORT struct ImBuf *scalefieldImBuf(struct ImBuf *ib,
236                                                           short x,
237                                                           short y)
238 {
239         return IMB_scalefieldImBuf(ib, x, y);
240 }
241
242 LIBEXPORT struct ImBuf *scalefastfieldImBuf(struct ImBuf *ib,
243                                                                   short x,
244                                                                   short y)
245 {
246         return IMB_scalefastfieldImBuf(ib, x, y);
247 }
248
249         /* Extra ones that some NaN (read Ton) plugins use,
250          * even though they aren't in the header
251          */
252
253 LIBEXPORT void interlace(struct ImBuf *ibuf)
254 {
255         IMB_interlace(ibuf);
256 }
257
258 LIBEXPORT void gamwarp(struct ImBuf *ibuf, double gamma)
259 {
260         IMB_gamwarp(ibuf,gamma);
261 }
262          
263 LIBEXPORT void de_interlace(struct ImBuf *ib)
264 {
265         IMB_de_interlace(ib);
266 }
267
268 /* -------------------------------------------------------------------------- */
269 /* stuff from plugin.h                                                        */ 
270 /* -------------------------------------------------------------------------- */
271
272 /* These three need to be defined in the plugion itself. The plugin
273  * loader looks for these functions to check whether it can use the
274  * plugin. For sequences, something similar exists. */
275 /*  int plugin_tex_getversion(void); */
276 /*  int plugin_seq_getversion(void); */
277 /*  void plugin_getinfo(PluginInfo *); */
278
279 LIBEXPORT float hnoise(float noisesize,
280                          float x,
281                          float y,
282                          float z)
283 {
284         return BLI_hnoise(noisesize, x, y, z);
285 }
286
287 LIBEXPORT float hnoisep(float noisesize,
288                           float x,
289                           float y,
290                           float z)
291 {
292         return BLI_hnoisep(noisesize, x, y, z);
293 }
294
295 LIBEXPORT float turbulence(float noisesize,
296                                  float x,
297                                  float y,
298                                  float z,
299                                  int depth)
300 {
301         return BLI_turbulence(noisesize, x, y, z, depth);
302 }
303
304 LIBEXPORT float turbulence1(float noisesize,
305                                   float x,
306                                   float y,
307                                   float z,
308                                   int depth)
309 {
310         return BLI_turbulence1(noisesize, x, y, z, depth);
311 }
312
313 /* -------------------------------------------------------------------------- */
314
315         /* Stupid hack - force the inclusion of all of the
316          * above functions in the binary by 'using' each one...
317          * Otherwise they will not be imported from the archive
318          * library on Unix. -zr
319          */
320 int pluginapi_force_ref(void); 
321
322 int pluginapi_force_ref(void) 
323 {
324         return (int) mallocN +
325                 (int) callocN +
326                 (int) freeN +
327                 (int) mallocT +
328                 (int) callocT +
329                 (int) freeT +
330                 (int) allocImBuf +
331                 (int) dupImBuf +
332                 (int) freeImBuf +
333                 (int) converttocmap +
334                 (int) saveiff +
335                 (int) loadiffmem +
336                 (int) loadifffile +
337                 (int) loadiffname +
338                 (int) testiffname +
339                 (int) onehalf +
340                 (int) onethird +
341                 (int) halflace +
342                 (int) half_x +
343                 (int) half_y +
344                 (int) double_x +
345                 (int) double_y +
346                 (int) double_fast_x +
347                 (int) double_fast_y +
348                 (int) ispic +
349                 (int) dit2 +
350                 (int) dit0 +
351                 (int) scaleImBuf +
352                 (int) scalefastImBuf +
353                 (int) scalefieldImBuf +
354                 (int) scalefastfieldImBuf +
355                 (int) hnoise +
356                 (int) hnoisep +
357                 (int) turbulence +
358                 (int) turbulence1 +
359                 (int) de_interlace +
360                 (int) interlace +
361                 (int) gamwarp;
362 }