From b471611da731ccec358d3960bba9efc6a846af01 Mon Sep 17 00:00:00 2001 From: brunodev85 Date: Fri, 16 May 2025 17:12:06 -0300 Subject: [PATCH] app: Add FluidSynth library and dependencies --- .../main/cpp/midihandler/fluidsynth/LICENSE | 504 ++++++++++++++++ .../fluidsynth/include/fluidsynth.h | 121 ++++ .../fluidsynth/include/fluidsynth/audio.h | 155 +++++ .../fluidsynth/include/fluidsynth/event.h | 143 +++++ .../fluidsynth/include/fluidsynth/gen.h | 134 +++++ .../fluidsynth/include/fluidsynth/ladspa.h | 69 +++ .../fluidsynth/include/fluidsynth/log.h | 97 +++ .../fluidsynth/include/fluidsynth/midi.h | 295 +++++++++ .../fluidsynth/include/fluidsynth/misc.h | 77 +++ .../fluidsynth/include/fluidsynth/mod.h | 116 ++++ .../fluidsynth/include/fluidsynth/seq.h | 92 +++ .../fluidsynth/include/fluidsynth/seqbind.h | 45 ++ .../fluidsynth/include/fluidsynth/settings.h | 197 ++++++ .../fluidsynth/include/fluidsynth/sfont.h | 362 ++++++++++++ .../fluidsynth/include/fluidsynth/shell.h | 150 +++++ .../fluidsynth/include/fluidsynth/synth.h | 559 ++++++++++++++++++ .../fluidsynth/include/fluidsynth/types.h | 83 +++ .../fluidsynth/include/fluidsynth/version.h | 47 ++ .../fluidsynth/include/fluidsynth/voice.h | 77 +++ app/src/main/jniLibs/arm64-v8a/libFLAC.so | Bin 0 -> 238784 bytes .../main/jniLibs/arm64-v8a/libc++_shared.so | Bin 0 -> 1292896 bytes .../arm64-v8a/libfluidsynth-assetloader.so | Bin 0 -> 6136 bytes .../main/jniLibs/arm64-v8a/libfluidsynth.so | Bin 0 -> 444744 bytes app/src/main/jniLibs/arm64-v8a/libgio-2.0.so | Bin 0 -> 1583888 bytes app/src/main/jniLibs/arm64-v8a/libglib-2.0.so | Bin 0 -> 2200640 bytes .../main/jniLibs/arm64-v8a/libgmodule-2.0.so | Bin 0 -> 11456 bytes .../main/jniLibs/arm64-v8a/libgobject-2.0.so | Bin 0 -> 379536 bytes .../main/jniLibs/arm64-v8a/libgthread-2.0.so | Bin 0 -> 4256 bytes .../jniLibs/arm64-v8a/libinstpatch-1.0.so | Bin 0 -> 832264 bytes app/src/main/jniLibs/arm64-v8a/liboboe.so | Bin 0 -> 275984 bytes app/src/main/jniLibs/arm64-v8a/libogg.so | Bin 0 -> 29752 bytes app/src/main/jniLibs/arm64-v8a/libopus.so | Bin 0 -> 400048 bytes app/src/main/jniLibs/arm64-v8a/libpcre.so | Bin 0 -> 237464 bytes .../main/jniLibs/arm64-v8a/libpcreposix.so | Bin 0 -> 7336 bytes app/src/main/jniLibs/arm64-v8a/libvorbis.so | Bin 0 -> 187440 bytes .../main/jniLibs/arm64-v8a/libvorbisenc.so | Bin 0 -> 653632 bytes .../main/jniLibs/arm64-v8a/libvorbisfile.so | Bin 0 -> 31312 bytes 37 files changed, 3323 insertions(+) create mode 100644 app/src/main/cpp/midihandler/fluidsynth/LICENSE create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/audio.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/event.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/gen.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/ladspa.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/log.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/midi.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/misc.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/mod.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seq.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seqbind.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/settings.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/sfont.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/shell.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/synth.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/types.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/version.h create mode 100644 app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/voice.h create mode 100644 app/src/main/jniLibs/arm64-v8a/libFLAC.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libc++_shared.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libfluidsynth-assetloader.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libfluidsynth.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libgio-2.0.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libglib-2.0.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libgmodule-2.0.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libgobject-2.0.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libgthread-2.0.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libinstpatch-1.0.so create mode 100644 app/src/main/jniLibs/arm64-v8a/liboboe.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libogg.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libopus.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libpcre.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libpcreposix.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libvorbis.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libvorbisenc.so create mode 100644 app/src/main/jniLibs/arm64-v8a/libvorbisfile.so diff --git a/app/src/main/cpp/midihandler/fluidsynth/LICENSE b/app/src/main/cpp/midihandler/fluidsynth/LICENSE new file mode 100644 index 0000000..19e3071 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/LICENSE @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 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. + +(This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.) + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +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 and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, 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 library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete 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 distribute a copy of this License along with the +Library. + + 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 Library or any portion +of it, thus forming a work based on the Library, 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) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +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 Library, 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 Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you 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. + + If distribution of 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 satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be 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. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library 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. + + 9. 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 Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +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 with +this License. + + 11. 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 Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library 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 Library. + +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. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library 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. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser 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 Library +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 Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +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 + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "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 +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. 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 LIBRARY 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 +LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), 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 Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. 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. + + {description} + Copyright (C) {year} {fullname} + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; 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. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random + Hacker. + + {signature of Ty Coon}, 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth.h new file mode 100644 index 0000000..3e7096f --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth.h @@ -0,0 +1,121 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_H +#define _FLUIDSYNTH_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define BUILD_SHARED_LIBS 1 + +#if (BUILD_SHARED_LIBS == 0) + #define FLUIDSYNTH_API // building static lib? no visibility control then +#elif defined(WIN32) + #if defined(FLUIDSYNTH_NOT_A_DLL) + #define FLUIDSYNTH_API + #elif defined(FLUIDSYNTH_DLL_EXPORTS) + #define FLUIDSYNTH_API __declspec(dllexport) + #else + #define FLUIDSYNTH_API __declspec(dllimport) + #endif + +#elif defined(MACOS9) +#define FLUIDSYNTH_API __declspec(export) + +#elif defined(__OS2__) +#define FLUIDSYNTH_API __declspec(dllexport) + +#elif defined(__GNUC__) +#define FLUIDSYNTH_API __attribute__ ((visibility ("default"))) + +#else +#define FLUIDSYNTH_API + +#endif + +#if defined(__GNUC__) || defined(__clang__) +# define FLUID_DEPRECATED __attribute__((deprecated)) +#elif defined(_MSC_VER) && _MSC_VER > 1200 +# define FLUID_DEPRECATED __declspec(deprecated) +#else +# define FLUID_DEPRECATED +#endif + + +/** + * @file fluidsynth.h + * @brief FluidSynth is a real-time synthesizer designed for SoundFont(R) files. + * + * This is the header of the fluidsynth library and contains the + * synthesizer's public API. + * + * Depending on how you want to use or extend the synthesizer you + * will need different API functions. You probably do not need all + * of them. Here is what you might want to do: + * + * - Embedded synthesizer: create a new synthesizer and send MIDI + * events to it. The sound goes directly to the audio output of + * your system. + * + * - Plugin synthesizer: create a synthesizer and send MIDI events + * but pull the audio back into your application. + * + * - SoundFont plugin: create a new type of "SoundFont" and allow + * the synthesizer to load your type of SoundFonts. + * + * - MIDI input: Create a MIDI handler to read the MIDI input on your + * machine and send the MIDI events directly to the synthesizer. + * + * - MIDI files: Open MIDI files and send the MIDI events to the + * synthesizer. + * + * - Command lines: You can send textual commands to the synthesizer. + * + * SoundFont(R) is a registered trademark of E-mu Systems, Inc. + */ + +#include "fluidsynth/types.h" +#include "fluidsynth/settings.h" +#include "fluidsynth/synth.h" +#include "fluidsynth/shell.h" +#include "fluidsynth/sfont.h" +#include "fluidsynth/audio.h" +#include "fluidsynth/event.h" +#include "fluidsynth/midi.h" +#include "fluidsynth/seq.h" +#include "fluidsynth/seqbind.h" +#include "fluidsynth/log.h" +#include "fluidsynth/misc.h" +#include "fluidsynth/mod.h" +#include "fluidsynth/gen.h" +#include "fluidsynth/voice.h" +#include "fluidsynth/version.h" +#include "fluidsynth/ladspa.h" + + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/audio.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/audio.h new file mode 100644 index 0000000..1c12ff7 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/audio.h @@ -0,0 +1,155 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_AUDIO_H +#define _FLUIDSYNTH_AUDIO_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup audio_output Audio Output + * + * Functions for managing audio drivers and file renderers. + * + * The file renderer is used for fast rendering of MIDI files to + * audio files. The audio drivers are a high-level interface to + * connect the synthesizer with external audio sinks or to render + * real-time audio to files. + */ + +/** + * @defgroup audio_driver Audio Driver + * @ingroup audio_output + * + * Functions for managing audio drivers. + * + * Defines functions for creating audio driver output. Use + * new_fluid_audio_driver() to create a new audio driver for a given synth + * and configuration settings. + * + * The function new_fluid_audio_driver2() can be + * used if custom audio processing is desired before the audio is sent to the + * audio driver (although it is not as efficient). + * + * @sa @ref CreatingAudioDriver + * + * @{ + */ + +/** + * Callback function type used with new_fluid_audio_driver2() to allow for + * custom user audio processing before the audio is sent to the driver. + * + * @param data The user data parameter as passed to new_fluid_audio_driver2(). + * @param len Count of audio frames to synthesize. + * @param nfx Count of arrays in \c fx. + * @param fx Array of buffers to store effects audio to. Buffers may alias with buffers of \c out. + * @param nout Count of arrays in \c out. + * @param out Array of buffers to store (dry) audio to. Buffers may alias with buffers of \c fx. + * @return Should return #FLUID_OK on success, #FLUID_FAILED if an error occurred. + * + * This function is responsible for rendering audio to the buffers. + * The buffers passed to this function are allocated and owned by the respective + * audio driver and are only valid during that specific call (do not cache them). + * The buffers have already been zeroed-out. + * For further details please refer to fluid_synth_process(). + * + * @parblock + * @note Whereas fluid_synth_process() allows aliasing buffers, there is the guarantee that @p out + * and @p fx buffers provided by fluidsynth's audio drivers never alias. This prevents downstream + * applications from e.g. applying a custom effect accidentally to the same buffer multiple times. + * @endparblock + * + * @parblock + * @note Also note that the Jack driver is currently the only driver that has dedicated @p fx buffers + * (but only if \setting{audio_jack_multi} is true). All other drivers do not provide @p fx buffers. + * In this case, users are encouraged to mix the effects into the provided dry buffers when calling + * fluid_synth_process(). + * @code{.cpp} +int myCallback(void *, int len, int nfx, float *fx[], int nout, float *out[]) +{ + int ret; + if(nfx == 0) + { + float *fxb[4] = {out[0], out[1], out[0], out[1]}; + ret = fluid_synth_process(synth, len, sizeof(fxb) / sizeof(fxb[0]), fxb, nout, out); + } + else + { + ret = fluid_synth_process(synth, len, nfx, fx, nout, out); + } + // ... client-code ... + return ret; +} + * @endcode + * For other possible use-cases refer to \ref fluidsynth_process.c . + * @endparblock + */ +typedef int (*fluid_audio_func_t)(void *data, int len, + int nfx, float *fx[], + int nout, float *out[]); + +/** @startlifecycle{Audio Driver} */ +FLUIDSYNTH_API fluid_audio_driver_t *new_fluid_audio_driver(fluid_settings_t *settings, + fluid_synth_t *synth); + +FLUIDSYNTH_API fluid_audio_driver_t *new_fluid_audio_driver2(fluid_settings_t *settings, + fluid_audio_func_t func, + void *data); + +FLUIDSYNTH_API void delete_fluid_audio_driver(fluid_audio_driver_t *driver); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_audio_driver_register(const char **adrivers); +/** @} */ + +/** + * @defgroup file_renderer File Renderer + * @ingroup audio_output + * + * Functions for managing file renderers and triggering the rendering. + * + * The file renderer is only used to render a MIDI file to audio as fast + * as possible. Please see \ref FileRenderer for a full example. + * + * If you are looking for a way to write audio generated + * from real-time events (for example from an external sequencer or a MIDI controller) to a file, + * please have a look at the \c file \ref audio_driver instead. + * + * + * @{ + */ + +/** @startlifecycle{File Renderer} */ +FLUIDSYNTH_API fluid_file_renderer_t *new_fluid_file_renderer(fluid_synth_t *synth); +FLUIDSYNTH_API void delete_fluid_file_renderer(fluid_file_renderer_t *dev); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_file_renderer_process_block(fluid_file_renderer_t *dev); +FLUIDSYNTH_API int fluid_file_set_encoding_quality(fluid_file_renderer_t *dev, double q); +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_AUDIO_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/event.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/event.h new file mode 100644 index 0000000..dbc29c7 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/event.h @@ -0,0 +1,143 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_EVENT_H +#define _FLUIDSYNTH_EVENT_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup sequencer_events Sequencer Events + * @ingroup sequencer + * + * Create, modify, query and destroy sequencer events. + * + * @{ + */ + +/** + * Sequencer event type enumeration. + */ +enum fluid_seq_event_type +{ + FLUID_SEQ_NOTE = 0, /**< Note event with duration */ + FLUID_SEQ_NOTEON, /**< Note on event */ + FLUID_SEQ_NOTEOFF, /**< Note off event */ + FLUID_SEQ_ALLSOUNDSOFF, /**< All sounds off event */ + FLUID_SEQ_ALLNOTESOFF, /**< All notes off event */ + FLUID_SEQ_BANKSELECT, /**< Bank select message */ + FLUID_SEQ_PROGRAMCHANGE, /**< Program change message */ + FLUID_SEQ_PROGRAMSELECT, /**< Program select message */ + FLUID_SEQ_PITCHBEND, /**< Pitch bend message */ + FLUID_SEQ_PITCHWHEELSENS, /**< Pitch wheel sensitivity set message @since 1.1.0 was misspelled previously */ + FLUID_SEQ_MODULATION, /**< Modulation controller event */ + FLUID_SEQ_SUSTAIN, /**< Sustain controller event */ + FLUID_SEQ_CONTROLCHANGE, /**< MIDI control change event */ + FLUID_SEQ_PAN, /**< Stereo pan set event */ + FLUID_SEQ_VOLUME, /**< Volume set event */ + FLUID_SEQ_REVERBSEND, /**< Reverb send set event */ + FLUID_SEQ_CHORUSSEND, /**< Chorus send set event */ + FLUID_SEQ_TIMER, /**< Timer event (useful for giving a callback at a certain time) */ + FLUID_SEQ_CHANNELPRESSURE, /**< Channel aftertouch event @since 1.1.0 */ + FLUID_SEQ_KEYPRESSURE, /**< Polyphonic aftertouch event @since 2.0.0 */ + FLUID_SEQ_SYSTEMRESET, /**< System reset event @since 1.1.0 */ + FLUID_SEQ_UNREGISTERING, /**< Called when a sequencer client is being unregistered. @since 1.1.0 */ + FLUID_SEQ_SCALE, /**< Sets a new time scale for the sequencer @since 2.2.0 */ + FLUID_SEQ_LASTEVENT /**< @internal Defines the count of events enums @warning This symbol + is not part of the public API and ABI stability guarantee and + may change at any time! */ +}; + +/* Event alloc/free */ +/** @startlifecycle{Sequencer Event} */ +FLUIDSYNTH_API fluid_event_t *new_fluid_event(void); +FLUIDSYNTH_API void delete_fluid_event(fluid_event_t *evt); +/** @endlifecycle */ + +/* Initializing events */ +FLUIDSYNTH_API void fluid_event_set_source(fluid_event_t *evt, fluid_seq_id_t src); +FLUIDSYNTH_API void fluid_event_set_dest(fluid_event_t *evt, fluid_seq_id_t dest); + +/* Timer events */ +FLUIDSYNTH_API void fluid_event_timer(fluid_event_t *evt, void *data); + +/* Note events */ +FLUIDSYNTH_API void fluid_event_note(fluid_event_t *evt, int channel, + short key, short vel, + unsigned int duration); + +FLUIDSYNTH_API void fluid_event_noteon(fluid_event_t *evt, int channel, short key, short vel); +FLUIDSYNTH_API void fluid_event_noteoff(fluid_event_t *evt, int channel, short key); +FLUIDSYNTH_API void fluid_event_all_sounds_off(fluid_event_t *evt, int channel); +FLUIDSYNTH_API void fluid_event_all_notes_off(fluid_event_t *evt, int channel); + +/* Instrument selection */ +FLUIDSYNTH_API void fluid_event_bank_select(fluid_event_t *evt, int channel, short bank_num); +FLUIDSYNTH_API void fluid_event_program_change(fluid_event_t *evt, int channel, int preset_num); +FLUIDSYNTH_API void fluid_event_program_select(fluid_event_t *evt, int channel, unsigned int sfont_id, short bank_num, short preset_num); + +/* Real-time generic instrument controllers */ +FLUIDSYNTH_API +void fluid_event_control_change(fluid_event_t *evt, int channel, short control, int val); + +/* Real-time instrument controllers shortcuts */ +FLUIDSYNTH_API void fluid_event_pitch_bend(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_pitch_wheelsens(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_modulation(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_sustain(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_pan(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_volume(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_reverb_send(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_chorus_send(fluid_event_t *evt, int channel, int val); + +FLUIDSYNTH_API void fluid_event_key_pressure(fluid_event_t *evt, int channel, short key, int val); +FLUIDSYNTH_API void fluid_event_channel_pressure(fluid_event_t *evt, int channel, int val); +FLUIDSYNTH_API void fluid_event_system_reset(fluid_event_t *evt); + +/* Only when unregistering clients */ +FLUIDSYNTH_API void fluid_event_unregistering(fluid_event_t *evt); + +FLUIDSYNTH_API void fluid_event_scale(fluid_event_t *evt, double new_scale); +FLUIDSYNTH_API int fluid_event_from_midi_event(fluid_event_t *, const fluid_midi_event_t *); + +/* Accessing event data */ +FLUIDSYNTH_API int fluid_event_get_type(fluid_event_t *evt); +FLUIDSYNTH_API fluid_seq_id_t fluid_event_get_source(fluid_event_t *evt); +FLUIDSYNTH_API fluid_seq_id_t fluid_event_get_dest(fluid_event_t *evt); +FLUIDSYNTH_API int fluid_event_get_channel(fluid_event_t *evt); +FLUIDSYNTH_API short fluid_event_get_key(fluid_event_t *evt); +FLUIDSYNTH_API short fluid_event_get_velocity(fluid_event_t *evt); +FLUIDSYNTH_API short fluid_event_get_control(fluid_event_t *evt); +FLUIDSYNTH_API int fluid_event_get_value(fluid_event_t *evt); +FLUIDSYNTH_API int fluid_event_get_program(fluid_event_t *evt); +FLUIDSYNTH_API void *fluid_event_get_data(fluid_event_t *evt); +FLUIDSYNTH_API unsigned int fluid_event_get_duration(fluid_event_t *evt); +FLUIDSYNTH_API short fluid_event_get_bank(fluid_event_t *evt); +FLUIDSYNTH_API int fluid_event_get_pitch(fluid_event_t *evt); +FLUIDSYNTH_API double fluid_event_get_scale(fluid_event_t *evt); +FLUIDSYNTH_API unsigned int fluid_event_get_sfont_id(fluid_event_t *evt); +/** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* _FLUIDSYNTH_EVENT_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/gen.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/gen.h new file mode 100644 index 0000000..a04c362 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/gen.h @@ -0,0 +1,134 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_GEN_H +#define _FLUIDSYNTH_GEN_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup generators SoundFont Generators + * @ingroup soundfonts + * + * Functions and defines for SoundFont generator effects. + * + * @{ + */ + +/** + * Generator (effect) numbers (Soundfont 2.01 specifications section 8.1.3) + */ +enum fluid_gen_type +{ + GEN_STARTADDROFS, /**< Sample start address offset (0-32767) */ + GEN_ENDADDROFS, /**< Sample end address offset (-32767-0) */ + GEN_STARTLOOPADDROFS, /**< Sample loop start address offset (-32767-32767) */ + GEN_ENDLOOPADDROFS, /**< Sample loop end address offset (-32767-32767) */ + GEN_STARTADDRCOARSEOFS, /**< Sample start address coarse offset (X 32768) */ + GEN_MODLFOTOPITCH, /**< Modulation LFO to pitch */ + GEN_VIBLFOTOPITCH, /**< Vibrato LFO to pitch */ + GEN_MODENVTOPITCH, /**< Modulation envelope to pitch */ + GEN_FILTERFC, /**< Filter cutoff */ + GEN_FILTERQ, /**< Filter Q */ + GEN_MODLFOTOFILTERFC, /**< Modulation LFO to filter cutoff */ + GEN_MODENVTOFILTERFC, /**< Modulation envelope to filter cutoff */ + GEN_ENDADDRCOARSEOFS, /**< Sample end address coarse offset (X 32768) */ + GEN_MODLFOTOVOL, /**< Modulation LFO to volume */ + GEN_UNUSED1, /**< Unused */ + GEN_CHORUSSEND, /**< Chorus send amount */ + GEN_REVERBSEND, /**< Reverb send amount */ + GEN_PAN, /**< Stereo panning */ + GEN_UNUSED2, /**< Unused */ + GEN_UNUSED3, /**< Unused */ + GEN_UNUSED4, /**< Unused */ + GEN_MODLFODELAY, /**< Modulation LFO delay */ + GEN_MODLFOFREQ, /**< Modulation LFO frequency */ + GEN_VIBLFODELAY, /**< Vibrato LFO delay */ + GEN_VIBLFOFREQ, /**< Vibrato LFO frequency */ + GEN_MODENVDELAY, /**< Modulation envelope delay */ + GEN_MODENVATTACK, /**< Modulation envelope attack */ + GEN_MODENVHOLD, /**< Modulation envelope hold */ + GEN_MODENVDECAY, /**< Modulation envelope decay */ + GEN_MODENVSUSTAIN, /**< Modulation envelope sustain */ + GEN_MODENVRELEASE, /**< Modulation envelope release */ + GEN_KEYTOMODENVHOLD, /**< Key to modulation envelope hold */ + GEN_KEYTOMODENVDECAY, /**< Key to modulation envelope decay */ + GEN_VOLENVDELAY, /**< Volume envelope delay */ + GEN_VOLENVATTACK, /**< Volume envelope attack */ + GEN_VOLENVHOLD, /**< Volume envelope hold */ + GEN_VOLENVDECAY, /**< Volume envelope decay */ + GEN_VOLENVSUSTAIN, /**< Volume envelope sustain */ + GEN_VOLENVRELEASE, /**< Volume envelope release */ + GEN_KEYTOVOLENVHOLD, /**< Key to volume envelope hold */ + GEN_KEYTOVOLENVDECAY, /**< Key to volume envelope decay */ + GEN_INSTRUMENT, /**< Instrument ID (shouldn't be set by user) */ + GEN_RESERVED1, /**< Reserved */ + GEN_KEYRANGE, /**< MIDI note range */ + GEN_VELRANGE, /**< MIDI velocity range */ + GEN_STARTLOOPADDRCOARSEOFS, /**< Sample start loop address coarse offset (X 32768) */ + GEN_KEYNUM, /**< Fixed MIDI note number */ + GEN_VELOCITY, /**< Fixed MIDI velocity value */ + GEN_ATTENUATION, /**< Initial volume attenuation */ + GEN_RESERVED2, /**< Reserved */ + GEN_ENDLOOPADDRCOARSEOFS, /**< Sample end loop address coarse offset (X 32768) */ + GEN_COARSETUNE, /**< Coarse tuning */ + GEN_FINETUNE, /**< Fine tuning */ + GEN_SAMPLEID, /**< Sample ID (shouldn't be set by user) */ + GEN_SAMPLEMODE, /**< Sample mode flags */ + GEN_RESERVED3, /**< Reserved */ + GEN_SCALETUNE, /**< Scale tuning */ + GEN_EXCLUSIVECLASS, /**< Exclusive class number */ + GEN_OVERRIDEROOTKEY, /**< Sample root note override */ + + /** + * Initial Pitch + * + * @note This is not "standard" SoundFont generator, because it is not + * mentioned in the list of generators in the SF2 specifications. + * It is used by FluidSynth internally to compute the nominal pitch of + * a note on note-on event. By nature it shouldn't be allowed to be modulated, + * however the specification defines a default modulator having "Initial Pitch" + * as destination (cf. SF2.01 page 57 section 8.4.10 MIDI Pitch Wheel to Initial Pitch). + * Thus it is impossible to cancel this default modulator, which would be required + * to let the MIDI Pitch Wheel controller modulate a different generator. + * In order to provide this flexibility, FluidSynth >= 2.1.0 uses a default modulator + * "Pitch Wheel to Fine Tune", rather than Initial Pitch. The same "compromise" can + * be found on the Audigy 2 ZS for instance. + */ + GEN_PITCH, + + GEN_CUSTOM_BALANCE, /**< Balance @note Not a real SoundFont generator */ + /* non-standard generator for an additional custom high- or low-pass filter */ + GEN_CUSTOM_FILTERFC, /**< Custom filter cutoff frequency */ + GEN_CUSTOM_FILTERQ, /**< Custom filter Q */ + + GEN_LAST /**< @internal Value defines the count of generators (#fluid_gen_type) + @warning This symbol is not part of the public API and ABI + stability guarantee and may change at any time! */ +}; +/** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* _FLUIDSYNTH_GEN_H */ + diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/ladspa.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/ladspa.h new file mode 100644 index 0000000..ae44f2b --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/ladspa.h @@ -0,0 +1,69 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_LADSPA_H +#define _FLUIDSYNTH_LADSPA_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup ladspa Effect - LADSPA + * @ingroup synth + * + * Functions for configuring the LADSPA effects unit + * + * This header defines useful functions for programmatically manipulating the ladspa + * effects unit of the synth that can be retrieved via fluid_synth_get_ladspa_fx(). + * + * Using any of those functions requires fluidsynth to be compiled with LADSPA support. + * Else all of those functions are useless dummies. + * + * @{ + */ +FLUIDSYNTH_API int fluid_ladspa_is_active(fluid_ladspa_fx_t *fx); +FLUIDSYNTH_API int fluid_ladspa_activate(fluid_ladspa_fx_t *fx); +FLUIDSYNTH_API int fluid_ladspa_deactivate(fluid_ladspa_fx_t *fx); +FLUIDSYNTH_API int fluid_ladspa_reset(fluid_ladspa_fx_t *fx); +FLUIDSYNTH_API int fluid_ladspa_check(fluid_ladspa_fx_t *fx, char *err, int err_size); + +FLUIDSYNTH_API int fluid_ladspa_host_port_exists(fluid_ladspa_fx_t *fx, const char *name); + +FLUIDSYNTH_API int fluid_ladspa_add_buffer(fluid_ladspa_fx_t *fx, const char *name); +FLUIDSYNTH_API int fluid_ladspa_buffer_exists(fluid_ladspa_fx_t *fx, const char *name); + +FLUIDSYNTH_API int fluid_ladspa_add_effect(fluid_ladspa_fx_t *fx, const char *effect_name, + const char *lib_name, const char *plugin_name); +FLUIDSYNTH_API int fluid_ladspa_effect_can_mix(fluid_ladspa_fx_t *fx, const char *name); +FLUIDSYNTH_API int fluid_ladspa_effect_set_mix(fluid_ladspa_fx_t *fx, const char *name, int mix, float gain); +FLUIDSYNTH_API int fluid_ladspa_effect_port_exists(fluid_ladspa_fx_t *fx, const char *effect_name, const char *port_name); +FLUIDSYNTH_API int fluid_ladspa_effect_set_control(fluid_ladspa_fx_t *fx, const char *effect_name, + const char *port_name, float val); +FLUIDSYNTH_API int fluid_ladspa_effect_link(fluid_ladspa_fx_t *fx, const char *effect_name, + const char *port_name, const char *name); +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_LADSPA_H */ + diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/log.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/log.h new file mode 100644 index 0000000..ab5911e --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/log.h @@ -0,0 +1,97 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_LOG_H +#define _FLUIDSYNTH_LOG_H + + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @defgroup logging Logging + * + * Logging interface + * + * The default logging function of the fluidsynth prints its messages to the + * stderr. The synthesizer uses five level of messages: #FLUID_PANIC, + * #FLUID_ERR, #FLUID_WARN, #FLUID_INFO, and #FLUID_DBG. + * + * A client application can install a new log function to handle the messages + * differently. In the following example, the application sets a callback + * function to display #FLUID_PANIC messages in a dialog, and ignores all other + * messages by setting the log function to NULL: + * + * @code + * fluid_set_log_function(FLUID_PANIC, show_dialog, (void*) root_window); + * fluid_set_log_function(FLUID_ERR, NULL, NULL); + * fluid_set_log_function(FLUID_WARN, NULL, NULL); + * fluid_set_log_function(FLUID_DBG, NULL, NULL); + * @endcode + * + * @note The logging configuration is global and not tied to a specific + * synthesizer instance. That means that all synthesizer instances created in + * the same process share the same logging configuration. + * + * @{ + */ + +/** + * FluidSynth log levels. + */ +enum fluid_log_level +{ + FLUID_PANIC, /**< The synth can't function correctly any more */ + FLUID_ERR, /**< Serious error occurred */ + FLUID_WARN, /**< Warning */ + FLUID_INFO, /**< Verbose informational messages */ + FLUID_DBG, /**< Debugging messages */ + LAST_LOG_LEVEL /**< @internal This symbol is not part of the public API and ABI + stability guarantee and may change at any time! */ +}; + +/** + * Log function handler callback type used by fluid_set_log_function(). + * + * @param level Log level (#fluid_log_level) + * @param message Log message text + * @param data User data pointer supplied to fluid_set_log_function(). + */ +typedef void (*fluid_log_function_t)(int level, const char *message, void *data); + +FLUIDSYNTH_API +fluid_log_function_t fluid_set_log_function(int level, fluid_log_function_t fun, void *data); + +FLUIDSYNTH_API void fluid_default_log_function(int level, const char *message, void *data); + +FLUIDSYNTH_API int fluid_log(int level, const char *fmt, ...) +#if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__) +__attribute__ ((format (printf, 2, 3))) +#endif +; +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_LOG_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/midi.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/midi.h new file mode 100644 index 0000000..044eeeb --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/midi.h @@ -0,0 +1,295 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_MIDI_H +#define _FLUIDSYNTH_MIDI_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup midi_input MIDI Input + * + * MIDI Input Subsystem + * + * There are multiple ways to send MIDI events to the synthesizer. They can come + * from MIDI files, from external MIDI sequencers or raw MIDI event sources, + * can be modified via MIDI routers and also generated manually. + * + * The interface connecting all sources and sinks of MIDI events in libfluidsynth + * is \ref handle_midi_event_func_t. + * + * @{ + */ + +/** + * Generic callback function for MIDI event handler. + * + * @param data User defined data pointer + * @param event The MIDI event + * @return Should return #FLUID_OK on success, #FLUID_FAILED otherwise + * + * This callback is used to pass MIDI events + * - from \ref midi_player, \ref midi_router or \ref midi_driver + * - to \ref midi_router via fluid_midi_router_handle_midi_event() + * - or to \ref synth via fluid_synth_handle_midi_event(). + * + * Additionally, there is a translation layer to pass MIDI events to + * a \ref sequencer via fluid_sequencer_add_midi_event_to_buffer(). + */ +typedef int (*handle_midi_event_func_t)(void *data, fluid_midi_event_t *event); + +/** + * Generic callback function fired once by MIDI tick change. + * + * @param data User defined data pointer + * @param tick The current (zero-based) tick, which triggered the callback + * @return Should return #FLUID_OK on success, #FLUID_FAILED otherwise + * + * This callback is fired at a constant rate depending on the current BPM and PPQ. + * e.g. for PPQ = 192 and BPM = 140 the callback is fired 192 * 140 times per minute (448/sec). + * + * It can be used to sync external elements with the beat, + * or stop / loop the song on a given tick. + * Ticks being BPM-dependent, you can manipulate values such as bars or beats, + * without having to care about BPM. + * + * For example, this callback loops the song whenever it reaches the 5th bar : + * + * @code{.cpp} +int handle_tick(void *data, int tick) +{ + fluid_player_t *player = (fluid_player_t *)data; + int ppq = 192; // From MIDI header + int beatsPerBar = 4; // From the song's time signature + int loopBar = 5; + int loopTick = (loopBar - 1) * ppq * beatsPerBar; + + if (tick == loopTick) + { + return fluid_player_seek(player, 0); + } + + return FLUID_OK; +} + * @endcode + */ +typedef int (*handle_midi_tick_func_t)(void *data, int tick); +/** @} */ + +/** + * @defgroup midi_events MIDI Events + * @ingroup midi_input + * + * Functions to create, modify, query and delete MIDI events. + * + * These functions are intended to be used in MIDI routers and other filtering + * and processing functions in the MIDI event path. If you want to simply + * send MIDI messages to the synthesizer, you can use the more convenient + * \ref midi_messages interface. + * + * @{ + */ +/** @startlifecycle{MIDI Event} */ +FLUIDSYNTH_API fluid_midi_event_t *new_fluid_midi_event(void); +FLUIDSYNTH_API void delete_fluid_midi_event(fluid_midi_event_t *event); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_midi_event_set_type(fluid_midi_event_t *evt, int type); +FLUIDSYNTH_API int fluid_midi_event_get_type(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_set_channel(fluid_midi_event_t *evt, int chan); +FLUIDSYNTH_API int fluid_midi_event_get_channel(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_get_key(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_set_key(fluid_midi_event_t *evt, int key); +FLUIDSYNTH_API int fluid_midi_event_get_velocity(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_set_velocity(fluid_midi_event_t *evt, int vel); +FLUIDSYNTH_API int fluid_midi_event_get_control(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_set_control(fluid_midi_event_t *evt, int ctrl); +FLUIDSYNTH_API int fluid_midi_event_get_value(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_set_value(fluid_midi_event_t *evt, int val); +FLUIDSYNTH_API int fluid_midi_event_get_program(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_set_program(fluid_midi_event_t *evt, int val); +FLUIDSYNTH_API int fluid_midi_event_get_pitch(const fluid_midi_event_t *evt); +FLUIDSYNTH_API int fluid_midi_event_set_pitch(fluid_midi_event_t *evt, int val); +FLUIDSYNTH_API int fluid_midi_event_set_sysex(fluid_midi_event_t *evt, void *data, + int size, int dynamic); +FLUIDSYNTH_API int fluid_midi_event_set_text(fluid_midi_event_t *evt, + void *data, int size, int dynamic); +FLUIDSYNTH_API int fluid_midi_event_get_text(fluid_midi_event_t *evt, + void **data, int *size); +FLUIDSYNTH_API int fluid_midi_event_set_lyrics(fluid_midi_event_t *evt, + void *data, int size, int dynamic); +FLUIDSYNTH_API int fluid_midi_event_get_lyrics(fluid_midi_event_t *evt, + void **data, int *size); +/** @} */ + +/** + * @defgroup midi_router MIDI Router + * @ingroup midi_input + * + * Rule based transformation and filtering of MIDI events. + * + * @{ + */ + +/** + * MIDI router rule type. + * + * @since 1.1.0 + */ +typedef enum +{ + FLUID_MIDI_ROUTER_RULE_NOTE, /**< MIDI note rule */ + FLUID_MIDI_ROUTER_RULE_CC, /**< MIDI controller rule */ + FLUID_MIDI_ROUTER_RULE_PROG_CHANGE, /**< MIDI program change rule */ + FLUID_MIDI_ROUTER_RULE_PITCH_BEND, /**< MIDI pitch bend rule */ + FLUID_MIDI_ROUTER_RULE_CHANNEL_PRESSURE, /**< MIDI channel pressure rule */ + FLUID_MIDI_ROUTER_RULE_KEY_PRESSURE, /**< MIDI key pressure rule */ + FLUID_MIDI_ROUTER_RULE_COUNT /**< @internal Total count of rule types. This symbol + is not part of the public API and ABI stability + guarantee and may change at any time!*/ +} fluid_midi_router_rule_type; + + +/** @startlifecycle{MIDI Router} */ +FLUIDSYNTH_API fluid_midi_router_t *new_fluid_midi_router(fluid_settings_t *settings, + handle_midi_event_func_t handler, + void *event_handler_data); +FLUIDSYNTH_API void delete_fluid_midi_router(fluid_midi_router_t *handler); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_midi_router_set_default_rules(fluid_midi_router_t *router); +FLUIDSYNTH_API int fluid_midi_router_clear_rules(fluid_midi_router_t *router); +FLUIDSYNTH_API int fluid_midi_router_add_rule(fluid_midi_router_t *router, + fluid_midi_router_rule_t *rule, int type); + + +/** @startlifecycle{MIDI Router Rule} */ +FLUIDSYNTH_API fluid_midi_router_rule_t *new_fluid_midi_router_rule(void); +FLUIDSYNTH_API void delete_fluid_midi_router_rule(fluid_midi_router_rule_t *rule); +/** @endlifecycle */ + +FLUIDSYNTH_API void fluid_midi_router_rule_set_chan(fluid_midi_router_rule_t *rule, + int min, int max, float mul, int add); +FLUIDSYNTH_API void fluid_midi_router_rule_set_param1(fluid_midi_router_rule_t *rule, + int min, int max, float mul, int add); +FLUIDSYNTH_API void fluid_midi_router_rule_set_param2(fluid_midi_router_rule_t *rule, + int min, int max, float mul, int add); +FLUIDSYNTH_API int fluid_midi_router_handle_midi_event(void *data, fluid_midi_event_t *event); +FLUIDSYNTH_API int fluid_midi_dump_prerouter(void *data, fluid_midi_event_t *event); +FLUIDSYNTH_API int fluid_midi_dump_postrouter(void *data, fluid_midi_event_t *event); +/** @} */ + +/** + * @defgroup midi_driver MIDI Driver + * @ingroup midi_input + * + * Functions for managing MIDI drivers. + * + * The available MIDI drivers depend on your platform. See \ref settings_midi for all + * available configuration options. + * + * To create a MIDI driver, you need to specify a source for the MIDI events to be + * forwarded to via the \ref fluid_midi_event_t callback. Normally this will be + * either a \ref midi_router via fluid_midi_router_handle_midi_event() or the synthesizer + * via fluid_synth_handle_midi_event(). + * + * But you can also write your own handler function that preprocesses the events and + * forwards them on to the router or synthesizer instead. + * + * @{ + */ + +/** @startlifecycle{MIDI Driver} */ +FLUIDSYNTH_API +fluid_midi_driver_t *new_fluid_midi_driver(fluid_settings_t *settings, + handle_midi_event_func_t handler, + void *event_handler_data); + +FLUIDSYNTH_API void delete_fluid_midi_driver(fluid_midi_driver_t *driver); +/** @endlifecycle */ + +/** @} */ + +/** + * @defgroup midi_player MIDI File Player + * @ingroup midi_input + * + * Parse standard MIDI files and emit MIDI events. + * + * @{ + */ + +/** + * MIDI File Player status enum. + * @since 1.1.0 + */ +enum fluid_player_status +{ + FLUID_PLAYER_READY, /**< Player is ready */ + FLUID_PLAYER_PLAYING, /**< Player is currently playing */ + FLUID_PLAYER_STOPPING, /**< Player is stopping, but hasn't finished yet (currently unused) */ + FLUID_PLAYER_DONE /**< Player is finished playing */ +}; + +/** + * MIDI File Player tempo enum. + * @since 2.2.0 + */ +enum fluid_player_set_tempo_type +{ + FLUID_PLAYER_TEMPO_INTERNAL, /**< Use midi file tempo set in midi file (120 bpm by default). Multiplied by a factor */ + FLUID_PLAYER_TEMPO_EXTERNAL_BPM, /**< Set player tempo in bpm, supersede midi file tempo */ + FLUID_PLAYER_TEMPO_EXTERNAL_MIDI, /**< Set player tempo in us per quarter note, supersede midi file tempo */ + FLUID_PLAYER_TEMPO_NBR /**< @internal Value defines the count of player tempo type (#fluid_player_set_tempo_type) @warning This symbol is not part of the public API and ABI stability guarantee and may change at any time! */ +}; + +/** @startlifecycle{MIDI File Player} */ +FLUIDSYNTH_API fluid_player_t *new_fluid_player(fluid_synth_t *synth); +FLUIDSYNTH_API void delete_fluid_player(fluid_player_t *player); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_player_add(fluid_player_t *player, const char *midifile); +FLUIDSYNTH_API int fluid_player_add_mem(fluid_player_t *player, const void *buffer, size_t len); +FLUIDSYNTH_API int fluid_player_play(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_stop(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_join(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_set_loop(fluid_player_t *player, int loop); +FLUIDSYNTH_API int fluid_player_set_tempo(fluid_player_t *player, int tempo_type, double tempo); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_player_set_midi_tempo(fluid_player_t *player, int tempo); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_player_set_bpm(fluid_player_t *player, int bpm); +FLUIDSYNTH_API int fluid_player_set_playback_callback(fluid_player_t *player, handle_midi_event_func_t handler, void *handler_data); +FLUIDSYNTH_API int fluid_player_set_tick_callback(fluid_player_t *player, handle_midi_tick_func_t handler, void *handler_data); + +FLUIDSYNTH_API int fluid_player_get_status(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_get_current_tick(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_get_total_ticks(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_get_bpm(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_get_division(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_get_midi_tempo(fluid_player_t *player); +FLUIDSYNTH_API int fluid_player_seek(fluid_player_t *player, int ticks); +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_MIDI_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/misc.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/misc.h new file mode 100644 index 0000000..f60bf61 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/misc.h @@ -0,0 +1,77 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_MISC_H +#define _FLUIDSYNTH_MISC_H + + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @defgroup misc Miscellaneous + * + * Miscellaneous utility functions and defines + * + * @{ + */ + +/** + * Value that indicates success, used by most libfluidsynth functions. + * + * @note This was not publicly defined prior to libfluidsynth 1.1.0. When + * writing code which should also be compatible with older versions, something + * like the following can be used: + * + * @code + * #include + * + * #ifndef FLUID_OK + * #define FLUID_OK (0) + * #define FLUID_FAILED (-1) + * #endif + * @endcode + * + * @since 1.1.0 + */ +#define FLUID_OK (0) + +/** + * Value that indicates failure, used by most libfluidsynth functions. + * + * @note See #FLUID_OK for more details. + * + * @since 1.1.0 + */ +#define FLUID_FAILED (-1) + + +FLUIDSYNTH_API int fluid_is_soundfont(const char *filename); +FLUIDSYNTH_API int fluid_is_midifile(const char *filename); +FLUIDSYNTH_API void fluid_free(void* ptr); +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_MISC_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/mod.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/mod.h new file mode 100644 index 0000000..001b790 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/mod.h @@ -0,0 +1,116 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_MOD_H +#define _FLUIDSYNTH_MOD_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup modulators SoundFont Modulators + * @ingroup soundfonts + * + * SoundFont modulator functions and constants. + * + * @{ + */ + +/** + * Flags defining the polarity, mapping function and type of a modulator source. + * Compare with SoundFont 2.04 PDF section 8.2. + * + * Note: Bit values do not correspond to the SoundFont spec! Also note that + * #FLUID_MOD_GC and #FLUID_MOD_CC are in the flags field instead of the source field. + */ +enum fluid_mod_flags +{ + FLUID_MOD_POSITIVE = 0, /**< Mapping function is positive */ + FLUID_MOD_NEGATIVE = 1, /**< Mapping function is negative */ + FLUID_MOD_UNIPOLAR = 0, /**< Mapping function is unipolar */ + FLUID_MOD_BIPOLAR = 2, /**< Mapping function is bipolar */ + FLUID_MOD_LINEAR = 0, /**< Linear mapping function */ + FLUID_MOD_CONCAVE = 4, /**< Concave mapping function */ + FLUID_MOD_CONVEX = 8, /**< Convex mapping function */ + FLUID_MOD_SWITCH = 12, /**< Switch (on/off) mapping function */ + FLUID_MOD_GC = 0, /**< General controller source type (#fluid_mod_src) */ + FLUID_MOD_CC = 16, /**< MIDI CC controller (source will be a MIDI CC number) */ + + FLUID_MOD_SIN = 0x80, /**< Custom non-standard sinus mapping function */ +}; + +/** + * Transform types for the SoundFont2 modulators as defined by SoundFont 2.04 section 8.3. + */ +enum fluid_mod_transforms +{ + FLUID_MOD_TRANSFORM_LINEAR = 0, /**< Linear: directly add the computed value to summing node */ + FLUID_MOD_TRANSFORM_ABS = 2 /**< Abs: add the absolute value of the computed to summing node */ +}; + +/** + * General controller (if #FLUID_MOD_GC in flags). This + * corresponds to SoundFont 2.04 PDF section 8.2.1 + */ +enum fluid_mod_src +{ + FLUID_MOD_NONE = 0, /**< No source controller */ + FLUID_MOD_VELOCITY = 2, /**< MIDI note-on velocity */ + FLUID_MOD_KEY = 3, /**< MIDI note-on note number */ + FLUID_MOD_KEYPRESSURE = 10, /**< MIDI key pressure */ + FLUID_MOD_CHANNELPRESSURE = 13, /**< MIDI channel pressure */ + FLUID_MOD_PITCHWHEEL = 14, /**< Pitch wheel */ + FLUID_MOD_PITCHWHEELSENS = 16 /**< Pitch wheel sensitivity */ +}; + +/** @startlifecycle{Modulator} */ +FLUIDSYNTH_API fluid_mod_t *new_fluid_mod(void); +FLUIDSYNTH_API void delete_fluid_mod(fluid_mod_t *mod); +/** @endlifecycle */ + +FLUIDSYNTH_API size_t fluid_mod_sizeof(void); + +FLUIDSYNTH_API void fluid_mod_set_source1(fluid_mod_t *mod, int src, int flags); +FLUIDSYNTH_API void fluid_mod_set_source2(fluid_mod_t *mod, int src, int flags); +FLUIDSYNTH_API void fluid_mod_set_dest(fluid_mod_t *mod, int dst); +FLUIDSYNTH_API void fluid_mod_set_amount(fluid_mod_t *mod, double amount); +FLUIDSYNTH_API void fluid_mod_set_transform(fluid_mod_t *mod, int type); + +FLUIDSYNTH_API int fluid_mod_get_source1(const fluid_mod_t *mod); +FLUIDSYNTH_API int fluid_mod_get_flags1(const fluid_mod_t *mod); +FLUIDSYNTH_API int fluid_mod_get_source2(const fluid_mod_t *mod); +FLUIDSYNTH_API int fluid_mod_get_flags2(const fluid_mod_t *mod); +FLUIDSYNTH_API int fluid_mod_get_dest(const fluid_mod_t *mod); +FLUIDSYNTH_API double fluid_mod_get_amount(const fluid_mod_t *mod); +FLUIDSYNTH_API int fluid_mod_get_transform(fluid_mod_t *mod); + +FLUIDSYNTH_API int fluid_mod_test_identity(const fluid_mod_t *mod1, const fluid_mod_t *mod2); +FLUIDSYNTH_API int fluid_mod_has_source(const fluid_mod_t *mod, int cc, int ctrl); +FLUIDSYNTH_API int fluid_mod_has_dest(const fluid_mod_t *mod, int gen); + +FLUIDSYNTH_API void fluid_mod_clone(fluid_mod_t *mod, const fluid_mod_t *src); +/** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* _FLUIDSYNTH_MOD_H */ + diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seq.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seq.h new file mode 100644 index 0000000..cdcc959 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seq.h @@ -0,0 +1,92 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_SEQ_H +#define _FLUIDSYNTH_SEQ_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup sequencer MIDI Sequencer + * + * MIDI event sequencer. + * + * The MIDI sequencer can be used to play MIDI events in a more flexible way than + * using the MIDI file player, which expects the events to be stored as + * Standard MIDI Files. Using the sequencer, you can provide the events one by + * one, with an optional timestamp for scheduling. + * + * @{ + */ + +/** + * Event callback prototype for destination clients. + * + * @param time Current sequencer tick value (see fluid_sequencer_get_tick()). + * @param event The event being received + * @param seq The sequencer instance + * @param data User defined data registered with the client + * + * @note @p time may not be of the same tick value as the scheduled event! In fact, depending on + * the sequencer's scale and the synth's sample-rate, @p time may be a few ticks too late. Although this + * itself is inaudible, it is important to consider, + * when you use this callback for enqueuing additional events over and over again with + * fluid_sequencer_send_at(): If you enqueue new events with a relative tick value you might introduce + * a timing error, which causes your sequence to sound e.g. slower than it's supposed to be. If this is + * your use-case, make sure to enqueue events with an absolute tick value. + */ +typedef void (*fluid_event_callback_t)(unsigned int time, fluid_event_t *event, + fluid_sequencer_t *seq, void *data); + + +/** @startlifecycle{MIDI Sequencer} */ +FLUID_DEPRECATED FLUIDSYNTH_API fluid_sequencer_t *new_fluid_sequencer(void); +FLUIDSYNTH_API fluid_sequencer_t *new_fluid_sequencer2(int use_system_timer); +FLUIDSYNTH_API void delete_fluid_sequencer(fluid_sequencer_t *seq); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_sequencer_get_use_system_timer(fluid_sequencer_t *seq); +FLUIDSYNTH_API +fluid_seq_id_t fluid_sequencer_register_client(fluid_sequencer_t *seq, const char *name, + fluid_event_callback_t callback, void *data); +FLUIDSYNTH_API void fluid_sequencer_unregister_client(fluid_sequencer_t *seq, fluid_seq_id_t id); +FLUIDSYNTH_API int fluid_sequencer_count_clients(fluid_sequencer_t *seq); +FLUIDSYNTH_API fluid_seq_id_t fluid_sequencer_get_client_id(fluid_sequencer_t *seq, int index); +FLUIDSYNTH_API char *fluid_sequencer_get_client_name(fluid_sequencer_t *seq, fluid_seq_id_t id); +FLUIDSYNTH_API int fluid_sequencer_client_is_dest(fluid_sequencer_t *seq, fluid_seq_id_t id); +FLUIDSYNTH_API void fluid_sequencer_process(fluid_sequencer_t *seq, unsigned int msec); +FLUIDSYNTH_API void fluid_sequencer_send_now(fluid_sequencer_t *seq, fluid_event_t *evt); +FLUIDSYNTH_API +int fluid_sequencer_send_at(fluid_sequencer_t *seq, fluid_event_t *evt, + unsigned int time, int absolute); +FLUIDSYNTH_API +void fluid_sequencer_remove_events(fluid_sequencer_t *seq, fluid_seq_id_t source, fluid_seq_id_t dest, int type); +FLUIDSYNTH_API unsigned int fluid_sequencer_get_tick(fluid_sequencer_t *seq); +FLUIDSYNTH_API void fluid_sequencer_set_time_scale(fluid_sequencer_t *seq, double scale); +FLUIDSYNTH_API double fluid_sequencer_get_time_scale(fluid_sequencer_t *seq); +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_SEQ_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seqbind.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seqbind.h new file mode 100644 index 0000000..1a50981 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/seqbind.h @@ -0,0 +1,45 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_SEQBIND_H +#define _FLUIDSYNTH_SEQBIND_H + +#include "seq.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup sequencer + * + * @{ + */ +FLUIDSYNTH_API +fluid_seq_id_t fluid_sequencer_register_fluidsynth(fluid_sequencer_t *seq, fluid_synth_t *synth); +FLUIDSYNTH_API +int fluid_sequencer_add_midi_event_to_buffer(void *data, fluid_midi_event_t *event); +/** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* _FLUIDSYNTH_SEQBIND_H */ + diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/settings.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/settings.h new file mode 100644 index 0000000..45ab07a --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/settings.h @@ -0,0 +1,197 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_SETTINGS_H +#define _FLUIDSYNTH_SETTINGS_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup settings Settings + * + * Functions for settings management + * + * To create a synthesizer object you will have to specify its + * settings. These settings are stored in a fluid_settings_t object. + * @code + * void + * my_synthesizer () + * { + * fluid_settings_t *settings; + * fluid_synth_t *synth; + * fluid_audio_driver_t *adriver; + * + * settings = new_fluid_settings (); + * fluid_settings_setstr(settings, "audio.driver", "alsa"); + * // ... change settings ... + * synth = new_fluid_synth (settings); + * adriver = new_fluid_audio_driver (settings, synth); + * // ... + * } + * @endcode + * All string settings are encoded in UTF-8. This includes the names + * of the audio and MIDI devices, exposed as setting options. + * + * @sa @ref CreatingSettings + * + * @{ + */ + +/** + * Hint FLUID_HINT_BOUNDED_BELOW indicates that the LowerBound field + * of the FLUID_PortRangeHint should be considered meaningful. The + * value in this field should be considered the (inclusive) lower + * bound of the valid range. If FLUID_HINT_SAMPLE_RATE is also + * specified then the value of LowerBound should be multiplied by the + * sample rate. + */ +#define FLUID_HINT_BOUNDED_BELOW 0x1 + +/** Hint FLUID_HINT_BOUNDED_ABOVE indicates that the UpperBound field + of the FLUID_PortRangeHint should be considered meaningful. The + value in this field should be considered the (inclusive) upper + bound of the valid range. If FLUID_HINT_SAMPLE_RATE is also + specified then the value of UpperBound should be multiplied by the + sample rate. */ +#define FLUID_HINT_BOUNDED_ABOVE 0x2 + +/** + * Hint FLUID_HINT_TOGGLED indicates that the data item should be + * considered a Boolean toggle. Data less than or equal to zero should + * be considered `off' or `false,' and data above zero should be + * considered `on' or `true.' FLUID_HINT_TOGGLED may not be used in + * conjunction with any other hint. + */ +#define FLUID_HINT_TOGGLED 0x4 + +#define FLUID_HINT_OPTIONLIST 0x02 /**< Setting is a list of string options */ + + +/** + * Settings type + * + * Each setting has a defined type: numeric (double), integer, string or a + * set of values. The type of each setting can be retrieved using the + * function fluid_settings_get_type() + */ +enum fluid_types_enum +{ + FLUID_NO_TYPE = -1, /**< Undefined type */ + FLUID_NUM_TYPE, /**< Numeric (double) */ + FLUID_INT_TYPE, /**< Integer */ + FLUID_STR_TYPE, /**< String */ + FLUID_SET_TYPE /**< Set of values */ +}; + +/** @startlifecycle{Settings} */ +FLUIDSYNTH_API fluid_settings_t *new_fluid_settings(void); +FLUIDSYNTH_API void delete_fluid_settings(fluid_settings_t *settings); +/** @endlifecycle */ + +FLUIDSYNTH_API +int fluid_settings_get_type(fluid_settings_t *settings, const char *name); + +FLUIDSYNTH_API +int fluid_settings_get_hints(fluid_settings_t *settings, const char *name, int *val); + +FLUIDSYNTH_API +int fluid_settings_is_realtime(fluid_settings_t *settings, const char *name); + +FLUIDSYNTH_API +int fluid_settings_setstr(fluid_settings_t *settings, const char *name, const char *str); + +FLUIDSYNTH_API +int fluid_settings_copystr(fluid_settings_t *settings, const char *name, char *str, int len); + +FLUIDSYNTH_API +int fluid_settings_dupstr(fluid_settings_t *settings, const char *name, char **str); + +FLUIDSYNTH_API +int fluid_settings_getstr_default(fluid_settings_t *settings, const char *name, char **def); + +FLUIDSYNTH_API +int fluid_settings_str_equal(fluid_settings_t *settings, const char *name, const char *value); + +FLUIDSYNTH_API +int fluid_settings_setnum(fluid_settings_t *settings, const char *name, double val); + +FLUIDSYNTH_API +int fluid_settings_getnum(fluid_settings_t *settings, const char *name, double *val); + +FLUIDSYNTH_API +int fluid_settings_getnum_default(fluid_settings_t *settings, const char *name, double *val); + +FLUIDSYNTH_API +int fluid_settings_getnum_range(fluid_settings_t *settings, const char *name, + double *min, double *max); + +FLUIDSYNTH_API +int fluid_settings_setint(fluid_settings_t *settings, const char *name, int val); + +FLUIDSYNTH_API +int fluid_settings_getint(fluid_settings_t *settings, const char *name, int *val); + +FLUIDSYNTH_API +int fluid_settings_getint_default(fluid_settings_t *settings, const char *name, int *val); + +FLUIDSYNTH_API +int fluid_settings_getint_range(fluid_settings_t *settings, const char *name, + int *min, int *max); + +/** + * Callback function type used with fluid_settings_foreach_option() + * + * @param data User defined data pointer + * @param name Setting name + * @param option A string option for this setting (iterates through the list) + */ +typedef void (*fluid_settings_foreach_option_t)(void *data, const char *name, const char *option); + +FLUIDSYNTH_API +void fluid_settings_foreach_option(fluid_settings_t *settings, + const char *name, void *data, + fluid_settings_foreach_option_t func); +FLUIDSYNTH_API +int fluid_settings_option_count(fluid_settings_t *settings, const char *name); +FLUIDSYNTH_API char *fluid_settings_option_concat(fluid_settings_t *settings, + const char *name, + const char *separator); + +/** + * Callback function type used with fluid_settings_foreach() + * + * @param data User defined data pointer + * @param name Setting name + * @param type Setting type (#fluid_types_enum) + */ +typedef void (*fluid_settings_foreach_t)(void *data, const char *name, int type); + +FLUIDSYNTH_API +void fluid_settings_foreach(fluid_settings_t *settings, void *data, + fluid_settings_foreach_t func); +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_SETTINGS_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/sfont.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/sfont.h new file mode 100644 index 0000000..6d0fd4c --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/sfont.h @@ -0,0 +1,362 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_SFONT_H +#define _FLUIDSYNTH_SFONT_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup soundfonts SoundFonts + * + * SoundFont related functions + * + * This part of the API contains functions, defines and types that are mostly + * only used by internal or custom SoundFont loaders or client code that + * modifies loaded presets, SoundFonts or voices directly. + */ + +/** + * @defgroup soundfont_loader SoundFont Loader + * @ingroup soundfonts + * + * Create custom SoundFont loaders + * + * It is possible to add new SoundFont loaders to the + * synthesizer. This API allows for virtual SoundFont files to be loaded + * and synthesized, which may not actually be SoundFont files, as long as they + * can be represented by the SoundFont synthesis model. + * + * To add a new SoundFont loader to the synthesizer, call + * fluid_synth_add_sfloader() and pass a pointer to an + * #fluid_sfloader_t instance created by new_fluid_sfloader(). + * On creation, you must specify a callback function \p load + * that will be called for every file attempting to load it and + * if successful returns a #fluid_sfont_t instance, or NULL if it fails. + * + * The #fluid_sfont_t structure contains a callback to obtain the + * name of the SoundFont. It contains two functions to iterate + * though the contained presets, and one function to obtain a + * preset corresponding to a bank and preset number. This + * function should return a #fluid_preset_t instance. + * + * The #fluid_preset_t instance contains some functions to obtain + * information from the preset (name, bank, number). The most + * important callback is the noteon function. The noteon function + * is called by fluidsynth internally and + * should call fluid_synth_alloc_voice() for every sample that has + * to be played. fluid_synth_alloc_voice() expects a pointer to a + * #fluid_sample_t instance and returns a pointer to the opaque + * #fluid_voice_t structure. To set or increment the values of a + * generator, use fluid_voice_gen_set() or fluid_voice_gen_incr(). When you are + * finished initializing the voice call fluid_voice_start() to + * start playing the synthesis voice. + * + * @{ + */ + +/** + * Some notification enums for presets and samples. + */ +enum +{ + FLUID_PRESET_SELECTED, /**< Preset selected notify */ + FLUID_PRESET_UNSELECTED, /**< Preset unselected notify */ + FLUID_SAMPLE_DONE, /**< Sample no longer needed notify */ + FLUID_PRESET_PIN, /**< Request to pin preset samples to cache */ + FLUID_PRESET_UNPIN /**< Request to unpin preset samples from cache */ +}; + +/** + * Indicates the type of a sample used by the _fluid_sample_t::sampletype field. + * + * This enum corresponds to the \c SFSampleLink enum in the SoundFont spec. + * One \c flag may be bit-wise OR-ed with one \c value. + */ +enum fluid_sample_type +{ + FLUID_SAMPLETYPE_MONO = 0x1, /**< Value used for mono samples */ + FLUID_SAMPLETYPE_RIGHT = 0x2, /**< Value used for right samples of a stereo pair */ + FLUID_SAMPLETYPE_LEFT = 0x4, /**< Value used for left samples of a stereo pair */ + FLUID_SAMPLETYPE_LINKED = 0x8, /**< Value used for linked sample, which is currently not supported */ + FLUID_SAMPLETYPE_OGG_VORBIS = 0x10, /**< Flag used for Ogg Vorbis compressed samples (non-standard compliant extension) as found in the program "sftools" developed by Werner Schweer from MuseScore @since 1.1.7 */ + FLUID_SAMPLETYPE_ROM = 0x8000 /**< Flag that indicates ROM samples, causing the sample to be ignored */ +}; + + +/** + * Method to load an instrument file (does not actually need to be a real file name, + * could be another type of string identifier that the \a loader understands). + * + * @param loader SoundFont loader + * @param filename File name or other string identifier + * @return The loaded instrument file (SoundFont) or NULL if an error occurred. + */ +typedef fluid_sfont_t *(*fluid_sfloader_load_t)(fluid_sfloader_t *loader, const char *filename); + +/** + * The free method should free the memory allocated for a fluid_sfloader_t instance in + * addition to any private data. + * + * @param loader SoundFont loader + * + * Any custom user provided cleanup function must ultimately call + * delete_fluid_sfloader() to ensure proper cleanup of the #fluid_sfloader_t struct. If no private data + * needs to be freed, setting this to delete_fluid_sfloader() is sufficient. + * + */ +typedef void (*fluid_sfloader_free_t)(fluid_sfloader_t *loader); + + +/** @startlifecycle{SoundFont Loader} */ +FLUIDSYNTH_API fluid_sfloader_t *new_fluid_sfloader(fluid_sfloader_load_t load, fluid_sfloader_free_t free); +FLUIDSYNTH_API void delete_fluid_sfloader(fluid_sfloader_t *loader); + +FLUIDSYNTH_API fluid_sfloader_t *new_fluid_defsfloader(fluid_settings_t *settings); +/** @endlifecycle */ + +/** + * Opens the file or memory indicated by \c filename in binary read mode. + * + * @return returns a file handle on success, NULL otherwise + * + * \c filename matches the string provided during the fluid_synth_sfload() call. + */ +typedef void *(* fluid_sfloader_callback_open_t)(const char *filename); + +/** + * Reads \c count bytes to the specified buffer \c buf. + * + * @return returns #FLUID_OK if exactly \c count bytes were successfully read, else returns #FLUID_FAILED and leaves \a buf unmodified. + */ +typedef int (* fluid_sfloader_callback_read_t)(void *buf, fluid_long_long_t count, void *handle); + +/** + * Same purpose and behaviour as fseek. + * + * @param origin either \c SEEK_SET, \c SEEK_CUR or \c SEEK_END + * @return returns #FLUID_OK if the seek was successfully performed while not seeking beyond a buffer or file, #FLUID_FAILED otherwise + */ +typedef int (* fluid_sfloader_callback_seek_t)(void *handle, fluid_long_long_t offset, int origin); + +/** + * Closes the handle returned by #fluid_sfloader_callback_open_t and frees used resources. + * + * @return returns #FLUID_OK on success, #FLUID_FAILED on error + */ +typedef int (* fluid_sfloader_callback_close_t)(void *handle); + +/** @return returns current file offset or #FLUID_FAILED on error */ +typedef fluid_long_long_t (* fluid_sfloader_callback_tell_t)(void *handle); + + +FLUIDSYNTH_API int fluid_sfloader_set_callbacks(fluid_sfloader_t *loader, + fluid_sfloader_callback_open_t open, + fluid_sfloader_callback_read_t read, + fluid_sfloader_callback_seek_t seek, + fluid_sfloader_callback_tell_t tell, + fluid_sfloader_callback_close_t close); + +FLUIDSYNTH_API int fluid_sfloader_set_data(fluid_sfloader_t *loader, void *data); +FLUIDSYNTH_API void *fluid_sfloader_get_data(fluid_sfloader_t *loader); + + + +/** + * Method to return the name of a virtual SoundFont. + * + * @param sfont Virtual SoundFont + * @return The name of the virtual SoundFont. + */ +typedef const char *(*fluid_sfont_get_name_t)(fluid_sfont_t *sfont); + +/** + * Get a virtual SoundFont preset by bank and program numbers. + * + * @param sfont Virtual SoundFont + * @param bank MIDI bank number (0-16383) + * @param prenum MIDI preset number (0-127) + * @return Should return an allocated virtual preset or NULL if it could not + * be found. + */ +typedef fluid_preset_t *(*fluid_sfont_get_preset_t)(fluid_sfont_t *sfont, int bank, int prenum); + +/** + * Start virtual SoundFont preset iteration method. + * + * @param sfont Virtual SoundFont + * + * Starts/re-starts virtual preset iteration in a SoundFont. + */ +typedef void (*fluid_sfont_iteration_start_t)(fluid_sfont_t *sfont); + +/** + * Virtual SoundFont preset iteration function. + * + * @param sfont Virtual SoundFont + * @return NULL when no more presets are available, otherwise the a pointer to the current preset + * + * Returns preset information to the caller. The returned buffer is only valid until a subsequent + * call to this function. + */ +typedef fluid_preset_t *(*fluid_sfont_iteration_next_t)(fluid_sfont_t *sfont); + +/** + * Method to free a virtual SoundFont bank. + * + * @param sfont Virtual SoundFont to free. + * @return Should return 0 when it was able to free all resources or non-zero + * if some of the samples could not be freed because they are still in use, + * in which case the free will be tried again later, until success. + * + * Any custom user provided cleanup function must ultimately call + * delete_fluid_sfont() to ensure proper cleanup of the #fluid_sfont_t struct. If no private data + * needs to be freed, setting this to delete_fluid_sfont() is sufficient. + */ +typedef int (*fluid_sfont_free_t)(fluid_sfont_t *sfont); + + +/** @startlifecycle{SoundFont} */ +FLUIDSYNTH_API fluid_sfont_t *new_fluid_sfont(fluid_sfont_get_name_t get_name, + fluid_sfont_get_preset_t get_preset, + fluid_sfont_iteration_start_t iter_start, + fluid_sfont_iteration_next_t iter_next, + fluid_sfont_free_t free); + +FLUIDSYNTH_API int delete_fluid_sfont(fluid_sfont_t *sfont); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_sfont_set_data(fluid_sfont_t *sfont, void *data); +FLUIDSYNTH_API void *fluid_sfont_get_data(fluid_sfont_t *sfont); + +FLUIDSYNTH_API int fluid_sfont_get_id(fluid_sfont_t *sfont); +FLUIDSYNTH_API const char *fluid_sfont_get_name(fluid_sfont_t *sfont); +FLUIDSYNTH_API fluid_preset_t *fluid_sfont_get_preset(fluid_sfont_t *sfont, int bank, int prenum); +FLUIDSYNTH_API void fluid_sfont_iteration_start(fluid_sfont_t *sfont); +FLUIDSYNTH_API fluid_preset_t *fluid_sfont_iteration_next(fluid_sfont_t *sfont); + +/** + * Method to get a virtual SoundFont preset name. + * + * @param preset Virtual SoundFont preset + * @return Should return the name of the preset. The returned string must be + * valid for the duration of the virtual preset (or the duration of the + * SoundFont, in the case of preset iteration). + */ +typedef const char *(*fluid_preset_get_name_t)(fluid_preset_t *preset); + +/** + * Method to get a virtual SoundFont preset MIDI bank number. + * + * @param preset Virtual SoundFont preset + * @param return The bank number of the preset + */ +typedef int (*fluid_preset_get_banknum_t)(fluid_preset_t *preset); + +/** + * Method to get a virtual SoundFont preset MIDI program number. + * + * @param preset Virtual SoundFont preset + * @param return The program number of the preset + */ +typedef int (*fluid_preset_get_num_t)(fluid_preset_t *preset); + +/** + * Method to handle a noteon event (synthesize the instrument). + * + * @param preset Virtual SoundFont preset + * @param synth Synthesizer instance + * @param chan MIDI channel number of the note on event + * @param key MIDI note number (0-127) + * @param vel MIDI velocity (0-127) + * @return #FLUID_OK on success (0) or #FLUID_FAILED (-1) otherwise + * + * This method may be called from within synthesis context and therefore + * should be as efficient as possible and not perform any operations considered + * bad for realtime audio output (memory allocations and other OS calls). + * + * Call fluid_synth_alloc_voice() for every sample that has + * to be played. fluid_synth_alloc_voice() expects a pointer to a + * #fluid_sample_t structure and returns a pointer to the opaque + * #fluid_voice_t structure. To set or increment the values of a + * generator, use fluid_voice_gen_set() or fluid_voice_gen_incr(). When you are + * finished initializing the voice call fluid_voice_start() to + * start playing the synthesis voice. Starting with FluidSynth 1.1.0 all voices + * created will be started at the same time. + */ +typedef int (*fluid_preset_noteon_t)(fluid_preset_t *preset, fluid_synth_t *synth, int chan, int key, int vel); + +/** + * Method to free a virtual SoundFont preset. + * + * @param preset Virtual SoundFont preset + * @return Should return 0 + * + * Any custom user provided cleanup function must ultimately call + * delete_fluid_preset() to ensure proper cleanup of the #fluid_preset_t struct. If no private data + * needs to be freed, setting this to delete_fluid_preset() is sufficient. + */ +typedef void (*fluid_preset_free_t)(fluid_preset_t *preset); + +/** @startlifecycle{Preset} */ +FLUIDSYNTH_API fluid_preset_t *new_fluid_preset(fluid_sfont_t *parent_sfont, + fluid_preset_get_name_t get_name, + fluid_preset_get_banknum_t get_bank, + fluid_preset_get_num_t get_num, + fluid_preset_noteon_t noteon, + fluid_preset_free_t free); +FLUIDSYNTH_API void delete_fluid_preset(fluid_preset_t *preset); +/** @endlifecycle */ + +FLUIDSYNTH_API int fluid_preset_set_data(fluid_preset_t *preset, void *data); +FLUIDSYNTH_API void *fluid_preset_get_data(fluid_preset_t *preset); + +FLUIDSYNTH_API const char *fluid_preset_get_name(fluid_preset_t *preset); +FLUIDSYNTH_API int fluid_preset_get_banknum(fluid_preset_t *preset); +FLUIDSYNTH_API int fluid_preset_get_num(fluid_preset_t *preset); +FLUIDSYNTH_API fluid_sfont_t *fluid_preset_get_sfont(fluid_preset_t *preset); + +/** @startlifecycle{Sample} */ +FLUIDSYNTH_API fluid_sample_t *new_fluid_sample(void); +FLUIDSYNTH_API void delete_fluid_sample(fluid_sample_t *sample); +/** @endlifecycle */ + +FLUIDSYNTH_API size_t fluid_sample_sizeof(void); + +FLUIDSYNTH_API int fluid_sample_set_name(fluid_sample_t *sample, const char *name); +FLUIDSYNTH_API int fluid_sample_set_sound_data(fluid_sample_t *sample, + short *data, + char *data24, + unsigned int nbframes, + unsigned int sample_rate, + short copy_data); + +FLUIDSYNTH_API int fluid_sample_set_loop(fluid_sample_t *sample, unsigned int loop_start, unsigned int loop_end); +FLUIDSYNTH_API int fluid_sample_set_pitch(fluid_sample_t *sample, int root_key, int fine_tune); + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_SFONT_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/shell.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/shell.h new file mode 100644 index 0000000..cb555c9 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/shell.h @@ -0,0 +1,150 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_SHELL_H +#define _FLUIDSYNTH_SHELL_H + + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @defgroup command_interface Command Interface + * + * Control and configuration interface + * + * The command interface allows you to send textual commands to + * the synthesizer, to parse a command file, or to read commands + * from the stdin or other input streams (like a TCP socket). + * + * For a full list of available commands, type \c help in the + * \ref command_shell or send the same command via a command handler. + * Further documentation can be found at + * https://github.com/FluidSynth/fluidsynth/wiki/UserManual#shell-commands + * + * @{ + */ +FLUIDSYNTH_API fluid_istream_t fluid_get_stdin(void); +FLUIDSYNTH_API fluid_ostream_t fluid_get_stdout(void); +FLUIDSYNTH_API char *fluid_get_userconf(char *buf, int len); +FLUIDSYNTH_API char *fluid_get_sysconf(char *buf, int len); +/** @} */ + + +/** + * @defgroup command_handler Command Handler + * @ingroup command_interface + * @brief Handles text commands and reading of configuration files + * + * @{ + */ + +/** @startlifecycle{Command Handler} */ +FLUIDSYNTH_API +fluid_cmd_handler_t *new_fluid_cmd_handler(fluid_synth_t *synth, fluid_midi_router_t *router); + +FLUIDSYNTH_API +fluid_cmd_handler_t *new_fluid_cmd_handler2(fluid_settings_t *settings, fluid_synth_t *synth, + fluid_midi_router_t *router, fluid_player_t *player); + +FLUIDSYNTH_API +void delete_fluid_cmd_handler(fluid_cmd_handler_t *handler); +/** @endlifecycle */ + +FLUIDSYNTH_API +void fluid_cmd_handler_set_synth(fluid_cmd_handler_t *handler, fluid_synth_t *synth); + +FLUIDSYNTH_API +int fluid_command(fluid_cmd_handler_t *handler, const char *cmd, fluid_ostream_t out); + +FLUIDSYNTH_API +int fluid_source(fluid_cmd_handler_t *handler, const char *filename); +/** @} */ + + +/** + * @defgroup command_shell Command Shell + * @ingroup command_interface + * + * Interactive shell to control and configure a synthesizer instance. + * + * If you need a platform independent way to get the standard input + * and output streams, use fluid_get_stdin() and fluid_get_stdout(). + * + * For a full list of available commands, type \c help in the shell. + * + * @{ + */ + +/** @startlifecycle{Command Shell} */ +FLUIDSYNTH_API +fluid_shell_t *new_fluid_shell(fluid_settings_t *settings, fluid_cmd_handler_t *handler, + fluid_istream_t in, fluid_ostream_t out, int thread); + +FLUIDSYNTH_API +void fluid_usershell(fluid_settings_t *settings, fluid_cmd_handler_t *handler); + +FLUIDSYNTH_API void delete_fluid_shell(fluid_shell_t *shell); +/** @endlifecycle */ + +/** @} */ + + +/** + * @defgroup command_server Command Server + * @ingroup command_interface + * + * TCP socket server for a command handler. + * + * The socket server will open the TCP port set by \ref settings_shell_port + * (default 9800) and starts a new thread and \ref command_handler for each + * incoming connection. + * + * @note The server is only available if libfluidsynth has been compiled + * with network support (enable-network). Without network support, all related + * functions will return FLUID_FAILED or NULL. + * + * @{ + */ + +/** @startlifecycle{Command Server} */ +FLUIDSYNTH_API +fluid_server_t *new_fluid_server(fluid_settings_t *settings, + fluid_synth_t *synth, fluid_midi_router_t *router); + +FLUIDSYNTH_API +fluid_server_t *new_fluid_server2(fluid_settings_t *settings, + fluid_synth_t *synth, fluid_midi_router_t *router, + fluid_player_t *player); + +FLUIDSYNTH_API void delete_fluid_server(fluid_server_t *server); + +FLUIDSYNTH_API int fluid_server_join(fluid_server_t *server); +/** @endlifecycle */ + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_SHELL_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/synth.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/synth.h new file mode 100644 index 0000000..59a1cb1 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/synth.h @@ -0,0 +1,559 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_SYNTH_H +#define _FLUIDSYNTH_SYNTH_H + + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @defgroup synth Synthesizer + * + * SoundFont synthesizer + * + * You create a new synthesizer with new_fluid_synth() and you destroy + * it with delete_fluid_synth(). Use the fluid_settings_t structure to specify + * the synthesizer characteristics. + * + * You have to load a SoundFont in order to hear any sound. For that + * you use the fluid_synth_sfload() function. + * + * You can use the audio driver functions to open + * the audio device and create a background audio thread. + * + * The API for sending MIDI events is probably what you expect: + * fluid_synth_noteon(), fluid_synth_noteoff(), ... + * + * @{ + */ + +/** @startlifecycle{Synthesizer} */ +FLUIDSYNTH_API fluid_synth_t *new_fluid_synth(fluid_settings_t *settings); +FLUIDSYNTH_API void delete_fluid_synth(fluid_synth_t *synth); +/** @endlifecycle */ + +FLUIDSYNTH_API double fluid_synth_get_cpu_load(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API const char *fluid_synth_error(fluid_synth_t *synth); +/** @} */ + +/** + * @defgroup midi_messages MIDI Channel Messages + * @ingroup synth + * + * The MIDI channel message functions are mostly directly named after their + * counterpart MIDI messages. They are a high-level interface to controlling + * the synthesizer, playing notes and changing note and channel parameters. + * + * @{ + */ +FLUIDSYNTH_API int fluid_synth_noteon(fluid_synth_t *synth, int chan, int key, int vel); +FLUIDSYNTH_API int fluid_synth_noteoff(fluid_synth_t *synth, int chan, int key); +FLUIDSYNTH_API int fluid_synth_cc(fluid_synth_t *synth, int chan, int ctrl, int val); +FLUIDSYNTH_API int fluid_synth_get_cc(fluid_synth_t *synth, int chan, int ctrl, int *pval); +FLUIDSYNTH_API int fluid_synth_sysex(fluid_synth_t *synth, const char *data, int len, + char *response, int *response_len, int *handled, int dryrun); +FLUIDSYNTH_API int fluid_synth_pitch_bend(fluid_synth_t *synth, int chan, int val); +FLUIDSYNTH_API int fluid_synth_get_pitch_bend(fluid_synth_t *synth, int chan, int *ppitch_bend); +FLUIDSYNTH_API int fluid_synth_pitch_wheel_sens(fluid_synth_t *synth, int chan, int val); +FLUIDSYNTH_API int fluid_synth_get_pitch_wheel_sens(fluid_synth_t *synth, int chan, int *pval); +FLUIDSYNTH_API int fluid_synth_program_change(fluid_synth_t *synth, int chan, int program); +FLUIDSYNTH_API int fluid_synth_channel_pressure(fluid_synth_t *synth, int chan, int val); +FLUIDSYNTH_API int fluid_synth_key_pressure(fluid_synth_t *synth, int chan, int key, int val); +FLUIDSYNTH_API int fluid_synth_bank_select(fluid_synth_t *synth, int chan, int bank); +FLUIDSYNTH_API int fluid_synth_sfont_select(fluid_synth_t *synth, int chan, int sfont_id); +FLUIDSYNTH_API +int fluid_synth_program_select(fluid_synth_t *synth, int chan, int sfont_id, + int bank_num, int preset_num); +FLUIDSYNTH_API int +fluid_synth_program_select_by_sfont_name(fluid_synth_t *synth, int chan, + const char *sfont_name, int bank_num, + int preset_num); +FLUIDSYNTH_API +int fluid_synth_get_program(fluid_synth_t *synth, int chan, int *sfont_id, + int *bank_num, int *preset_num); +FLUIDSYNTH_API int fluid_synth_unset_program(fluid_synth_t *synth, int chan); +FLUIDSYNTH_API int fluid_synth_program_reset(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_system_reset(fluid_synth_t *synth); + +FLUIDSYNTH_API int fluid_synth_all_notes_off(fluid_synth_t *synth, int chan); +FLUIDSYNTH_API int fluid_synth_all_sounds_off(fluid_synth_t *synth, int chan); + +FLUIDSYNTH_API int fluid_synth_set_gen(fluid_synth_t *synth, int chan, + int param, float value); +FLUIDSYNTH_API float fluid_synth_get_gen(fluid_synth_t *synth, int chan, int param); +/** @} MIDI Channel Messages */ + + +/** + * @defgroup voice_control Synthesis Voice Control + * @ingroup synth + * + * Low-level access to synthesis voices. + * + * @{ + */ +FLUIDSYNTH_API int fluid_synth_start(fluid_synth_t *synth, unsigned int id, + fluid_preset_t *preset, int audio_chan, + int midi_chan, int key, int vel); +FLUIDSYNTH_API int fluid_synth_stop(fluid_synth_t *synth, unsigned int id); + +FLUIDSYNTH_API fluid_voice_t *fluid_synth_alloc_voice(fluid_synth_t *synth, + fluid_sample_t *sample, + int channum, int key, int vel); +FLUIDSYNTH_API void fluid_synth_start_voice(fluid_synth_t *synth, fluid_voice_t *voice); +FLUIDSYNTH_API void fluid_synth_get_voicelist(fluid_synth_t *synth, + fluid_voice_t *buf[], int bufsize, int ID); +/** @} Voice Control */ + + +/** + * @defgroup soundfont_management SoundFont Management + * @ingroup synth + * + * Functions to load and unload SoundFonts. + * + * @{ + */ +FLUIDSYNTH_API +int fluid_synth_sfload(fluid_synth_t *synth, const char *filename, int reset_presets); +FLUIDSYNTH_API int fluid_synth_sfreload(fluid_synth_t *synth, int id); +FLUIDSYNTH_API int fluid_synth_sfunload(fluid_synth_t *synth, int id, int reset_presets); +FLUIDSYNTH_API int fluid_synth_add_sfont(fluid_synth_t *synth, fluid_sfont_t *sfont); +FLUIDSYNTH_API int fluid_synth_remove_sfont(fluid_synth_t *synth, fluid_sfont_t *sfont); +FLUIDSYNTH_API int fluid_synth_sfcount(fluid_synth_t *synth); +FLUIDSYNTH_API fluid_sfont_t *fluid_synth_get_sfont(fluid_synth_t *synth, unsigned int num); +FLUIDSYNTH_API fluid_sfont_t *fluid_synth_get_sfont_by_id(fluid_synth_t *synth, int id); +FLUIDSYNTH_API fluid_sfont_t *fluid_synth_get_sfont_by_name(fluid_synth_t *synth, + const char *name); +FLUIDSYNTH_API int fluid_synth_set_bank_offset(fluid_synth_t *synth, int sfont_id, int offset); +FLUIDSYNTH_API int fluid_synth_get_bank_offset(fluid_synth_t *synth, int sfont_id); +/** @} Soundfont Management */ + + +/** + * @defgroup reverb_effect Effect - Reverb + * @ingroup synth + * + * Functions for configuring the built-in reverb effect + * + * @{ + */ +FLUID_DEPRECATED FLUIDSYNTH_API void fluid_synth_set_reverb_on(fluid_synth_t *synth, int on); +FLUIDSYNTH_API int fluid_synth_reverb_on(fluid_synth_t *synth, int fx_group, int on); + +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_reverb(fluid_synth_t *synth, double roomsize, + double damping, double width, double level); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_reverb_roomsize(fluid_synth_t *synth, double roomsize); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_reverb_damp(fluid_synth_t *synth, double damping); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_reverb_width(fluid_synth_t *synth, double width); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_reverb_level(fluid_synth_t *synth, double level); + +FLUID_DEPRECATED FLUIDSYNTH_API double fluid_synth_get_reverb_roomsize(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API double fluid_synth_get_reverb_damp(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API double fluid_synth_get_reverb_level(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API double fluid_synth_get_reverb_width(fluid_synth_t *synth); + +FLUIDSYNTH_API int fluid_synth_set_reverb_group_roomsize(fluid_synth_t *synth, int fx_group, double roomsize); +FLUIDSYNTH_API int fluid_synth_set_reverb_group_damp(fluid_synth_t *synth, int fx_group, double damping); +FLUIDSYNTH_API int fluid_synth_set_reverb_group_width(fluid_synth_t *synth, int fx_group, double width); +FLUIDSYNTH_API int fluid_synth_set_reverb_group_level(fluid_synth_t *synth, int fx_group, double level); + +FLUIDSYNTH_API int fluid_synth_get_reverb_group_roomsize(fluid_synth_t *synth, int fx_group, double *roomsize); +FLUIDSYNTH_API int fluid_synth_get_reverb_group_damp(fluid_synth_t *synth, int fx_group, double *damping); +FLUIDSYNTH_API int fluid_synth_get_reverb_group_width(fluid_synth_t *synth, int fx_group, double *width); +FLUIDSYNTH_API int fluid_synth_get_reverb_group_level(fluid_synth_t *synth, int fx_group, double *level); + /** @} Reverb */ + + +/** + * @defgroup chorus_effect Effect - Chorus + * @ingroup synth + * + * Functions for configuring the built-in chorus effect + * + * @{ + */ + +/** + * Chorus modulation waveform type. + */ +enum fluid_chorus_mod +{ + FLUID_CHORUS_MOD_SINE = 0, /**< Sine wave chorus modulation */ + FLUID_CHORUS_MOD_TRIANGLE = 1 /**< Triangle wave chorus modulation */ +}; + + +FLUID_DEPRECATED FLUIDSYNTH_API void fluid_synth_set_chorus_on(fluid_synth_t *synth, int on); +FLUIDSYNTH_API int fluid_synth_chorus_on(fluid_synth_t *synth, int fx_group, int on); + +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_chorus(fluid_synth_t *synth, int nr, double level, + double speed, double depth_ms, int type); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_chorus_nr(fluid_synth_t *synth, int nr); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_chorus_level(fluid_synth_t *synth, double level); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_chorus_speed(fluid_synth_t *synth, double speed); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_chorus_depth(fluid_synth_t *synth, double depth_ms); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_set_chorus_type(fluid_synth_t *synth, int type); + +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_get_chorus_nr(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API double fluid_synth_get_chorus_level(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API double fluid_synth_get_chorus_speed(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API double fluid_synth_get_chorus_depth(fluid_synth_t *synth); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_get_chorus_type(fluid_synth_t *synth); /* see fluid_chorus_mod */ + +FLUIDSYNTH_API int fluid_synth_set_chorus_group_nr(fluid_synth_t *synth, int fx_group, int nr); +FLUIDSYNTH_API int fluid_synth_set_chorus_group_level(fluid_synth_t *synth, int fx_group, double level); +FLUIDSYNTH_API int fluid_synth_set_chorus_group_speed(fluid_synth_t *synth, int fx_group, double speed); +FLUIDSYNTH_API int fluid_synth_set_chorus_group_depth(fluid_synth_t *synth, int fx_group, double depth_ms); +FLUIDSYNTH_API int fluid_synth_set_chorus_group_type(fluid_synth_t *synth, int fx_group, int type); + +FLUIDSYNTH_API int fluid_synth_get_chorus_group_nr(fluid_synth_t *synth, int fx_group, int *nr); +FLUIDSYNTH_API int fluid_synth_get_chorus_group_level(fluid_synth_t *synth, int fx_group, double *level); +FLUIDSYNTH_API int fluid_synth_get_chorus_group_speed(fluid_synth_t *synth, int fx_group, double *speed); +FLUIDSYNTH_API int fluid_synth_get_chorus_group_depth(fluid_synth_t *synth, int fx_group, double *depth_ms); +FLUIDSYNTH_API int fluid_synth_get_chorus_group_type(fluid_synth_t *synth, int fx_group, int *type); +/** @} Chorus */ + +/** + * @defgroup synthesis_params Synthesis Parameters + * @ingroup synth + * + * Functions to control and query synthesis parameters like gain and + * polyphony count. + * + * @{ + */ +FLUIDSYNTH_API int fluid_synth_count_midi_channels(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_count_audio_channels(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_count_audio_groups(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_count_effects_channels(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_count_effects_groups(fluid_synth_t *synth); + +FLUID_DEPRECATED FLUIDSYNTH_API void fluid_synth_set_sample_rate(fluid_synth_t *synth, float sample_rate); +FLUIDSYNTH_API void fluid_synth_set_gain(fluid_synth_t *synth, float gain); +FLUIDSYNTH_API float fluid_synth_get_gain(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_set_polyphony(fluid_synth_t *synth, int polyphony); +FLUIDSYNTH_API int fluid_synth_get_polyphony(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_get_active_voice_count(fluid_synth_t *synth); +FLUIDSYNTH_API int fluid_synth_get_internal_bufsize(fluid_synth_t *synth); + +FLUIDSYNTH_API +int fluid_synth_set_interp_method(fluid_synth_t *synth, int chan, int interp_method); + +/** + * Synthesis interpolation method. + */ +enum fluid_interp +{ + FLUID_INTERP_NONE = 0, /**< No interpolation: Fastest, but questionable audio quality */ + FLUID_INTERP_LINEAR = 1, /**< Straight-line interpolation: A bit slower, reasonable audio quality */ + FLUID_INTERP_4THORDER = 4, /**< Fourth-order interpolation, best quality, the default */ + + /** + * Seventh-point sinc interpolation + * @note This interpolation method was believed to provide highest quality. However, in Feb. 2025 it was discovered + * that for certain samples it does introduce ringing artifacts, which + * are not present in the 4th order interpolation. This is not a bug, it's rather a limitation of only using 7 points for the sinc interpolation. + */ + FLUID_INTERP_7THORDER = 7, + + FLUID_INTERP_DEFAULT = FLUID_INTERP_4THORDER, /**< Default interpolation method */ + FLUID_INTERP_HIGHEST = FLUID_INTERP_7THORDER, /**< Highest interpolation method */ +}; + +/** + * Enum used with fluid_synth_add_default_mod() to specify how to handle duplicate modulators. + */ +enum fluid_synth_add_mod +{ + FLUID_SYNTH_OVERWRITE, /**< Overwrite any existing matching modulator */ + FLUID_SYNTH_ADD, /**< Sum up modulator amounts */ +}; + +FLUIDSYNTH_API int fluid_synth_add_default_mod(fluid_synth_t *synth, const fluid_mod_t *mod, int mode); +FLUIDSYNTH_API int fluid_synth_remove_default_mod(fluid_synth_t *synth, const fluid_mod_t *mod); +/** @} Synthesis Parameters */ + + +/** + * @defgroup tuning MIDI Tuning + * @ingroup synth + * + * The functions in this section implement the MIDI Tuning Standard interface. + * + * @{ + */ +FLUIDSYNTH_API +int fluid_synth_activate_key_tuning(fluid_synth_t *synth, int bank, int prog, + const char *name, const double *pitch, int apply); +FLUIDSYNTH_API +int fluid_synth_activate_octave_tuning(fluid_synth_t *synth, int bank, int prog, + const char *name, const double *pitch, int apply); +FLUIDSYNTH_API +int fluid_synth_tune_notes(fluid_synth_t *synth, int bank, int prog, + int len, const int *keys, const double *pitch, int apply); +FLUIDSYNTH_API +int fluid_synth_activate_tuning(fluid_synth_t *synth, int chan, int bank, int prog, + int apply); +FLUIDSYNTH_API +int fluid_synth_deactivate_tuning(fluid_synth_t *synth, int chan, int apply); +FLUIDSYNTH_API void fluid_synth_tuning_iteration_start(fluid_synth_t *synth); +FLUIDSYNTH_API +int fluid_synth_tuning_iteration_next(fluid_synth_t *synth, int *bank, int *prog); +FLUIDSYNTH_API int fluid_synth_tuning_dump(fluid_synth_t *synth, int bank, int prog, + char *name, int len, double *pitch); +/** @} MIDI Tuning */ + + +/** + * @defgroup audio_rendering Audio Rendering + * @ingroup synth + * + * The functions in this section can be used to render audio directly to + * memory buffers. They are used internally by the \ref audio_driver and \ref file_renderer, + * but can also be used manually for custom processing of the rendered audio. + * + * @note Please note that all following functions block during rendering. If your goal is to + * render real-time audio, ensure that you call these functions from a high-priority + * thread with little to no other duties other than calling the rendering functions. + * + * @warning + * If a concurrently running thread calls any other sound affecting synth function + * (e.g. fluid_synth_noteon(), fluid_synth_cc(), etc.) it is unspecified whether the event triggered by such a call + * will be effective in the recently synthesized audio. While this is inaudible when only requesting small chunks from the + * synth with every call (cf. fluid_synth_get_internal_bufsize()), it will become evident when requesting larger sample chunks: + * With larger sample chunks it will get harder for the synth to react on those spontaneously occurring events in time + * (like events received from a MIDI driver, or directly made synth API calls). + * In those real-time scenarios, prefer requesting smaller + * sample chunks from the synth with each call, to avoid poor quantization of your events in the synthesized audio. + * This issue is not applicable when using the MIDI player or sequencer for event dispatching. Also + * refer to the documentation of \setting{audio_period-size}. + * + * @{ + */ +FLUIDSYNTH_API int fluid_synth_write_s16(fluid_synth_t *synth, int len, + void *lout, int loff, int lincr, + void *rout, int roff, int rincr); +FLUIDSYNTH_API int fluid_synth_write_float(fluid_synth_t *synth, int len, + void *lout, int loff, int lincr, + void *rout, int roff, int rincr); +FLUID_DEPRECATED FLUIDSYNTH_API int fluid_synth_nwrite_float(fluid_synth_t *synth, int len, + float **left, float **right, + float **fx_left, float **fx_right); +FLUIDSYNTH_API int fluid_synth_process(fluid_synth_t *synth, int len, + int nfx, float *fx[], + int nout, float *out[]); +/** @} Audio Rendering */ + + +/** + * @defgroup iir_filter Effect - IIR Filter + * @ingroup synth + * + * Functions for configuring the built-in IIR filter effect + * + * @{ + */ + +/** + * Specifies the type of filter to use for the custom IIR filter + */ +enum fluid_iir_filter_type +{ + FLUID_IIR_DISABLED = 0, /**< Custom IIR filter is not operating */ + FLUID_IIR_LOWPASS, /**< Custom IIR filter is operating as low-pass filter */ + FLUID_IIR_HIGHPASS, /**< Custom IIR filter is operating as high-pass filter */ + FLUID_IIR_LAST /**< @internal Value defines the count of filter types (#fluid_iir_filter_type) @warning This symbol is not part of the public API and ABI stability guarantee and may change at any time! */ +}; + +/** + * Specifies optional settings to use for the custom IIR filter. Can be bitwise ORed. + */ +enum fluid_iir_filter_flags +{ + FLUID_IIR_Q_LINEAR = 1 << 0, /**< The Soundfont spec requires the filter Q to be interpreted in dB. If this flag is set the filter Q is instead assumed to be in a linear range */ + FLUID_IIR_Q_ZERO_OFF = 1 << 1, /**< If this flag the filter is switched off if Q == 0 (prior to any transformation) */ + FLUID_IIR_NO_GAIN_AMP = 1 << 2 /**< The Soundfont spec requires to correct the gain of the filter depending on the filter's Q. If this flag is set the filter gain will not be corrected. */ +}; + +FLUIDSYNTH_API int fluid_synth_set_custom_filter(fluid_synth_t *, int type, int flags); +/** @} IIR Filter */ + + + + +/** + * @defgroup channel_setup MIDI Channel Setup + * @ingroup synth + * + * The functions in this section provide interfaces to change the channel type + * and to configure basic channels, legato and portamento setups. + * + * @{ + */ + +/** @name Channel Type + * @{ + */ + +/** + * The midi channel type used by fluid_synth_set_channel_type() + */ +enum fluid_midi_channel_type +{ + CHANNEL_TYPE_MELODIC = 0, /**< Melodic midi channel */ + CHANNEL_TYPE_DRUM = 1 /**< Drum midi channel */ +}; + +FLUIDSYNTH_API int fluid_synth_set_channel_type(fluid_synth_t *synth, int chan, int type); +/** @} Channel Type */ + + +/** @name Basic Channel Mode + * @{ + */ + +/** + * Channel mode bits OR-ed together so that it matches with the midi spec: poly omnion (0), mono omnion (1), poly omnioff (2), mono omnioff (3) + */ +enum fluid_channel_mode_flags +{ + FLUID_CHANNEL_POLY_OFF = 0x01, /**< if flag is set, the basic channel is in mono on state, if not set poly is on */ + FLUID_CHANNEL_OMNI_OFF = 0x02, /**< if flag is set, the basic channel is in omni off state, if not set omni is on */ +}; + +/** + * Indicates the mode a basic channel is set to + */ +enum fluid_basic_channel_modes +{ + FLUID_CHANNEL_MODE_MASK = (FLUID_CHANNEL_OMNI_OFF | FLUID_CHANNEL_POLY_OFF), /**< Mask Poly and Omni bits of #fluid_channel_mode_flags, usually only used internally */ + FLUID_CHANNEL_MODE_OMNION_POLY = FLUID_CHANNEL_MODE_MASK & (~FLUID_CHANNEL_OMNI_OFF & ~FLUID_CHANNEL_POLY_OFF), /**< corresponds to MIDI mode 0 */ + FLUID_CHANNEL_MODE_OMNION_MONO = FLUID_CHANNEL_MODE_MASK & (~FLUID_CHANNEL_OMNI_OFF & FLUID_CHANNEL_POLY_OFF), /**< corresponds to MIDI mode 1 */ + FLUID_CHANNEL_MODE_OMNIOFF_POLY = FLUID_CHANNEL_MODE_MASK & (FLUID_CHANNEL_OMNI_OFF & ~FLUID_CHANNEL_POLY_OFF), /**< corresponds to MIDI mode 2 */ + FLUID_CHANNEL_MODE_OMNIOFF_MONO = FLUID_CHANNEL_MODE_MASK & (FLUID_CHANNEL_OMNI_OFF | FLUID_CHANNEL_POLY_OFF), /**< corresponds to MIDI mode 3 */ + FLUID_CHANNEL_MODE_LAST /**< @internal Value defines the count of basic channel modes (#fluid_basic_channel_modes) @warning This symbol is not part of the public API and ABI stability guarantee and may change at any time! */ +}; + +FLUIDSYNTH_API int fluid_synth_reset_basic_channel(fluid_synth_t *synth, int chan); + +FLUIDSYNTH_API int fluid_synth_get_basic_channel(fluid_synth_t *synth, int chan, + int *basic_chan_out, + int *mode_chan_out, + int *basic_val_out); +FLUIDSYNTH_API int fluid_synth_set_basic_channel(fluid_synth_t *synth, int chan, int mode, int val); + +/** @} Basic Channel Mode */ + +/** @name Legato Mode + * @{ + */ + +/** + * Indicates the legato mode a channel is set to + * n1,n2,n3,.. is a legato passage. n1 is the first note, and n2,n3,n4 are played legato with previous note. */ +enum fluid_channel_legato_mode +{ + FLUID_CHANNEL_LEGATO_MODE_RETRIGGER, /**< Mode 0 - Release previous note, start a new note */ + FLUID_CHANNEL_LEGATO_MODE_MULTI_RETRIGGER, /**< Mode 1 - On contiguous notes retrigger in attack section using current value, shape attack using current dynamic and make use of previous voices if any */ + FLUID_CHANNEL_LEGATO_MODE_LAST /**< @internal Value defines the count of legato modes (#fluid_channel_legato_mode) @warning This symbol is not part of the public API and ABI stability guarantee and may change at any time! */ +}; + +FLUIDSYNTH_API int fluid_synth_set_legato_mode(fluid_synth_t *synth, int chan, int legatomode); +FLUIDSYNTH_API int fluid_synth_get_legato_mode(fluid_synth_t *synth, int chan, int *legatomode); +/** @} Legato Mode */ + +/** @name Portamento Mode + * @{ + */ + +/** + * Indicates the portamento mode a channel is set to + */ +enum fluid_channel_portamento_mode +{ + FLUID_CHANNEL_PORTAMENTO_MODE_EACH_NOTE, /**< Mode 0 - Portamento on each note (staccato or legato) */ + FLUID_CHANNEL_PORTAMENTO_MODE_LEGATO_ONLY, /**< Mode 1 - Portamento only on legato note */ + FLUID_CHANNEL_PORTAMENTO_MODE_STACCATO_ONLY, /**< Mode 2 - Portamento only on staccato note */ + FLUID_CHANNEL_PORTAMENTO_MODE_LAST /**< @internal Value defines the count of portamento modes + @warning This symbol is not part of the public API and ABI + stability guarantee and may change at any time! */ +}; + +FLUIDSYNTH_API int fluid_synth_set_portamento_mode(fluid_synth_t *synth, + int chan, int portamentomode); +FLUIDSYNTH_API int fluid_synth_get_portamento_mode(fluid_synth_t *synth, + int chan, int *portamentomode); +/** @} Portamento Mode */ + +/**@name Breath Mode + * @{ + */ + +/** + * Indicates the breath mode a channel is set to + */ +enum fluid_channel_breath_flags +{ + FLUID_CHANNEL_BREATH_POLY = 0x10, /**< when channel is poly, this flag indicates that the default velocity to initial attenuation modulator is replaced by a breath to initial attenuation modulator */ + FLUID_CHANNEL_BREATH_MONO = 0x20, /**< when channel is mono, this flag indicates that the default velocity to initial attenuation modulator is replaced by a breath modulator */ + FLUID_CHANNEL_BREATH_SYNC = 0x40, /**< when channel is mono, this flag indicates that the breath controller(MSB)triggers noteon/noteoff on the running note */ +}; + +FLUIDSYNTH_API int fluid_synth_set_breath_mode(fluid_synth_t *synth, + int chan, int breathmode); +FLUIDSYNTH_API int fluid_synth_get_breath_mode(fluid_synth_t *synth, + int chan, int *breathmode); +/** @} Breath Mode */ +/** @} MIDI Channel Setup */ + + +/** @ingroup settings */ +FLUIDSYNTH_API fluid_settings_t *fluid_synth_get_settings(fluid_synth_t *synth); + +/** @ingroup soundfont_loader */ +FLUIDSYNTH_API void fluid_synth_add_sfloader(fluid_synth_t *synth, fluid_sfloader_t *loader); + +/** @ingroup soundfont_loader */ +FLUIDSYNTH_API fluid_preset_t *fluid_synth_get_channel_preset(fluid_synth_t *synth, int chan); + +/** @ingroup midi_input */ +FLUIDSYNTH_API int fluid_synth_handle_midi_event(void *data, fluid_midi_event_t *event); + +/** @ingroup soundfonts */ +FLUIDSYNTH_API +int fluid_synth_pin_preset(fluid_synth_t *synth, int sfont_id, int bank_num, int preset_num); + +/** @ingroup soundfonts */ +FLUIDSYNTH_API +int fluid_synth_unpin_preset(fluid_synth_t *synth, int sfont_id, int bank_num, int preset_num); + +/** @ingroup ladspa */ +FLUIDSYNTH_API fluid_ladspa_fx_t *fluid_synth_get_ladspa_fx(fluid_synth_t *synth); + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_SYNTH_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/types.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/types.h new file mode 100644 index 0000000..09a8509 --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/types.h @@ -0,0 +1,83 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_TYPES_H +#define _FLUIDSYNTH_TYPES_H + + + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @defgroup Types Types + * @brief Type declarations + * + * @{ + */ + +typedef struct _fluid_hashtable_t fluid_settings_t; /**< Configuration settings instance */ +typedef struct _fluid_synth_t fluid_synth_t; /**< Synthesizer instance */ +typedef struct _fluid_voice_t fluid_voice_t; /**< Synthesis voice instance */ +typedef struct _fluid_sfloader_t fluid_sfloader_t; /**< SoundFont loader plugin */ +typedef struct _fluid_sfont_t fluid_sfont_t; /**< SoundFont */ +typedef struct _fluid_preset_t fluid_preset_t; /**< SoundFont preset */ +typedef struct _fluid_sample_t fluid_sample_t; /**< SoundFont sample */ +typedef struct _fluid_mod_t fluid_mod_t; /**< SoundFont modulator */ +typedef struct _fluid_audio_driver_t fluid_audio_driver_t; /**< Audio driver instance */ +typedef struct _fluid_file_renderer_t fluid_file_renderer_t; /**< Audio file renderer instance */ +typedef struct _fluid_player_t fluid_player_t; /**< MIDI player instance */ +typedef struct _fluid_midi_event_t fluid_midi_event_t; /**< MIDI event */ +typedef struct _fluid_midi_driver_t fluid_midi_driver_t; /**< MIDI driver instance */ +typedef struct _fluid_midi_router_t fluid_midi_router_t; /**< MIDI router instance */ +typedef struct _fluid_midi_router_rule_t fluid_midi_router_rule_t; /**< MIDI router rule */ +typedef struct _fluid_hashtable_t fluid_cmd_hash_t; /**< Command handler hash table */ +typedef struct _fluid_shell_t fluid_shell_t; /**< Command shell */ +typedef struct _fluid_server_t fluid_server_t; /**< TCP/IP shell server instance */ +typedef struct _fluid_event_t fluid_event_t; /**< Sequencer event */ +typedef struct _fluid_sequencer_t fluid_sequencer_t; /**< Sequencer instance */ +typedef struct _fluid_cmd_handler_t fluid_cmd_handler_t; /**< Shell Command Handler */ +typedef struct _fluid_ladspa_fx_t fluid_ladspa_fx_t; /**< LADSPA effects instance */ +typedef struct _fluid_file_callbacks_t fluid_file_callbacks_t; /**< Callback struct to perform custom file loading of soundfonts */ + +typedef int fluid_istream_t; /**< Input stream descriptor */ +typedef int fluid_ostream_t; /**< Output stream descriptor */ + +typedef short fluid_seq_id_t; /**< Unique client IDs used by the sequencer and #fluid_event_t, obtained by fluid_sequencer_register_client() and fluid_sequencer_register_fluidsynth() */ + +#if defined(_MSC_VER) && (_MSC_VER < 1800) +typedef __int64 fluid_long_long_t; // even on 32bit windows +#else +/** + * A typedef for C99's type long long, which is at least 64-bit wide, as guaranteed by the C99. + * @p __int64 will be used as replacement for VisualStudio 2010 and older. + */ +typedef long long fluid_long_long_t; +#endif + +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_TYPES_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/version.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/version.h new file mode 100644 index 0000000..39ba5cf --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/version.h @@ -0,0 +1,47 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_VERSION_H +#define _FLUIDSYNTH_VERSION_H + + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @addtogroup misc + * + * @{ + */ +#define FLUIDSYNTH_VERSION "2.4.5" /**< String constant of libfluidsynth version. */ +#define FLUIDSYNTH_VERSION_MAJOR 2 /**< libfluidsynth major version integer constant. */ +#define FLUIDSYNTH_VERSION_MINOR 4 /**< libfluidsynth minor version integer constant. */ +#define FLUIDSYNTH_VERSION_MICRO 5 /**< libfluidsynth micro version integer constant. */ + +FLUIDSYNTH_API void fluid_version(int *major, int *minor, int *micro); +FLUIDSYNTH_API char* fluid_version_str(void); +/** @} */ + +#ifdef __cplusplus +} +#endif + +#endif /* _FLUIDSYNTH_VERSION_H */ diff --git a/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/voice.h b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/voice.h new file mode 100644 index 0000000..1d31cba --- /dev/null +++ b/app/src/main/cpp/midihandler/fluidsynth/include/fluidsynth/voice.h @@ -0,0 +1,77 @@ +/* FluidSynth - A Software Synthesizer + * + * Copyright (C) 2003 Peter Hanappe and others. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public License + * as published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free + * Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA + */ + +#ifndef _FLUIDSYNTH_VOICE_H +#define _FLUIDSYNTH_VOICE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup voices Voice Manipulation + * @ingroup soundfonts + * + * Synthesis voice manipulation functions. + * + * The interface to the synthesizer's voices. + * Examples on using them can be found in the source code of the default SoundFont + * loader (fluid_defsfont.c). + * + * Most of these functions should only be called from within synthesis context, + * such as the SoundFont loader's noteon method. + * + * @{ + */ + +/** + * Enum used with fluid_voice_add_mod() to specify how to handle duplicate modulators. + */ +enum fluid_voice_add_mod +{ + FLUID_VOICE_OVERWRITE, /**< Overwrite any existing matching modulator */ + FLUID_VOICE_ADD, /**< Add (sum) modulator amounts */ + FLUID_VOICE_DEFAULT /**< For default modulators only, no need to check for duplicates */ +}; + +FLUIDSYNTH_API void fluid_voice_add_mod(fluid_voice_t *voice, fluid_mod_t *mod, int mode); +FLUIDSYNTH_API float fluid_voice_gen_get(fluid_voice_t *voice, int gen); +FLUIDSYNTH_API void fluid_voice_gen_set(fluid_voice_t *voice, int gen, float val); +FLUIDSYNTH_API void fluid_voice_gen_incr(fluid_voice_t *voice, int gen, float val); + +FLUIDSYNTH_API unsigned int fluid_voice_get_id(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_get_channel(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_get_key(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_get_actual_key(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_get_velocity(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_get_actual_velocity(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_is_playing(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_is_on(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_is_sustained(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_is_sostenuto(const fluid_voice_t *voice); +FLUIDSYNTH_API int fluid_voice_optimize_sample(fluid_sample_t *s); +FLUIDSYNTH_API void fluid_voice_update_param(fluid_voice_t *voice, int gen); +/** @} */ + +#ifdef __cplusplus +} +#endif +#endif /* _FLUIDSYNTH_VOICE_H */ + diff --git a/app/src/main/jniLibs/arm64-v8a/libFLAC.so b/app/src/main/jniLibs/arm64-v8a/libFLAC.so new file mode 100644 index 0000000000000000000000000000000000000000..132ea907967240a3033d91cf6e674c19d2a25a08 GIT binary patch literal 238784 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