Fix some valgrind issues
[scilab.git] / scilab / modules / fftw / src / c / callfftw.c
1 /*
2 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3 * Copyright (C) 2006 - INRIA - Allan CORNET
4 * Copyright (C) 2012 - INRIA - Serge STEER
5 *
6 * This file must be used under the terms of the CeCILL.
7 * This source file is licensed as described in the file COPYING, which
8 * you should have received as part of this distribution.  The terms
9 * are also available at
10 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11 *
12 */
13 #include "callfftw.h"
14 /*--------------------------------------------------------------------------*/
15 #include "dynamiclibrary.h"
16 #include "getshortpathname.h"
17 #include "MALLOC.h"
18 #include "charEncoding.h"
19 /*--------------------------------------------------------------------------*/
20 typedef void (*PROC_FFTW_EXECUTE_SPLIT_DFT)     (const fftw_plan p, double *ri, double *ii, double *ro, double *io);
21 typedef void (*PROC_FFTW_EXECUTE_SPLIT_DFT_C2R) (const fftw_plan p, double *ri, double *ii, double *ro);
22 typedef void (*PROC_FFTW_EXECUTE_SPLIT_DFT_R2C) (const fftw_plan p, double *ri,             double *ro, double *io);
23 typedef void (*PROC_FFTW_EXECUTE_SPLIT_DFT_R2R) (const fftw_plan p, double *ri,             double *ro);
24 typedef fftw_plan (*PROC_FFTW_PLAN_GURU_SPLIT_DFT) (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ii, double *ro, double *io, unsigned flags);
25 typedef fftw_plan (*PROC_FFTW_PLAN_GURU_SPLIT_DFT_C2R) (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ii, double *ro, unsigned flags);
26 typedef fftw_plan (*PROC_FFTW_PLAN_GURU_SPLIT_DFT_R2C) (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ro, double *io, unsigned flags);
27 typedef fftw_plan (*PROC_FFTW_PLAN_GURU_SPLIT_DFT_R2R) (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ro, fftw_r2r_kind *kind, unsigned flags);
28 typedef void (*PROC_FFTW_DESTROY_PLAN) (fftw_plan p);
29 typedef char *(*PROC_FFTW_EXPORT_WISDOM_TO_STRING) (void);
30 typedef int (*PROC_FFTW_IMPORT_WISDOM_FROM_STRING) (const char *input_string);
31 typedef void (*PROC_FFTW_FORGET_WISDOM) (void);
32 /*--------------------------------------------------------------------------*/
33 static DynLibHandle hinstLib = NULL;
34 static PROC_FFTW_EXECUTE_SPLIT_DFT       MY_FFTW_EXECUTE_SPLIT_DFT       = NULL;
35 static PROC_FFTW_EXECUTE_SPLIT_DFT_C2R   MY_FFTW_EXECUTE_SPLIT_DFT_C2R   = NULL;
36 static PROC_FFTW_EXECUTE_SPLIT_DFT_R2C   MY_FFTW_EXECUTE_SPLIT_DFT_R2C   = NULL;
37 static PROC_FFTW_EXECUTE_SPLIT_DFT_R2R   MY_FFTW_EXECUTE_SPLIT_DFT_R2R   = NULL;
38 static PROC_FFTW_PLAN_GURU_SPLIT_DFT     MY_FFTW_PLAN_GURU_SPLIT_DFT     = NULL;
39 static PROC_FFTW_PLAN_GURU_SPLIT_DFT_C2R MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R = NULL;
40 static PROC_FFTW_PLAN_GURU_SPLIT_DFT_R2C MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C = NULL;
41 static PROC_FFTW_PLAN_GURU_SPLIT_DFT_R2R MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R = NULL;
42 static PROC_FFTW_DESTROY_PLAN            MY_FFTW_DESTROY_PLAN            = NULL;
43 static PROC_FFTW_EXPORT_WISDOM_TO_STRING MY_FFTW_EXPORT_WISDOM_TO_STRING = NULL;
44 static PROC_FFTW_IMPORT_WISDOM_FROM_STRING MY_FFTW_IMPORT_WISDOM_FROM_STRING = NULL;
45 static PROC_FFTW_FORGET_WISDOM MY_FFTW_FORGET_WISDOM = NULL;
46 /*--------------------------------------------------------------------------*/
47 BOOL IsLoadedFFTW(void)
48 {
49     if ( (MY_FFTW_EXECUTE_SPLIT_DFT) && (MY_FFTW_PLAN_GURU_SPLIT_DFT) && (MY_FFTW_DESTROY_PLAN) &&
50             (MY_FFTW_EXPORT_WISDOM_TO_STRING) && (MY_FFTW_IMPORT_WISDOM_FROM_STRING) &&
51             (MY_FFTW_FORGET_WISDOM) )
52     {
53         return TRUE;
54     }
55     return FALSE;
56 }
57 /*--------------------------------------------------------------------------*/
58 BOOL LoadFFTWLibrary(const char* libraryname)
59 {
60
61     if (libraryname == NULL)
62     {
63         return FALSE;
64     }
65     if (hinstLib == NULL)
66     {
67 #ifdef _MSC_VER
68         {
69             wchar_t * wclibraryname = to_wide_string(libraryname);
70             if (wclibraryname)
71             {
72                 hinstLib = LoadDynLibraryW(wclibraryname);
73                 FREE(wclibraryname);
74                 wclibraryname = NULL;
75             }
76         }
77 #else
78         hinstLib = LoadDynLibrary(libraryname);
79 #endif
80         MY_FFTW_EXECUTE_SPLIT_DFT        = NULL;
81         MY_FFTW_EXECUTE_SPLIT_DFT_C2R    = NULL;
82         MY_FFTW_EXECUTE_SPLIT_DFT_R2C    = NULL;
83         MY_FFTW_EXECUTE_SPLIT_DFT_R2R    = NULL;
84
85         MY_FFTW_PLAN_GURU_SPLIT_DFT      = NULL;
86         MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R  = NULL;
87         MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C  = NULL;
88         MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R  = NULL;
89
90         MY_FFTW_DESTROY_PLAN             = NULL;
91
92         MY_FFTW_EXPORT_WISDOM_TO_STRING  = NULL;
93         MY_FFTW_IMPORT_WISDOM_FROM_STRING = NULL;
94         MY_FFTW_FORGET_WISDOM            = NULL;
95
96         MY_FFTW_EXECUTE_SPLIT_DFT     = (PROC_FFTW_EXECUTE_SPLIT_DFT)     GetDynLibFuncPtr(hinstLib, "fftw_execute_split_dft");
97         MY_FFTW_EXECUTE_SPLIT_DFT_C2R = (PROC_FFTW_EXECUTE_SPLIT_DFT_C2R) GetDynLibFuncPtr(hinstLib, "fftw_execute_split_dft_c2r");
98         MY_FFTW_EXECUTE_SPLIT_DFT_R2C = (PROC_FFTW_EXECUTE_SPLIT_DFT_R2C) GetDynLibFuncPtr(hinstLib, "fftw_execute_split_dft_r2c");
99         MY_FFTW_EXECUTE_SPLIT_DFT_R2R = (PROC_FFTW_EXECUTE_SPLIT_DFT_R2R) GetDynLibFuncPtr(hinstLib, "fftw_execute_r2r");
100
101         MY_FFTW_PLAN_GURU_SPLIT_DFT     = (PROC_FFTW_PLAN_GURU_SPLIT_DFT)     GetDynLibFuncPtr(hinstLib, "fftw_plan_guru_split_dft");
102         MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R = (PROC_FFTW_PLAN_GURU_SPLIT_DFT_C2R) GetDynLibFuncPtr(hinstLib, "fftw_plan_guru_split_dft_c2r");
103         MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C = (PROC_FFTW_PLAN_GURU_SPLIT_DFT_R2C) GetDynLibFuncPtr(hinstLib, "fftw_plan_guru_split_dft_r2c");
104         MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R = (PROC_FFTW_PLAN_GURU_SPLIT_DFT_R2R) GetDynLibFuncPtr(hinstLib, "fftw_plan_guru_r2r");
105
106
107         MY_FFTW_DESTROY_PLAN = (PROC_FFTW_DESTROY_PLAN) GetDynLibFuncPtr(hinstLib, "fftw_destroy_plan");
108
109         MY_FFTW_EXPORT_WISDOM_TO_STRING   = (PROC_FFTW_EXPORT_WISDOM_TO_STRING)   GetDynLibFuncPtr(hinstLib, "fftw_export_wisdom_to_string");
110         MY_FFTW_IMPORT_WISDOM_FROM_STRING = (PROC_FFTW_IMPORT_WISDOM_FROM_STRING) GetDynLibFuncPtr(hinstLib, "fftw_import_wisdom_from_string");
111         MY_FFTW_FORGET_WISDOM             = (PROC_FFTW_FORGET_WISDOM) GetDynLibFuncPtr(hinstLib, "fftw_forget_wisdom");
112     }
113
114     return IsLoadedFFTW();
115 }
116 /*--------------------------------------------------------------------------*/
117 BOOL DisposeFFTWLibrary(void)
118 {
119     BOOL fFreeResult;
120
121     if (hinstLib)
122     {
123         fFreeResult = FreeDynLibrary(hinstLib);
124         hinstLib = NULL;
125     }
126
127     if (MY_FFTW_EXECUTE_SPLIT_DFT)
128     {
129         MY_FFTW_EXECUTE_SPLIT_DFT = NULL;
130     }
131     if (MY_FFTW_EXECUTE_SPLIT_DFT_C2R)
132     {
133         MY_FFTW_EXECUTE_SPLIT_DFT_C2R = NULL;
134     }
135     if (MY_FFTW_EXECUTE_SPLIT_DFT_R2C)
136     {
137         MY_FFTW_EXECUTE_SPLIT_DFT_R2C = NULL;
138     }
139     if (MY_FFTW_EXECUTE_SPLIT_DFT_R2R)
140     {
141         MY_FFTW_EXECUTE_SPLIT_DFT_R2R = NULL;
142     }
143
144     if (MY_FFTW_PLAN_GURU_SPLIT_DFT)
145     {
146         MY_FFTW_PLAN_GURU_SPLIT_DFT = NULL;
147     }
148     if (MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R)
149     {
150         MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R = NULL;
151     }
152     if (MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C)
153     {
154         MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C = NULL;
155     }
156     if (MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R)
157     {
158         MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R = NULL;
159     }
160
161     if (MY_FFTW_DESTROY_PLAN)
162     {
163         MY_FFTW_DESTROY_PLAN = NULL;
164     }
165
166     if (MY_FFTW_EXPORT_WISDOM_TO_STRING)
167     {
168         MY_FFTW_EXPORT_WISDOM_TO_STRING     = NULL;
169     }
170     if (MY_FFTW_IMPORT_WISDOM_FROM_STRING)
171     {
172         MY_FFTW_IMPORT_WISDOM_FROM_STRING = NULL;
173     }
174     if (MY_FFTW_FORGET_WISDOM)
175     {
176         MY_FFTW_FORGET_WISDOM                         = NULL;
177     }
178
179     if ( !MY_FFTW_EXECUTE_SPLIT_DFT       && !MY_FFTW_EXECUTE_SPLIT_DFT_C2R     &&
180             !MY_FFTW_EXECUTE_SPLIT_DFT_R2C   && !MY_FFTW_EXECUTE_SPLIT_DFT_R2R     &&
181             !MY_FFTW_PLAN_GURU_SPLIT_DFT     && !MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R   &&
182             !MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C && !MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R   &&
183             !MY_FFTW_DESTROY_PLAN            &&
184             !MY_FFTW_EXPORT_WISDOM_TO_STRING && !MY_FFTW_IMPORT_WISDOM_FROM_STRING &&
185             !MY_FFTW_FORGET_WISDOM )
186     {
187         return TRUE;
188     }
189
190     return FALSE;
191 }
192 /*--------------------------------------------------------------------------*/
193 void call_fftw_execute_split_dft (const fftw_plan p, double *ri, double *ii, double *ro, double *io)
194 {
195     if (MY_FFTW_EXECUTE_SPLIT_DFT)
196     {
197         (MY_FFTW_EXECUTE_SPLIT_DFT)(p, ri, ii, ro, io);
198     }
199 }
200 /*--------------------------------------------------------------------------*/
201 void call_fftw_execute_split_dft_c2r (const fftw_plan p, double *ri, double *ii, double *ro)
202 {
203     if (MY_FFTW_EXECUTE_SPLIT_DFT_C2R)
204     {
205         (MY_FFTW_EXECUTE_SPLIT_DFT_C2R)(p, ri, ii, ro);
206     }
207 }
208 /*--------------------------------------------------------------------------*/
209 void call_fftw_execute_split_dft_r2c (const fftw_plan p, double *ri, double *ro, double *io)
210 {
211     if (MY_FFTW_EXECUTE_SPLIT_DFT_R2C)
212     {
213         (MY_FFTW_EXECUTE_SPLIT_DFT_R2C)(p, ri, ro, io);
214     }
215 }
216 /*--------------------------------------------------------------------------*/
217 void call_fftw_execute_split_dft_r2r (const fftw_plan p, double *ri, double *ro)
218 {
219     if (MY_FFTW_EXECUTE_SPLIT_DFT_R2R)
220     {
221         (MY_FFTW_EXECUTE_SPLIT_DFT_R2R)(p, ri, ro);
222     }
223 }
224 /*--------------------------------------------------------------------------*/
225 fftw_plan call_fftw_plan_guru_split_dft (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ii, double *ro, double *io, unsigned flags)
226 {
227     if (MY_FFTW_PLAN_GURU_SPLIT_DFT)
228     {
229         return (fftw_plan)(MY_FFTW_PLAN_GURU_SPLIT_DFT)(rank, dims, howmany_rank, howmany_dims, ri, ii, ro, io, flags);
230     }
231     else
232     {
233         return NULL;
234     }
235 }
236 /*--------------------------------------------------------------------------*/
237 fftw_plan call_fftw_plan_guru_split_dft_c2r (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ii, double *ro,  unsigned flags)
238 {
239     if (MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R)
240     {
241         return (fftw_plan)(MY_FFTW_PLAN_GURU_SPLIT_DFT_C2R)(rank, dims, howmany_rank, howmany_dims, ri, ii, ro, flags);
242     }
243     else
244     {
245         return NULL;
246     }
247 }
248 /*--------------------------------------------------------------------------*/
249 fftw_plan call_fftw_plan_guru_split_dft_r2c (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ro, double *io, unsigned flags)
250 {
251     if (MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C)
252     {
253         return (fftw_plan)(MY_FFTW_PLAN_GURU_SPLIT_DFT_R2C)(rank, dims, howmany_rank, howmany_dims, ri, ro, io, flags);
254     }
255     else
256     {
257         return NULL;
258     }
259 }
260 /*--------------------------------------------------------------------------*/
261 fftw_plan call_fftw_plan_guru_split_dft_r2r (int rank, const fftw_iodim *dims, int howmany_rank, const fftw_iodim *howmany_dims, double *ri, double *ro, fftw_r2r_kind *kind, unsigned flags)
262 {
263     if (MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R)
264     {
265         return (fftw_plan)(MY_FFTW_PLAN_GURU_SPLIT_DFT_R2R)(rank, dims, howmany_rank, howmany_dims, ri, ro, kind, flags);
266     }
267     else
268     {
269         return NULL;
270     }
271 }
272
273 /*--------------------------------------------------------------------------*/
274 void call_fftw_destroy_plan (fftw_plan p)
275 {
276     if (MY_FFTW_DESTROY_PLAN)
277     {
278         (MY_FFTW_DESTROY_PLAN)(p);
279     }
280 }
281 /*--------------------------------------------------------------------------*/
282 char *call_fftw_export_wisdom_to_string (void)
283 {
284     if (MY_FFTW_EXPORT_WISDOM_TO_STRING)
285     {
286         return (char *)(MY_FFTW_EXPORT_WISDOM_TO_STRING)();
287     }
288     return NULL;
289 }
290 /*--------------------------------------------------------------------------*/
291 int call_fftw_import_wisdom_from_string (const char *input_string)
292 {
293     if (MY_FFTW_IMPORT_WISDOM_FROM_STRING)
294     {
295         return (int)(MY_FFTW_IMPORT_WISDOM_FROM_STRING)(input_string);
296     }
297     return 0;
298 }
299 /*--------------------------------------------------------------------------*/
300 void call_fftw_forget_wisdom (void)
301 {
302     if (MY_FFTW_FORGET_WISDOM)
303     {
304         (MY_FFTW_FORGET_WISDOM)();
305     }
306 }
307 /*--------------------------------------------------------------------------*/