diff --git a/CMakeLists.txt b/CMakeLists.txt index 89638ba..64151a9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -59,8 +59,8 @@ include(${wxWidgets_USE_FILE}) if (DEFINED WIN32) - include_directories ( ${PROJECT_SOURCE_DIR}/external/rtl-sdr-release ) - link_directories ( ${PROJECT_SOURCE_DIR}/external/rtl-sdr-release/x32 ) + include_directories ( ${PROJECT_SOURCE_DIR}/external/fftw-3.3.4-dll32 ${PROJECT_SOURCE_DIR}/external/rtl-sdr-release ) + link_directories ( ${PROJECT_SOURCE_DIR}/external/fftw-3.3.4-dll32 ${PROJECT_SOURCE_DIR}/external/rtl-sdr-release/x32 ) else (DEFINED WIN32) set(RTLSDR_INCLUDE "/opt/local/include" CACHE FILEPATH "RTL-SDR Include Path") set(RTLSDR_LIB "/opt/local/lib" CACHE FILEPATH "RTL-SDR Lib Path") @@ -84,13 +84,14 @@ SET (cubicsdr_headers src/IQBufferThread.h src/PrimaryGLContext.h src/AppFrame.h + src/CubicSDRDefs.h ) #configure_files(${PROJECT_SOURCE_DIR}/shaders ${PROJECT_BINARY_DIR}/shaders COPYONLY) #configure_files(${PROJECT_SOURCE_DIR}/png ${PROJECT_BINARY_DIR}/png COPYONLY) add_executable(CubicSDR ${cubicsdr_sources} ${cubicsdr_headers}) -target_link_libraries(CubicSDR rtlsdr ${wxWidgets_LIBRARIES} ${OPENGL_LIBRARIES}) +target_link_libraries(CubicSDR rtlsdr fftw3-3 ${wxWidgets_LIBRARIES} ${OPENGL_LIBRARIES}) # cubicvr2 glfw ${GLFW_LIBRARIES} ${OPENAL_LIBRARY} diff --git a/external/fftw-3.3.4-dll32/COPYING b/external/fftw-3.3.4-dll32/COPYING new file mode 100644 index 0000000..623b625 --- /dev/null +++ b/external/fftw-3.3.4-dll32/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/external/fftw-3.3.4-dll32/COPYRIGHT b/external/fftw-3.3.4-dll32/COPYRIGHT new file mode 100644 index 0000000..089500b --- /dev/null +++ b/external/fftw-3.3.4-dll32/COPYRIGHT @@ -0,0 +1,19 @@ +/* + * Copyright (c) 2003, 2007-14 Matteo Frigo + * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + * + */ diff --git a/external/fftw-3.3.4-dll32/fftw3.h b/external/fftw-3.3.4-dll32/fftw3.h new file mode 100644 index 0000000..4326eae --- /dev/null +++ b/external/fftw-3.3.4-dll32/fftw3.h @@ -0,0 +1,414 @@ +/* + * Copyright (c) 2003, 2007-14 Matteo Frigo + * Copyright (c) 2003, 2007-14 Massachusetts Institute of Technology + * + * The following statement of license applies *only* to this header file, + * and *not* to the other files distributed with FFTW or derived therefrom: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS + * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE + * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/***************************** NOTE TO USERS ********************************* + * + * THIS IS A HEADER FILE, NOT A MANUAL + * + * If you want to know how to use FFTW, please read the manual, + * online at http://www.fftw.org/doc/ and also included with FFTW. + * For a quick start, see the manual's tutorial section. + * + * (Reading header files to learn how to use a library is a habit + * stemming from code lacking a proper manual. Arguably, it's a + * *bad* habit in most cases, because header files can contain + * interfaces that are not part of the public, stable API.) + * + ****************************************************************************/ + +#ifndef FFTW3_H +#define FFTW3_H + +#include + +#ifdef __cplusplus +extern "C" +{ +#endif /* __cplusplus */ + +/* If is included, use the C99 complex type. Otherwise + define a type bit-compatible with C99 complex */ +#if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I) +# define FFTW_DEFINE_COMPLEX(R, C) typedef R _Complex C +#else +# define FFTW_DEFINE_COMPLEX(R, C) typedef R C[2] +#endif + +#define FFTW_CONCAT(prefix, name) prefix ## name +#define FFTW_MANGLE_DOUBLE(name) FFTW_CONCAT(fftw_, name) +#define FFTW_MANGLE_FLOAT(name) FFTW_CONCAT(fftwf_, name) +#define FFTW_MANGLE_LONG_DOUBLE(name) FFTW_CONCAT(fftwl_, name) +#define FFTW_MANGLE_QUAD(name) FFTW_CONCAT(fftwq_, name) + +/* IMPORTANT: for Windows compilers, you should add a line +*/ +#define FFTW_DLL +/* + here and in kernel/ifftw.h if you are compiling/using FFTW as a + DLL, in order to do the proper importing/exporting, or + alternatively compile with -DFFTW_DLL or the equivalent + command-line flag. This is not necessary under MinGW/Cygwin, where + libtool does the imports/exports automatically. */ +#if defined(FFTW_DLL) && (defined(_WIN32) || defined(__WIN32__)) + /* annoying Windows syntax for shared-library declarations */ +# if defined(COMPILING_FFTW) /* defined in api.h when compiling FFTW */ +# define FFTW_EXTERN extern __declspec(dllexport) +# else /* user is calling FFTW; import symbol */ +# define FFTW_EXTERN extern __declspec(dllimport) +# endif +#else +# define FFTW_EXTERN extern +#endif + +enum fftw_r2r_kind_do_not_use_me { + FFTW_R2HC=0, FFTW_HC2R=1, FFTW_DHT=2, + FFTW_REDFT00=3, FFTW_REDFT01=4, FFTW_REDFT10=5, FFTW_REDFT11=6, + FFTW_RODFT00=7, FFTW_RODFT01=8, FFTW_RODFT10=9, FFTW_RODFT11=10 +}; + +struct fftw_iodim_do_not_use_me { + int n; /* dimension size */ + int is; /* input stride */ + int os; /* output stride */ +}; + +#include /* for ptrdiff_t */ +struct fftw_iodim64_do_not_use_me { + ptrdiff_t n; /* dimension size */ + ptrdiff_t is; /* input stride */ + ptrdiff_t os; /* output stride */ +}; + +typedef void (*fftw_write_char_func_do_not_use_me)(char c, void *); +typedef int (*fftw_read_char_func_do_not_use_me)(void *); + +/* + huge second-order macro that defines prototypes for all API + functions. We expand this macro for each supported precision + + X: name-mangling macro + R: real data type + C: complex data type +*/ + +#define FFTW_DEFINE_API(X, R, C) \ + \ +FFTW_DEFINE_COMPLEX(R, C); \ + \ +typedef struct X(plan_s) *X(plan); \ + \ +typedef struct fftw_iodim_do_not_use_me X(iodim); \ +typedef struct fftw_iodim64_do_not_use_me X(iodim64); \ + \ +typedef enum fftw_r2r_kind_do_not_use_me X(r2r_kind); \ + \ +typedef fftw_write_char_func_do_not_use_me X(write_char_func); \ +typedef fftw_read_char_func_do_not_use_me X(read_char_func); \ + \ +FFTW_EXTERN void X(execute)(const X(plan) p); \ + \ +FFTW_EXTERN X(plan) X(plan_dft)(int rank, const int *n, \ + C *in, C *out, int sign, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_dft_1d)(int n, C *in, C *out, int sign, \ + unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_dft_2d)(int n0, int n1, \ + C *in, C *out, int sign, unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_dft_3d)(int n0, int n1, int n2, \ + C *in, C *out, int sign, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_many_dft)(int rank, const int *n, \ + int howmany, \ + C *in, const int *inembed, \ + int istride, int idist, \ + C *out, const int *onembed, \ + int ostride, int odist, \ + int sign, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru_dft)(int rank, const X(iodim) *dims, \ + int howmany_rank, \ + const X(iodim) *howmany_dims, \ + C *in, C *out, \ + int sign, unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_guru_split_dft)(int rank, const X(iodim) *dims, \ + int howmany_rank, \ + const X(iodim) *howmany_dims, \ + R *ri, R *ii, R *ro, R *io, \ + unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru64_dft)(int rank, \ + const X(iodim64) *dims, \ + int howmany_rank, \ + const X(iodim64) *howmany_dims, \ + C *in, C *out, \ + int sign, unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_guru64_split_dft)(int rank, \ + const X(iodim64) *dims, \ + int howmany_rank, \ + const X(iodim64) *howmany_dims, \ + R *ri, R *ii, R *ro, R *io, \ + unsigned flags); \ + \ +FFTW_EXTERN void X(execute_dft)(const X(plan) p, C *in, C *out); \ +FFTW_EXTERN void X(execute_split_dft)(const X(plan) p, R *ri, R *ii, \ + R *ro, R *io); \ + \ +FFTW_EXTERN X(plan) X(plan_many_dft_r2c)(int rank, const int *n, \ + int howmany, \ + R *in, const int *inembed, \ + int istride, int idist, \ + C *out, const int *onembed, \ + int ostride, int odist, \ + unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_dft_r2c)(int rank, const int *n, \ + R *in, C *out, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_dft_r2c_1d)(int n,R *in,C *out,unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_dft_r2c_2d)(int n0, int n1, \ + R *in, C *out, unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_dft_r2c_3d)(int n0, int n1, \ + int n2, \ + R *in, C *out, unsigned flags); \ + \ + \ +FFTW_EXTERN X(plan) X(plan_many_dft_c2r)(int rank, const int *n, \ + int howmany, \ + C *in, const int *inembed, \ + int istride, int idist, \ + R *out, const int *onembed, \ + int ostride, int odist, \ + unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_dft_c2r)(int rank, const int *n, \ + C *in, R *out, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_dft_c2r_1d)(int n,C *in,R *out,unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_dft_c2r_2d)(int n0, int n1, \ + C *in, R *out, unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_dft_c2r_3d)(int n0, int n1, \ + int n2, \ + C *in, R *out, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru_dft_r2c)(int rank, const X(iodim) *dims, \ + int howmany_rank, \ + const X(iodim) *howmany_dims, \ + R *in, C *out, \ + unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_guru_dft_c2r)(int rank, const X(iodim) *dims, \ + int howmany_rank, \ + const X(iodim) *howmany_dims, \ + C *in, R *out, \ + unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru_split_dft_r2c)( \ + int rank, const X(iodim) *dims, \ + int howmany_rank, \ + const X(iodim) *howmany_dims, \ + R *in, R *ro, R *io, \ + unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_guru_split_dft_c2r)( \ + int rank, const X(iodim) *dims, \ + int howmany_rank, \ + const X(iodim) *howmany_dims, \ + R *ri, R *ii, R *out, \ + unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru64_dft_r2c)(int rank, \ + const X(iodim64) *dims, \ + int howmany_rank, \ + const X(iodim64) *howmany_dims, \ + R *in, C *out, \ + unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_guru64_dft_c2r)(int rank, \ + const X(iodim64) *dims, \ + int howmany_rank, \ + const X(iodim64) *howmany_dims, \ + C *in, R *out, \ + unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru64_split_dft_r2c)( \ + int rank, const X(iodim64) *dims, \ + int howmany_rank, \ + const X(iodim64) *howmany_dims, \ + R *in, R *ro, R *io, \ + unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_guru64_split_dft_c2r)( \ + int rank, const X(iodim64) *dims, \ + int howmany_rank, \ + const X(iodim64) *howmany_dims, \ + R *ri, R *ii, R *out, \ + unsigned flags); \ + \ +FFTW_EXTERN void X(execute_dft_r2c)(const X(plan) p, R *in, C *out); \ +FFTW_EXTERN void X(execute_dft_c2r)(const X(plan) p, C *in, R *out); \ + \ +FFTW_EXTERN void X(execute_split_dft_r2c)(const X(plan) p, \ + R *in, R *ro, R *io); \ +FFTW_EXTERN void X(execute_split_dft_c2r)(const X(plan) p, \ + R *ri, R *ii, R *out); \ + \ +FFTW_EXTERN X(plan) X(plan_many_r2r)(int rank, const int *n, \ + int howmany, \ + R *in, const int *inembed, \ + int istride, int idist, \ + R *out, const int *onembed, \ + int ostride, int odist, \ + const X(r2r_kind) *kind, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_r2r)(int rank, const int *n, R *in, R *out, \ + const X(r2r_kind) *kind, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_r2r_1d)(int n, R *in, R *out, \ + X(r2r_kind) kind, unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_r2r_2d)(int n0, int n1, R *in, R *out, \ + X(r2r_kind) kind0, X(r2r_kind) kind1, \ + unsigned flags); \ +FFTW_EXTERN X(plan) X(plan_r2r_3d)(int n0, int n1, int n2, \ + R *in, R *out, X(r2r_kind) kind0, \ + X(r2r_kind) kind1, X(r2r_kind) kind2, \ + unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru_r2r)(int rank, const X(iodim) *dims, \ + int howmany_rank, \ + const X(iodim) *howmany_dims, \ + R *in, R *out, \ + const X(r2r_kind) *kind, unsigned flags); \ + \ +FFTW_EXTERN X(plan) X(plan_guru64_r2r)(int rank, const X(iodim64) *dims, \ + int howmany_rank, \ + const X(iodim64) *howmany_dims, \ + R *in, R *out, \ + const X(r2r_kind) *kind, unsigned flags); \ + \ +FFTW_EXTERN void X(execute_r2r)(const X(plan) p, R *in, R *out); \ + \ +FFTW_EXTERN void X(destroy_plan)(X(plan) p); \ +FFTW_EXTERN void X(forget_wisdom)(void); \ +FFTW_EXTERN void X(cleanup)(void); \ + \ +FFTW_EXTERN void X(set_timelimit)(double t); \ + \ +FFTW_EXTERN void X(plan_with_nthreads)(int nthreads); \ +FFTW_EXTERN int X(init_threads)(void); \ +FFTW_EXTERN void X(cleanup_threads)(void); \ + \ +FFTW_EXTERN int X(export_wisdom_to_filename)(const char *filename); \ +FFTW_EXTERN void X(export_wisdom_to_file)(FILE *output_file); \ +FFTW_EXTERN char *X(export_wisdom_to_string)(void); \ +FFTW_EXTERN void X(export_wisdom)(X(write_char_func) write_char, \ + void *data); \ +FFTW_EXTERN int X(import_system_wisdom)(void); \ +FFTW_EXTERN int X(import_wisdom_from_filename)(const char *filename); \ +FFTW_EXTERN int X(import_wisdom_from_file)(FILE *input_file); \ +FFTW_EXTERN int X(import_wisdom_from_string)(const char *input_string); \ +FFTW_EXTERN int X(import_wisdom)(X(read_char_func) read_char, void *data); \ + \ +FFTW_EXTERN void X(fprint_plan)(const X(plan) p, FILE *output_file); \ +FFTW_EXTERN void X(print_plan)(const X(plan) p); \ +FFTW_EXTERN char *X(sprint_plan)(const X(plan) p); \ + \ +FFTW_EXTERN void *X(malloc)(size_t n); \ +FFTW_EXTERN R *X(alloc_real)(size_t n); \ +FFTW_EXTERN C *X(alloc_complex)(size_t n); \ +FFTW_EXTERN void X(free)(void *p); \ + \ +FFTW_EXTERN void X(flops)(const X(plan) p, \ + double *add, double *mul, double *fmas); \ +FFTW_EXTERN double X(estimate_cost)(const X(plan) p); \ +FFTW_EXTERN double X(cost)(const X(plan) p); \ + \ +FFTW_EXTERN int X(alignment_of)(R *p); \ +FFTW_EXTERN const char X(version)[]; \ +FFTW_EXTERN const char X(cc)[]; \ +FFTW_EXTERN const char X(codelet_optim)[]; + + +/* end of FFTW_DEFINE_API macro */ + +FFTW_DEFINE_API(FFTW_MANGLE_DOUBLE, double, fftw_complex) +FFTW_DEFINE_API(FFTW_MANGLE_FLOAT, float, fftwf_complex) +FFTW_DEFINE_API(FFTW_MANGLE_LONG_DOUBLE, long double, fftwl_complex) + +/* __float128 (quad precision) is a gcc extension on i386, x86_64, and ia64 + for gcc >= 4.6 (compiled in FFTW with --enable-quad-precision) */ +#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) \ + && !(defined(__ICC) || defined(__INTEL_COMPILER)) \ + && (defined(__i386__) || defined(__x86_64__) || defined(__ia64__)) +# if !defined(FFTW_NO_Complex) && defined(_Complex_I) && defined(complex) && defined(I) +/* note: __float128 is a typedef, which is not supported with the _Complex + keyword in gcc, so instead we use this ugly __attribute__ version. + However, we can't simply pass the __attribute__ version to + FFTW_DEFINE_API because the __attribute__ confuses gcc in pointer + types. Hence redefining FFTW_DEFINE_COMPLEX. Ugh. */ +# undef FFTW_DEFINE_COMPLEX +# define FFTW_DEFINE_COMPLEX(R, C) typedef _Complex float __attribute__((mode(TC))) C +# endif +FFTW_DEFINE_API(FFTW_MANGLE_QUAD, __float128, fftwq_complex) +#endif + +#define FFTW_FORWARD (-1) +#define FFTW_BACKWARD (+1) + +#define FFTW_NO_TIMELIMIT (-1.0) + +/* documented flags */ +#define FFTW_MEASURE (0U) +#define FFTW_DESTROY_INPUT (1U << 0) +#define FFTW_UNALIGNED (1U << 1) +#define FFTW_CONSERVE_MEMORY (1U << 2) +#define FFTW_EXHAUSTIVE (1U << 3) /* NO_EXHAUSTIVE is default */ +#define FFTW_PRESERVE_INPUT (1U << 4) /* cancels FFTW_DESTROY_INPUT */ +#define FFTW_PATIENT (1U << 5) /* IMPATIENT is default */ +#define FFTW_ESTIMATE (1U << 6) +#define FFTW_WISDOM_ONLY (1U << 21) + +/* undocumented beyond-guru flags */ +#define FFTW_ESTIMATE_PATIENT (1U << 7) +#define FFTW_BELIEVE_PCOST (1U << 8) +#define FFTW_NO_DFT_R2HC (1U << 9) +#define FFTW_NO_NONTHREADED (1U << 10) +#define FFTW_NO_BUFFERING (1U << 11) +#define FFTW_NO_INDIRECT_OP (1U << 12) +#define FFTW_ALLOW_LARGE_GENERIC (1U << 13) /* NO_LARGE_GENERIC is default */ +#define FFTW_NO_RANK_SPLITS (1U << 14) +#define FFTW_NO_VRANK_SPLITS (1U << 15) +#define FFTW_NO_VRECURSE (1U << 16) +#define FFTW_NO_SIMD (1U << 17) +#define FFTW_NO_SLOW (1U << 18) +#define FFTW_NO_FIXED_RADIX_LARGE_N (1U << 19) +#define FFTW_ALLOW_PRUNING (1U << 20) + +#ifdef __cplusplus +} /* extern "C" */ +#endif /* __cplusplus */ + +#endif /* FFTW3_H */ diff --git a/external/fftw-3.3.4-dll32/libfftw3-3.a b/external/fftw-3.3.4-dll32/libfftw3-3.a new file mode 100644 index 0000000..68d81c5 Binary files /dev/null and b/external/fftw-3.3.4-dll32/libfftw3-3.a differ diff --git a/external/fftw-3.3.4-dll32/libfftw3-3.def b/external/fftw-3.3.4-dll32/libfftw3-3.def new file mode 100644 index 0000000..282fc19 --- /dev/null +++ b/external/fftw-3.3.4-dll32/libfftw3-3.def @@ -0,0 +1,1013 @@ +LIBRARY libfftw3-3.dll +EXPORTS +dfftw_cleanup_ +dfftw_cleanup__ +dfftw_cleanup_threads_ +dfftw_cleanup_threads__ +dfftw_cost_ +dfftw_cost__ +dfftw_destroy_plan_ +dfftw_destroy_plan__ +dfftw_estimate_cost_ +dfftw_estimate_cost__ +dfftw_execute_ +dfftw_execute__ +dfftw_execute_dft_ +dfftw_execute_dft__ +dfftw_execute_dft_c2r_ +dfftw_execute_dft_c2r__ +dfftw_execute_dft_r2c_ +dfftw_execute_dft_r2c__ +dfftw_execute_r2r_ +dfftw_execute_r2r__ +dfftw_execute_split_dft_ +dfftw_execute_split_dft__ +dfftw_execute_split_dft_c2r_ +dfftw_execute_split_dft_c2r__ +dfftw_execute_split_dft_r2c_ +dfftw_execute_split_dft_r2c__ +dfftw_export_wisdom_ +dfftw_export_wisdom__ +dfftw_flops_ +dfftw_flops__ +dfftw_forget_wisdom_ +dfftw_forget_wisdom__ +dfftw_import_system_wisdom_ +dfftw_import_system_wisdom__ +dfftw_import_wisdom_ +dfftw_import_wisdom__ +dfftw_init_threads_ +dfftw_init_threads__ +dfftw_plan_dft_ +dfftw_plan_dft_1d_ +dfftw_plan_dft_1d__ +dfftw_plan_dft_2d_ +dfftw_plan_dft_2d__ +dfftw_plan_dft_3d_ +dfftw_plan_dft_3d__ +dfftw_plan_dft__ +dfftw_plan_dft_c2r_ +dfftw_plan_dft_c2r_1d_ +dfftw_plan_dft_c2r_1d__ +dfftw_plan_dft_c2r_2d_ +dfftw_plan_dft_c2r_2d__ +dfftw_plan_dft_c2r_3d_ +dfftw_plan_dft_c2r_3d__ +dfftw_plan_dft_c2r__ +dfftw_plan_dft_r2c_ +dfftw_plan_dft_r2c_1d_ +dfftw_plan_dft_r2c_1d__ +dfftw_plan_dft_r2c_2d_ +dfftw_plan_dft_r2c_2d__ +dfftw_plan_dft_r2c_3d_ +dfftw_plan_dft_r2c_3d__ +dfftw_plan_dft_r2c__ +dfftw_plan_guru_dft_ +dfftw_plan_guru_dft__ +dfftw_plan_guru_dft_c2r_ +dfftw_plan_guru_dft_c2r__ +dfftw_plan_guru_dft_r2c_ +dfftw_plan_guru_dft_r2c__ +dfftw_plan_guru_r2r_ +dfftw_plan_guru_r2r__ +dfftw_plan_guru_split_dft_ +dfftw_plan_guru_split_dft__ +dfftw_plan_guru_split_dft_c2r_ +dfftw_plan_guru_split_dft_c2r__ +dfftw_plan_guru_split_dft_r2c_ +dfftw_plan_guru_split_dft_r2c__ +dfftw_plan_many_dft_ +dfftw_plan_many_dft__ +dfftw_plan_many_dft_c2r_ +dfftw_plan_many_dft_c2r__ +dfftw_plan_many_dft_r2c_ +dfftw_plan_many_dft_r2c__ +dfftw_plan_many_r2r_ +dfftw_plan_many_r2r__ +dfftw_plan_r2r_ +dfftw_plan_r2r_1d_ +dfftw_plan_r2r_1d__ +dfftw_plan_r2r_2d_ +dfftw_plan_r2r_2d__ +dfftw_plan_r2r_3d_ +dfftw_plan_r2r_3d__ +dfftw_plan_r2r__ +dfftw_plan_with_nthreads_ +dfftw_plan_with_nthreads__ +dfftw_print_plan_ +dfftw_print_plan__ +dfftw_set_timelimit_ +dfftw_set_timelimit__ +fftw_alignment_of +fftw_alloc_complex +fftw_alloc_real +fftw_assertion_failed +fftw_bufdist +fftw_check_alignment_of_sse2_pm +fftw_choose_radix +fftw_cleanup +fftw_cleanup_threads +fftw_codelet_e01_8 +fftw_codelet_e10_8 +fftw_codelet_hb2_16 +fftw_codelet_hb2_20 +fftw_codelet_hb2_25 +fftw_codelet_hb2_32 +fftw_codelet_hb2_4 +fftw_codelet_hb2_5 +fftw_codelet_hb2_8 +fftw_codelet_hb_10 +fftw_codelet_hb_12 +fftw_codelet_hb_15 +fftw_codelet_hb_16 +fftw_codelet_hb_2 +fftw_codelet_hb_20 +fftw_codelet_hb_25 +fftw_codelet_hb_3 +fftw_codelet_hb_32 +fftw_codelet_hb_4 +fftw_codelet_hb_5 +fftw_codelet_hb_6 +fftw_codelet_hb_64 +fftw_codelet_hb_7 +fftw_codelet_hb_8 +fftw_codelet_hb_9 +fftw_codelet_hc2cb2_16 +fftw_codelet_hc2cb2_20 +fftw_codelet_hc2cb2_32 +fftw_codelet_hc2cb2_4 +fftw_codelet_hc2cb2_8 +fftw_codelet_hc2cb_10 +fftw_codelet_hc2cb_12 +fftw_codelet_hc2cb_16 +fftw_codelet_hc2cb_2 +fftw_codelet_hc2cb_20 +fftw_codelet_hc2cb_32 +fftw_codelet_hc2cb_4 +fftw_codelet_hc2cb_6 +fftw_codelet_hc2cb_8 +fftw_codelet_hc2cbdft2_16 +fftw_codelet_hc2cbdft2_20 +fftw_codelet_hc2cbdft2_32 +fftw_codelet_hc2cbdft2_4 +fftw_codelet_hc2cbdft2_8 +fftw_codelet_hc2cbdft_10 +fftw_codelet_hc2cbdft_12 +fftw_codelet_hc2cbdft_16 +fftw_codelet_hc2cbdft_2 +fftw_codelet_hc2cbdft_20 +fftw_codelet_hc2cbdft_32 +fftw_codelet_hc2cbdft_4 +fftw_codelet_hc2cbdft_6 +fftw_codelet_hc2cbdft_8 +fftw_codelet_hc2cbdftv_10_avx +fftw_codelet_hc2cbdftv_10_sse2 +fftw_codelet_hc2cbdftv_12_avx +fftw_codelet_hc2cbdftv_12_sse2 +fftw_codelet_hc2cbdftv_16_avx +fftw_codelet_hc2cbdftv_16_sse2 +fftw_codelet_hc2cbdftv_20_avx +fftw_codelet_hc2cbdftv_20_sse2 +fftw_codelet_hc2cbdftv_2_avx +fftw_codelet_hc2cbdftv_2_sse2 +fftw_codelet_hc2cbdftv_32_avx +fftw_codelet_hc2cbdftv_32_sse2 +fftw_codelet_hc2cbdftv_4_avx +fftw_codelet_hc2cbdftv_4_sse2 +fftw_codelet_hc2cbdftv_6_avx +fftw_codelet_hc2cbdftv_6_sse2 +fftw_codelet_hc2cbdftv_8_avx +fftw_codelet_hc2cbdftv_8_sse2 +fftw_codelet_hc2cf2_16 +fftw_codelet_hc2cf2_20 +fftw_codelet_hc2cf2_32 +fftw_codelet_hc2cf2_4 +fftw_codelet_hc2cf2_8 +fftw_codelet_hc2cf_10 +fftw_codelet_hc2cf_12 +fftw_codelet_hc2cf_16 +fftw_codelet_hc2cf_2 +fftw_codelet_hc2cf_20 +fftw_codelet_hc2cf_32 +fftw_codelet_hc2cf_4 +fftw_codelet_hc2cf_6 +fftw_codelet_hc2cf_8 +fftw_codelet_hc2cfdft2_16 +fftw_codelet_hc2cfdft2_20 +fftw_codelet_hc2cfdft2_32 +fftw_codelet_hc2cfdft2_4 +fftw_codelet_hc2cfdft2_8 +fftw_codelet_hc2cfdft_10 +fftw_codelet_hc2cfdft_12 +fftw_codelet_hc2cfdft_16 +fftw_codelet_hc2cfdft_2 +fftw_codelet_hc2cfdft_20 +fftw_codelet_hc2cfdft_32 +fftw_codelet_hc2cfdft_4 +fftw_codelet_hc2cfdft_6 +fftw_codelet_hc2cfdft_8 +fftw_codelet_hc2cfdftv_10_avx +fftw_codelet_hc2cfdftv_10_sse2 +fftw_codelet_hc2cfdftv_12_avx +fftw_codelet_hc2cfdftv_12_sse2 +fftw_codelet_hc2cfdftv_16_avx +fftw_codelet_hc2cfdftv_16_sse2 +fftw_codelet_hc2cfdftv_20_avx +fftw_codelet_hc2cfdftv_20_sse2 +fftw_codelet_hc2cfdftv_2_avx +fftw_codelet_hc2cfdftv_2_sse2 +fftw_codelet_hc2cfdftv_32_avx +fftw_codelet_hc2cfdftv_32_sse2 +fftw_codelet_hc2cfdftv_4_avx +fftw_codelet_hc2cfdftv_4_sse2 +fftw_codelet_hc2cfdftv_6_avx +fftw_codelet_hc2cfdftv_6_sse2 +fftw_codelet_hc2cfdftv_8_avx +fftw_codelet_hc2cfdftv_8_sse2 +fftw_codelet_hf2_16 +fftw_codelet_hf2_20 +fftw_codelet_hf2_25 +fftw_codelet_hf2_32 +fftw_codelet_hf2_4 +fftw_codelet_hf2_5 +fftw_codelet_hf2_8 +fftw_codelet_hf_10 +fftw_codelet_hf_12 +fftw_codelet_hf_15 +fftw_codelet_hf_16 +fftw_codelet_hf_2 +fftw_codelet_hf_20 +fftw_codelet_hf_25 +fftw_codelet_hf_3 +fftw_codelet_hf_32 +fftw_codelet_hf_4 +fftw_codelet_hf_5 +fftw_codelet_hf_6 +fftw_codelet_hf_64 +fftw_codelet_hf_7 +fftw_codelet_hf_8 +fftw_codelet_hf_9 +fftw_codelet_n1_10 +fftw_codelet_n1_11 +fftw_codelet_n1_12 +fftw_codelet_n1_13 +fftw_codelet_n1_14 +fftw_codelet_n1_15 +fftw_codelet_n1_16 +fftw_codelet_n1_2 +fftw_codelet_n1_20 +fftw_codelet_n1_25 +fftw_codelet_n1_3 +fftw_codelet_n1_32 +fftw_codelet_n1_4 +fftw_codelet_n1_5 +fftw_codelet_n1_6 +fftw_codelet_n1_64 +fftw_codelet_n1_7 +fftw_codelet_n1_8 +fftw_codelet_n1_9 +fftw_codelet_n1bv_10_avx +fftw_codelet_n1bv_10_sse2 +fftw_codelet_n1bv_11_avx +fftw_codelet_n1bv_11_sse2 +fftw_codelet_n1bv_128_avx +fftw_codelet_n1bv_128_sse2 +fftw_codelet_n1bv_12_avx +fftw_codelet_n1bv_12_sse2 +fftw_codelet_n1bv_13_avx +fftw_codelet_n1bv_13_sse2 +fftw_codelet_n1bv_14_avx +fftw_codelet_n1bv_14_sse2 +fftw_codelet_n1bv_15_avx +fftw_codelet_n1bv_15_sse2 +fftw_codelet_n1bv_16_avx +fftw_codelet_n1bv_16_sse2 +fftw_codelet_n1bv_20_avx +fftw_codelet_n1bv_20_sse2 +fftw_codelet_n1bv_25_avx +fftw_codelet_n1bv_25_sse2 +fftw_codelet_n1bv_2_avx +fftw_codelet_n1bv_2_sse2 +fftw_codelet_n1bv_32_avx +fftw_codelet_n1bv_32_sse2 +fftw_codelet_n1bv_3_avx +fftw_codelet_n1bv_3_sse2 +fftw_codelet_n1bv_4_avx +fftw_codelet_n1bv_4_sse2 +fftw_codelet_n1bv_5_avx +fftw_codelet_n1bv_5_sse2 +fftw_codelet_n1bv_64_avx +fftw_codelet_n1bv_64_sse2 +fftw_codelet_n1bv_6_avx +fftw_codelet_n1bv_6_sse2 +fftw_codelet_n1bv_7_avx +fftw_codelet_n1bv_7_sse2 +fftw_codelet_n1bv_8_avx +fftw_codelet_n1bv_8_sse2 +fftw_codelet_n1bv_9_avx +fftw_codelet_n1bv_9_sse2 +fftw_codelet_n1fv_10_avx +fftw_codelet_n1fv_10_sse2 +fftw_codelet_n1fv_11_avx +fftw_codelet_n1fv_11_sse2 +fftw_codelet_n1fv_128_avx +fftw_codelet_n1fv_128_sse2 +fftw_codelet_n1fv_12_avx +fftw_codelet_n1fv_12_sse2 +fftw_codelet_n1fv_13_avx +fftw_codelet_n1fv_13_sse2 +fftw_codelet_n1fv_14_avx +fftw_codelet_n1fv_14_sse2 +fftw_codelet_n1fv_15_avx +fftw_codelet_n1fv_15_sse2 +fftw_codelet_n1fv_16_avx +fftw_codelet_n1fv_16_sse2 +fftw_codelet_n1fv_20_avx +fftw_codelet_n1fv_20_sse2 +fftw_codelet_n1fv_25_avx +fftw_codelet_n1fv_25_sse2 +fftw_codelet_n1fv_2_avx +fftw_codelet_n1fv_2_sse2 +fftw_codelet_n1fv_32_avx +fftw_codelet_n1fv_32_sse2 +fftw_codelet_n1fv_3_avx +fftw_codelet_n1fv_3_sse2 +fftw_codelet_n1fv_4_avx +fftw_codelet_n1fv_4_sse2 +fftw_codelet_n1fv_5_avx +fftw_codelet_n1fv_5_sse2 +fftw_codelet_n1fv_64_avx +fftw_codelet_n1fv_64_sse2 +fftw_codelet_n1fv_6_avx +fftw_codelet_n1fv_6_sse2 +fftw_codelet_n1fv_7_avx +fftw_codelet_n1fv_7_sse2 +fftw_codelet_n1fv_8_avx +fftw_codelet_n1fv_8_sse2 +fftw_codelet_n1fv_9_avx +fftw_codelet_n1fv_9_sse2 +fftw_codelet_n2bv_10_avx +fftw_codelet_n2bv_10_sse2 +fftw_codelet_n2bv_12_avx +fftw_codelet_n2bv_12_sse2 +fftw_codelet_n2bv_14_avx +fftw_codelet_n2bv_14_sse2 +fftw_codelet_n2bv_16_avx +fftw_codelet_n2bv_16_sse2 +fftw_codelet_n2bv_20_avx +fftw_codelet_n2bv_20_sse2 +fftw_codelet_n2bv_2_avx +fftw_codelet_n2bv_2_sse2 +fftw_codelet_n2bv_32_avx +fftw_codelet_n2bv_32_sse2 +fftw_codelet_n2bv_4_avx +fftw_codelet_n2bv_4_sse2 +fftw_codelet_n2bv_64_avx +fftw_codelet_n2bv_64_sse2 +fftw_codelet_n2bv_6_avx +fftw_codelet_n2bv_6_sse2 +fftw_codelet_n2bv_8_avx +fftw_codelet_n2bv_8_sse2 +fftw_codelet_n2fv_10_avx +fftw_codelet_n2fv_10_sse2 +fftw_codelet_n2fv_12_avx +fftw_codelet_n2fv_12_sse2 +fftw_codelet_n2fv_14_avx +fftw_codelet_n2fv_14_sse2 +fftw_codelet_n2fv_16_avx +fftw_codelet_n2fv_16_sse2 +fftw_codelet_n2fv_20_avx +fftw_codelet_n2fv_20_sse2 +fftw_codelet_n2fv_2_avx +fftw_codelet_n2fv_2_sse2 +fftw_codelet_n2fv_32_avx +fftw_codelet_n2fv_32_sse2 +fftw_codelet_n2fv_4_avx +fftw_codelet_n2fv_4_sse2 +fftw_codelet_n2fv_64_avx +fftw_codelet_n2fv_64_sse2 +fftw_codelet_n2fv_6_avx +fftw_codelet_n2fv_6_sse2 +fftw_codelet_n2fv_8_avx +fftw_codelet_n2fv_8_sse2 +fftw_codelet_n2sv_16_avx +fftw_codelet_n2sv_16_sse2 +fftw_codelet_n2sv_32_avx +fftw_codelet_n2sv_32_sse2 +fftw_codelet_n2sv_4_avx +fftw_codelet_n2sv_4_sse2 +fftw_codelet_n2sv_64_avx +fftw_codelet_n2sv_64_sse2 +fftw_codelet_n2sv_8_avx +fftw_codelet_n2sv_8_sse2 +fftw_codelet_q1_2 +fftw_codelet_q1_3 +fftw_codelet_q1_4 +fftw_codelet_q1_5 +fftw_codelet_q1_6 +fftw_codelet_q1_8 +fftw_codelet_q1bv_2_avx +fftw_codelet_q1bv_2_sse2 +fftw_codelet_q1bv_4_avx +fftw_codelet_q1bv_4_sse2 +fftw_codelet_q1bv_5_avx +fftw_codelet_q1bv_5_sse2 +fftw_codelet_q1bv_8_avx +fftw_codelet_q1bv_8_sse2 +fftw_codelet_q1fv_2_avx +fftw_codelet_q1fv_2_sse2 +fftw_codelet_q1fv_4_avx +fftw_codelet_q1fv_4_sse2 +fftw_codelet_q1fv_5_avx +fftw_codelet_q1fv_5_sse2 +fftw_codelet_q1fv_8_avx +fftw_codelet_q1fv_8_sse2 +fftw_codelet_r2cbIII_10 +fftw_codelet_r2cbIII_12 +fftw_codelet_r2cbIII_15 +fftw_codelet_r2cbIII_16 +fftw_codelet_r2cbIII_2 +fftw_codelet_r2cbIII_20 +fftw_codelet_r2cbIII_25 +fftw_codelet_r2cbIII_3 +fftw_codelet_r2cbIII_32 +fftw_codelet_r2cbIII_4 +fftw_codelet_r2cbIII_5 +fftw_codelet_r2cbIII_6 +fftw_codelet_r2cbIII_64 +fftw_codelet_r2cbIII_7 +fftw_codelet_r2cbIII_8 +fftw_codelet_r2cbIII_9 +fftw_codelet_r2cb_10 +fftw_codelet_r2cb_11 +fftw_codelet_r2cb_12 +fftw_codelet_r2cb_128 +fftw_codelet_r2cb_13 +fftw_codelet_r2cb_14 +fftw_codelet_r2cb_15 +fftw_codelet_r2cb_16 +fftw_codelet_r2cb_2 +fftw_codelet_r2cb_20 +fftw_codelet_r2cb_25 +fftw_codelet_r2cb_3 +fftw_codelet_r2cb_32 +fftw_codelet_r2cb_4 +fftw_codelet_r2cb_5 +fftw_codelet_r2cb_6 +fftw_codelet_r2cb_64 +fftw_codelet_r2cb_7 +fftw_codelet_r2cb_8 +fftw_codelet_r2cb_9 +fftw_codelet_r2cfII_10 +fftw_codelet_r2cfII_12 +fftw_codelet_r2cfII_15 +fftw_codelet_r2cfII_16 +fftw_codelet_r2cfII_2 +fftw_codelet_r2cfII_20 +fftw_codelet_r2cfII_25 +fftw_codelet_r2cfII_3 +fftw_codelet_r2cfII_32 +fftw_codelet_r2cfII_4 +fftw_codelet_r2cfII_5 +fftw_codelet_r2cfII_6 +fftw_codelet_r2cfII_64 +fftw_codelet_r2cfII_7 +fftw_codelet_r2cfII_8 +fftw_codelet_r2cfII_9 +fftw_codelet_r2cf_10 +fftw_codelet_r2cf_11 +fftw_codelet_r2cf_12 +fftw_codelet_r2cf_128 +fftw_codelet_r2cf_13 +fftw_codelet_r2cf_14 +fftw_codelet_r2cf_15 +fftw_codelet_r2cf_16 +fftw_codelet_r2cf_2 +fftw_codelet_r2cf_20 +fftw_codelet_r2cf_25 +fftw_codelet_r2cf_3 +fftw_codelet_r2cf_32 +fftw_codelet_r2cf_4 +fftw_codelet_r2cf_5 +fftw_codelet_r2cf_6 +fftw_codelet_r2cf_64 +fftw_codelet_r2cf_7 +fftw_codelet_r2cf_8 +fftw_codelet_r2cf_9 +fftw_codelet_t1_10 +fftw_codelet_t1_12 +fftw_codelet_t1_15 +fftw_codelet_t1_16 +fftw_codelet_t1_2 +fftw_codelet_t1_20 +fftw_codelet_t1_25 +fftw_codelet_t1_3 +fftw_codelet_t1_32 +fftw_codelet_t1_4 +fftw_codelet_t1_5 +fftw_codelet_t1_6 +fftw_codelet_t1_64 +fftw_codelet_t1_7 +fftw_codelet_t1_8 +fftw_codelet_t1_9 +fftw_codelet_t1buv_10_avx +fftw_codelet_t1buv_10_sse2 +fftw_codelet_t1buv_2_avx +fftw_codelet_t1buv_2_sse2 +fftw_codelet_t1buv_3_avx +fftw_codelet_t1buv_3_sse2 +fftw_codelet_t1buv_4_avx +fftw_codelet_t1buv_4_sse2 +fftw_codelet_t1buv_5_avx +fftw_codelet_t1buv_5_sse2 +fftw_codelet_t1buv_6_avx +fftw_codelet_t1buv_6_sse2 +fftw_codelet_t1buv_7_avx +fftw_codelet_t1buv_7_sse2 +fftw_codelet_t1buv_8_avx +fftw_codelet_t1buv_8_sse2 +fftw_codelet_t1buv_9_avx +fftw_codelet_t1buv_9_sse2 +fftw_codelet_t1bv_10_avx +fftw_codelet_t1bv_10_sse2 +fftw_codelet_t1bv_12_avx +fftw_codelet_t1bv_12_sse2 +fftw_codelet_t1bv_15_avx +fftw_codelet_t1bv_15_sse2 +fftw_codelet_t1bv_16_avx +fftw_codelet_t1bv_16_sse2 +fftw_codelet_t1bv_20_avx +fftw_codelet_t1bv_20_sse2 +fftw_codelet_t1bv_25_avx +fftw_codelet_t1bv_25_sse2 +fftw_codelet_t1bv_2_avx +fftw_codelet_t1bv_2_sse2 +fftw_codelet_t1bv_32_avx +fftw_codelet_t1bv_32_sse2 +fftw_codelet_t1bv_3_avx +fftw_codelet_t1bv_3_sse2 +fftw_codelet_t1bv_4_avx +fftw_codelet_t1bv_4_sse2 +fftw_codelet_t1bv_5_avx +fftw_codelet_t1bv_5_sse2 +fftw_codelet_t1bv_64_avx +fftw_codelet_t1bv_64_sse2 +fftw_codelet_t1bv_6_avx +fftw_codelet_t1bv_6_sse2 +fftw_codelet_t1bv_7_avx +fftw_codelet_t1bv_7_sse2 +fftw_codelet_t1bv_8_avx +fftw_codelet_t1bv_8_sse2 +fftw_codelet_t1bv_9_avx +fftw_codelet_t1bv_9_sse2 +fftw_codelet_t1fuv_10_avx +fftw_codelet_t1fuv_10_sse2 +fftw_codelet_t1fuv_2_avx +fftw_codelet_t1fuv_2_sse2 +fftw_codelet_t1fuv_3_avx +fftw_codelet_t1fuv_3_sse2 +fftw_codelet_t1fuv_4_avx +fftw_codelet_t1fuv_4_sse2 +fftw_codelet_t1fuv_5_avx +fftw_codelet_t1fuv_5_sse2 +fftw_codelet_t1fuv_6_avx +fftw_codelet_t1fuv_6_sse2 +fftw_codelet_t1fuv_7_avx +fftw_codelet_t1fuv_7_sse2 +fftw_codelet_t1fuv_8_avx +fftw_codelet_t1fuv_8_sse2 +fftw_codelet_t1fuv_9_avx +fftw_codelet_t1fuv_9_sse2 +fftw_codelet_t1fv_10_avx +fftw_codelet_t1fv_10_sse2 +fftw_codelet_t1fv_12_avx +fftw_codelet_t1fv_12_sse2 +fftw_codelet_t1fv_15_avx +fftw_codelet_t1fv_15_sse2 +fftw_codelet_t1fv_16_avx +fftw_codelet_t1fv_16_sse2 +fftw_codelet_t1fv_20_avx +fftw_codelet_t1fv_20_sse2 +fftw_codelet_t1fv_25_avx +fftw_codelet_t1fv_25_sse2 +fftw_codelet_t1fv_2_avx +fftw_codelet_t1fv_2_sse2 +fftw_codelet_t1fv_32_avx +fftw_codelet_t1fv_32_sse2 +fftw_codelet_t1fv_3_avx +fftw_codelet_t1fv_3_sse2 +fftw_codelet_t1fv_4_avx +fftw_codelet_t1fv_4_sse2 +fftw_codelet_t1fv_5_avx +fftw_codelet_t1fv_5_sse2 +fftw_codelet_t1fv_64_avx +fftw_codelet_t1fv_64_sse2 +fftw_codelet_t1fv_6_avx +fftw_codelet_t1fv_6_sse2 +fftw_codelet_t1fv_7_avx +fftw_codelet_t1fv_7_sse2 +fftw_codelet_t1fv_8_avx +fftw_codelet_t1fv_8_sse2 +fftw_codelet_t1fv_9_avx +fftw_codelet_t1fv_9_sse2 +fftw_codelet_t1sv_16_avx +fftw_codelet_t1sv_16_sse2 +fftw_codelet_t1sv_2_avx +fftw_codelet_t1sv_2_sse2 +fftw_codelet_t1sv_32_avx +fftw_codelet_t1sv_32_sse2 +fftw_codelet_t1sv_4_avx +fftw_codelet_t1sv_4_sse2 +fftw_codelet_t1sv_8_avx +fftw_codelet_t1sv_8_sse2 +fftw_codelet_t2_10 +fftw_codelet_t2_16 +fftw_codelet_t2_20 +fftw_codelet_t2_25 +fftw_codelet_t2_32 +fftw_codelet_t2_4 +fftw_codelet_t2_5 +fftw_codelet_t2_64 +fftw_codelet_t2_8 +fftw_codelet_t2bv_10_avx +fftw_codelet_t2bv_10_sse2 +fftw_codelet_t2bv_16_avx +fftw_codelet_t2bv_16_sse2 +fftw_codelet_t2bv_20_avx +fftw_codelet_t2bv_20_sse2 +fftw_codelet_t2bv_25_avx +fftw_codelet_t2bv_25_sse2 +fftw_codelet_t2bv_2_avx +fftw_codelet_t2bv_2_sse2 +fftw_codelet_t2bv_32_avx +fftw_codelet_t2bv_32_sse2 +fftw_codelet_t2bv_4_avx +fftw_codelet_t2bv_4_sse2 +fftw_codelet_t2bv_5_avx +fftw_codelet_t2bv_5_sse2 +fftw_codelet_t2bv_64_avx +fftw_codelet_t2bv_64_sse2 +fftw_codelet_t2bv_8_avx +fftw_codelet_t2bv_8_sse2 +fftw_codelet_t2fv_10_avx +fftw_codelet_t2fv_10_sse2 +fftw_codelet_t2fv_16_avx +fftw_codelet_t2fv_16_sse2 +fftw_codelet_t2fv_20_avx +fftw_codelet_t2fv_20_sse2 +fftw_codelet_t2fv_25_avx +fftw_codelet_t2fv_25_sse2 +fftw_codelet_t2fv_2_avx +fftw_codelet_t2fv_2_sse2 +fftw_codelet_t2fv_32_avx +fftw_codelet_t2fv_32_sse2 +fftw_codelet_t2fv_4_avx +fftw_codelet_t2fv_4_sse2 +fftw_codelet_t2fv_5_avx +fftw_codelet_t2fv_5_sse2 +fftw_codelet_t2fv_64_avx +fftw_codelet_t2fv_64_sse2 +fftw_codelet_t2fv_8_avx +fftw_codelet_t2fv_8_sse2 +fftw_codelet_t2sv_16_avx +fftw_codelet_t2sv_16_sse2 +fftw_codelet_t2sv_32_avx +fftw_codelet_t2sv_32_sse2 +fftw_codelet_t2sv_4_avx +fftw_codelet_t2sv_4_sse2 +fftw_codelet_t2sv_8_avx +fftw_codelet_t2sv_8_sse2 +fftw_codelet_t3bv_10_avx +fftw_codelet_t3bv_10_sse2 +fftw_codelet_t3bv_16_avx +fftw_codelet_t3bv_16_sse2 +fftw_codelet_t3bv_20_avx +fftw_codelet_t3bv_20_sse2 +fftw_codelet_t3bv_25_avx +fftw_codelet_t3bv_25_sse2 +fftw_codelet_t3bv_32_avx +fftw_codelet_t3bv_32_sse2 +fftw_codelet_t3bv_4_avx +fftw_codelet_t3bv_4_sse2 +fftw_codelet_t3bv_5_avx +fftw_codelet_t3bv_5_sse2 +fftw_codelet_t3bv_8_avx +fftw_codelet_t3bv_8_sse2 +fftw_codelet_t3fv_10_avx +fftw_codelet_t3fv_10_sse2 +fftw_codelet_t3fv_16_avx +fftw_codelet_t3fv_16_sse2 +fftw_codelet_t3fv_20_avx +fftw_codelet_t3fv_20_sse2 +fftw_codelet_t3fv_25_avx +fftw_codelet_t3fv_25_sse2 +fftw_codelet_t3fv_32_avx +fftw_codelet_t3fv_32_sse2 +fftw_codelet_t3fv_4_avx +fftw_codelet_t3fv_4_sse2 +fftw_codelet_t3fv_5_avx +fftw_codelet_t3fv_5_sse2 +fftw_codelet_t3fv_8_avx +fftw_codelet_t3fv_8_sse2 +fftw_compute_tilesz +fftw_configure_planner +fftw_cost +fftw_cpy1d +fftw_cpy2d +fftw_cpy2d_ci +fftw_cpy2d_co +fftw_cpy2d_pair +fftw_cpy2d_pair_ci +fftw_cpy2d_pair_co +fftw_cpy2d_tiled +fftw_cpy2d_tiledbuf +fftw_ct_applicable +fftw_ct_generic_register +fftw_ct_genericbuf_register +fftw_ct_uglyp +fftw_destroy_plan +fftw_dft_bluestein_register +fftw_dft_buffered_register +fftw_dft_conf_standard +fftw_dft_generic_register +fftw_dft_indirect_register +fftw_dft_indirect_transpose_register +fftw_dft_nop_register +fftw_dft_r2hc_register +fftw_dft_rader_register +fftw_dft_rank_geq2_register +fftw_dft_solve +fftw_dft_thr_vrank_geq1_register +fftw_dft_vrank_geq1_register +fftw_dft_zerotens +fftw_dht_r2hc_register +fftw_dht_rader_register +fftw_dimcmp +fftw_elapsed_since +fftw_estimate_cost +fftw_execute +fftw_execute_dft +fftw_execute_dft_c2r +fftw_execute_dft_r2c +fftw_execute_r2r +fftw_execute_split_dft +fftw_execute_split_dft_c2r +fftw_execute_split_dft_r2c +fftw_export_wisdom +fftw_export_wisdom_to_file +fftw_export_wisdom_to_filename +fftw_export_wisdom_to_string +fftw_extract_reim +fftw_factors_into +fftw_factors_into_small_primes +fftw_find_generator +fftw_first_divisor +fftw_flops +fftw_forget_wisdom +fftw_fprint_plan +fftw_free +fftw_get_crude_time +fftw_guru64_kosherp +fftw_guru_kosherp +fftw_hash +fftw_have_simd_avx +fftw_have_simd_sse2 +fftw_hc2c_applicable +fftw_hc2hc_applicable +fftw_hc2hc_generic_register +fftw_iabs +fftw_iestimate_cost +fftw_ifree +fftw_ifree0 +fftw_imax +fftw_imin +fftw_import_system_wisdom +fftw_import_wisdom +fftw_import_wisdom_from_file +fftw_import_wisdom_from_filename +fftw_import_wisdom_from_string +fftw_init_threads +fftw_is_prime +fftw_isqrt +fftw_ithreads_init +fftw_join_taint +fftw_kdft_dif_register +fftw_kdft_difsq_register +fftw_kdft_dit_register +fftw_kdft_register +fftw_kernel_free +fftw_kernel_malloc +fftw_khc2c_register +fftw_khc2hc_register +fftw_kr2c_register +fftw_kr2r_register +fftw_malloc +fftw_malloc_plain +fftw_many_kosherp +fftw_map_r2r_kind +fftw_mapflags +fftw_md5INT +fftw_md5begin +fftw_md5end +fftw_md5int +fftw_md5putb +fftw_md5putc +fftw_md5puts +fftw_md5unsigned +fftw_measure_execution_time +fftw_mkapiplan +fftw_mkplan +fftw_mkplan_d +fftw_mkplan_dft +fftw_mkplan_dftw +fftw_mkplan_f_d +fftw_mkplan_hc2c +fftw_mkplan_hc2hc +fftw_mkplan_rdft +fftw_mkplan_rdft2 +fftw_mkplanner +fftw_mkprinter +fftw_mkprinter_cnt +fftw_mkprinter_file +fftw_mkprinter_str +fftw_mkproblem +fftw_mkproblem_dft +fftw_mkproblem_dft_d +fftw_mkproblem_rdft +fftw_mkproblem_rdft2 +fftw_mkproblem_rdft2_d +fftw_mkproblem_rdft2_d_3pointers +fftw_mkproblem_rdft_0_d +fftw_mkproblem_rdft_1 +fftw_mkproblem_rdft_1_d +fftw_mkproblem_rdft_d +fftw_mkproblem_unsolvable +fftw_mkscanner +fftw_mksolver +fftw_mksolver_ct +fftw_mksolver_ct_threads +fftw_mksolver_dft_direct +fftw_mksolver_dft_directbuf +fftw_mksolver_hc2c +fftw_mksolver_hc2hc +fftw_mksolver_hc2hc_threads +fftw_mksolver_rdft2_direct +fftw_mksolver_rdft_r2c_direct +fftw_mksolver_rdft_r2c_directbuf +fftw_mksolver_rdft_r2r_direct +fftw_mkstride +fftw_mktensor +fftw_mktensor_0d +fftw_mktensor_1d +fftw_mktensor_2d +fftw_mktensor_3d +fftw_mktensor_4d +fftw_mktensor_5d +fftw_mktensor_iodims +fftw_mktensor_iodims64 +fftw_mktensor_rowmajor +fftw_mktriggen +fftw_modulo +fftw_nbuf +fftw_nbuf_redundant +fftw_next_prime +fftw_null_awake +fftw_ops_add +fftw_ops_add2 +fftw_ops_cpy +fftw_ops_madd +fftw_ops_madd2 +fftw_ops_other +fftw_ops_zero +fftw_pickdim +fftw_plan_awake +fftw_plan_destroy_internal +fftw_plan_dft +fftw_plan_dft_1d +fftw_plan_dft_2d +fftw_plan_dft_3d +fftw_plan_dft_c2r +fftw_plan_dft_c2r_1d +fftw_plan_dft_c2r_2d +fftw_plan_dft_c2r_3d +fftw_plan_dft_r2c +fftw_plan_dft_r2c_1d +fftw_plan_dft_r2c_2d +fftw_plan_dft_r2c_3d +fftw_plan_guru64_dft +fftw_plan_guru64_dft_c2r +fftw_plan_guru64_dft_r2c +fftw_plan_guru64_r2r +fftw_plan_guru64_split_dft +fftw_plan_guru64_split_dft_c2r +fftw_plan_guru64_split_dft_r2c +fftw_plan_guru_dft +fftw_plan_guru_dft_c2r +fftw_plan_guru_dft_r2c +fftw_plan_guru_r2r +fftw_plan_guru_split_dft +fftw_plan_guru_split_dft_c2r +fftw_plan_guru_split_dft_r2c +fftw_plan_many_dft +fftw_plan_many_dft_c2r +fftw_plan_many_dft_r2c +fftw_plan_many_r2r +fftw_plan_null_destroy +fftw_plan_r2r +fftw_plan_r2r_1d +fftw_plan_r2r_2d +fftw_plan_r2r_3d +fftw_plan_with_nthreads +fftw_planner_destroy +fftw_power_mod +fftw_print_plan +fftw_printer_destroy +fftw_problem_destroy +fftw_rader_tl_delete +fftw_rader_tl_find +fftw_rader_tl_insert +fftw_rdft2_buffered_register +fftw_rdft2_complex_n +fftw_rdft2_inplace_strides +fftw_rdft2_nop_register +fftw_rdft2_pad +fftw_rdft2_rank0_register +fftw_rdft2_rank_geq2_register +fftw_rdft2_rdft_register +fftw_rdft2_solve +fftw_rdft2_strides +fftw_rdft2_tensor_max_index +fftw_rdft2_thr_vrank_geq1_register +fftw_rdft2_vrank_geq1_register +fftw_rdft_buffered_register +fftw_rdft_conf_standard +fftw_rdft_dht_register +fftw_rdft_generic_register +fftw_rdft_indirect_register +fftw_rdft_kind_str +fftw_rdft_nop_register +fftw_rdft_rank0_register +fftw_rdft_rank_geq2_register +fftw_rdft_solve +fftw_rdft_thr_vrank_geq1_register +fftw_rdft_vrank3_transpose_register +fftw_rdft_vrank_geq1_register +fftw_rdft_zerotens +fftw_redft00e_r2hc_pad_register +fftw_regsolver_ct_directw +fftw_regsolver_ct_directwsq +fftw_regsolver_hc2c_direct +fftw_regsolver_hc2hc_direct +fftw_reodft00e_splitradix_register +fftw_reodft010e_r2hc_register +fftw_reodft11e_r2hc_odd_register +fftw_reodft11e_radix2_r2hc_register +fftw_reodft_conf_standard +fftw_rodft00e_r2hc_pad_register +fftw_safe_mulmod +fftw_scanner_destroy +fftw_set_timelimit +fftw_solver_destroy +fftw_solver_register +fftw_solver_use +fftw_solvtab_exec +fftw_spawn_loop +fftw_sprint_plan +fftw_stride_destroy +fftw_taint +fftw_tensor_append +fftw_tensor_compress +fftw_tensor_compress_contiguous +fftw_tensor_copy +fftw_tensor_copy_except +fftw_tensor_copy_inplace +fftw_tensor_copy_sub +fftw_tensor_destroy +fftw_tensor_destroy2 +fftw_tensor_destroy4 +fftw_tensor_equal +fftw_tensor_inplace_locations +fftw_tensor_inplace_strides +fftw_tensor_inplace_strides2 +fftw_tensor_kosherp +fftw_tensor_max_index +fftw_tensor_md5 +fftw_tensor_min_istride +fftw_tensor_min_ostride +fftw_tensor_min_stride +fftw_tensor_print +fftw_tensor_split +fftw_tensor_strides_decrease +fftw_tensor_sz +fftw_tensor_tornk1 +fftw_the_planner +fftw_threads_cleanup +fftw_threads_conf_standard +fftw_tile2d +fftw_toobig +fftw_transpose +fftw_transpose_tiled +fftw_transpose_tiledbuf +fftw_triggen_destroy +fftw_twiddle_awake +fftw_twiddle_length diff --git a/external/fftw-3.3.4-dll32/libfftw3-3.dll b/external/fftw-3.3.4-dll32/libfftw3-3.dll new file mode 100644 index 0000000..e8a067f Binary files /dev/null and b/external/fftw-3.3.4-dll32/libfftw3-3.dll differ diff --git a/src/CubicSDRDefs.h b/src/CubicSDRDefs.h new file mode 100644 index 0000000..3b9b214 --- /dev/null +++ b/src/CubicSDRDefs.h @@ -0,0 +1,6 @@ +#pragma once + +#define BUF_SIZE (16 * 32 * 512) +#define SRATE 2500000 +#define FFT_SIZE BUF_SIZE/2 + diff --git a/src/IQBufferThread.cpp b/src/IQBufferThread.cpp index 11304b4..38389b0 100644 --- a/src/IQBufferThread.cpp +++ b/src/IQBufferThread.cpp @@ -11,7 +11,7 @@ #error "OpenGL required: set wxUSE_GLCANVAS to 1 and rebuild the library" #endif -#define BUF_SIZE (16 * 32 * 512) +#include "CubicSDRDefs.h" IQBufferThread::IQBufferThread(wxApp *app) : wxThread(wxTHREAD_DETACHED) { diff --git a/src/PrimaryGLContext.cpp b/src/PrimaryGLContext.cpp index 3c8bb97..cd20dc9 100644 --- a/src/PrimaryGLContext.cpp +++ b/src/PrimaryGLContext.cpp @@ -11,6 +11,8 @@ #endif #include "CubicSDR.h" +#include "CubicSDRDefs.h" +#include wxString glGetwxString(GLenum name) { const GLubyte *v = glGetString(name); @@ -68,7 +70,7 @@ void PrimaryGLContext::PlotIQ(std::vector &i_points, std::vector & glPushMatrix(); glTranslatef(0.0f, 0.5f, 0.0f); if (q_points.size()) { - glScalef(10.0f, 1.0f, 1.0f); +// glScalef(10.0f, 1.0f, 1.0f); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 0, &q_points[0]); glDrawArrays(GL_LINE_STRIP, 0, q_points.size() / 2); @@ -85,7 +87,7 @@ void PrimaryGLContext::PlotIQ(std::vector &i_points, std::vector & glPushMatrix(); glTranslatef(0.0f, -0.5f, 0.0f); if (i_points.size()) { - glScalef(10.0f, 1.0f, 1.0f); +// glScalef(10.0f, 1.0f, 1.0f); glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(2, GL_FLOAT, 0, &i_points[0]); glDrawArrays(GL_LINE_STRIP, 0, i_points.size() / 2); @@ -113,6 +115,13 @@ TestGLCanvas::TestGLCanvas(wxWindow *parent, int *attribList) : wxGLCanvas(parent, wxID_ANY, attribList, wxDefaultPosition, wxDefaultSize, wxFULL_REPAINT_ON_RESIZE) { + int in_block_size = BUF_SIZE/2; + int out_block_size = FFT_SIZE; + + in = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * in_block_size); + out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * out_block_size); + plan = fftw_plan_dft_1d(out_block_size, in, out, FFTW_FORWARD, FFTW_ESTIMATE); + } void TestGLCanvas::OnPaint(wxPaintEvent& WXUNUSED(event)) { @@ -148,23 +157,60 @@ void TestGLCanvas::OnKeyDown(wxKeyEvent& event) { } void TestGLCanvas::setData(std::vector *data) { + + if (data && data->size()) { - if (i_points.size() < data->size()) { - i_points.resize(data->size()); - } - if (q_points.size() < data->size()) { - q_points.resize(data->size()); + + if (i_points.size() < FFT_SIZE*2) { + i_points.resize(FFT_SIZE*2); } - for (int i = 0, iMax = data->size() / 2; i < iMax; i++) { - i_points[i * 2 + 1] = (float) (*data)[i * 2] / 127.0f; - q_points[i * 2 + 1] = (float) (*data)[i * 2 + 1] / 127.0f; - i_points[i * 2] = q_points[i * 2] = 2.0f * ((float) i / (float) iMax) - 1.0f; + for (int i = 0; i < BUF_SIZE / 2; i++) { + in[i][0] = (float) (*data)[i * 2] / 127.0f; + in[i][1] = (float) (*data)[i * 2 + 1] / 127.0f; } + +// for (int i = 0; i < BUF_SIZE / 2; i++) { +// double ang = (M_PI / (float) BUF_SIZE) * (float) i; +// double w = 0.5 * (1.0 - cos(ang)); +// +// in[i][0] *= w; +// in[i][1] *= w; +// } + + fftw_execute(plan); + + float result[FFT_SIZE]; + float fft_floor, fft_ceil; + + for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) { + double a = out[i][0]; + double b = out[i][1]; + + double c = sqrt(a*a+b*b); + if (i==1) { + fft_floor=fft_ceil=c; + } else { + if (cfft_ceil) { + fft_ceil = c; + } + } + + result[i] = c; + } + + for (int i = 0, iMax = FFT_SIZE; i < iMax; i++) { + i_points[i * 2 + 1] = (result[i]-fft_floor)/(fft_ceil-fft_floor); + i_points[i * 2] = 2.0f * ((float) i / (float) iMax) - 1.0f; + } + } } void TestGLCanvas::OnIdle(wxIdleEvent &event) { Refresh(false); } -; + diff --git a/src/PrimaryGLContext.h b/src/PrimaryGLContext.h index fc5be10..ebc5410 100644 --- a/src/PrimaryGLContext.h +++ b/src/PrimaryGLContext.h @@ -4,6 +4,8 @@ #include "wx/timer.h" #include +#include "CubicSDRDefs.h" +#include "fftw3.h" class PrimaryGLContext : public wxGLContext { @@ -27,6 +29,9 @@ public: std::vector i_points; std::vector q_points; + fftw_complex *in, *out; + fftw_plan plan; + private: void OnPaint(wxPaintEvent& event); void OnKeyDown(wxKeyEvent& event); diff --git a/src/SDRThread.cpp b/src/SDRThread.cpp index 145103f..e0a6c2e 100644 --- a/src/SDRThread.cpp +++ b/src/SDRThread.cpp @@ -1,7 +1,7 @@ #include "SDRThread.h" +#include "CubicSDRDefs.h" #include -#define BUF_SIZE (16 * 32 * 512) //wxDEFINE_EVENT(wxEVT_COMMAND_SDRThread_INPUT, wxThreadEvent); @@ -87,14 +87,19 @@ wxThread::ExitCode SDRThread::Entry() { enumerate_rtl(); - rtlsdr_open(&dev, 0); - rtlsdr_set_sample_rate(dev, 2500000); - rtlsdr_set_center_freq(dev, 105700000); + rtlsdr_open(&dev, 3); + rtlsdr_set_sample_rate(dev, SRATE); + rtlsdr_set_center_freq(dev, 105700000-(SRATE/2)); rtlsdr_set_agc_mode(dev, 1); rtlsdr_set_offset_tuning(dev, 1); rtlsdr_reset_buffer(dev); + sample_rate = rtlsdr_get_sample_rate(dev); + + std::cout << "Sample Rate is: " << sample_rate << std::endl; + int n_read; + double seconds = 0.0; std::cout << "Sampling.."; while (!TestDestroy()) { @@ -107,9 +112,17 @@ wxThread::ExitCode SDRThread::Entry() { new_buffer->push_back(buf[i] - 127); } - wxThreadEvent event(wxEVT_THREAD, EVENT_SDR_INPUT); - event.SetPayload(new_buffer); - wxQueueEvent(frame, event.Clone()); + double time_slice = (double)n_read/(double)sample_rate; + seconds += time_slice; + + std::cout << "Time Slice: " << time_slice << std::endl; + if (!TestDestroy()) { + wxThreadEvent event(wxEVT_THREAD, EVENT_SDR_INPUT); + event.SetPayload(new_buffer); + wxQueueEvent(frame, event.Clone()); + } else { + delete new_buffer; + } } this->Sleep(1); } diff --git a/src/SDRThread.h b/src/SDRThread.h index 88198c8..3097a7d 100644 --- a/src/SDRThread.h +++ b/src/SDRThread.h @@ -32,4 +32,5 @@ public: protected: virtual ExitCode Entry(); AppFrame *frame; + uint32_t sample_rate; };