commit c13016275b98f517fbb5f08d4d407df26f259fc9 Author: versustunez Date: Sat Feb 20 18:13:51 2021 +0100 Initial Commit diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..122520b --- /dev/null +++ b/.gitignore @@ -0,0 +1,5 @@ +/build/ +/helper/ +/cmake-build-debug/ +.idea/ +*.iml \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..00c1f2e --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,42 @@ +cmake_minimum_required(VERSION 3.17) +project(VulcanoLE) +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG") +list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake") + +find_package(udev REQUIRED) +find_package(HIDAPI REQUIRED) +pkg_check_modules(LIBUSB REQUIRED libusb-1.0) +find_package(Threads REQUIRED) +find_library(PULSE_FOUND NAMES pulse) +if (PULSE_FOUND) + set(DYNAMIC_LIBRARIES ${DYNAMIC_LIBRARIES} pulse pulse-simple) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ENABLE_PULSE") + set(CMAKE_LD_FLAGS "${CMAKE_LD_FLAGS} -D_ENABLE_PULSE") +endif () + +set(SOURCE_FILES + src/VulcanoLE/API/HIDHelper.cpp + src/VulcanoLE/Keyboards/Vulcan121.cpp + src/VulcanoLE/Audio/AudioGrabber.cpp + src/VulcanoLE/Audio/FFT.cpp + src/VulcanoLE/Audio/VisAudioRunner.cpp + src/VulcanoLE/Visual/VisPlugins.cpp + src/VulcanoLE/Scripts/Loudness.cpp + src/VulcanoLE/Scripts/Spectrum.cpp + src/VulcanoLE/Scripts/WeirdSpec.cpp + ) +set(UTILS_FILES + src/VUtils/Logging.cpp + src/VUtils/FileHandler.cpp + src/VUtils/Pool.cpp + src/VUtils/Environment.cpp + src/VUtils/StringUtils.cpp + ) +include_directories(${CMAKE_SOURCE_DIR}/headers/) +add_executable( + VulcanoLE main.cpp + ${SOURCE_FILES} ${UTILS_FILES} +) +target_link_libraries(VulcanoLE fftw3 evdev hidapi-libusb udev ${CMAKE_DL_LIBS} ${DYNAMIC_LIBRARIES} Threads::Threads m + debug tbb) diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..e72bfdd --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If 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 convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..b120d99 --- /dev/null +++ b/README.md @@ -0,0 +1,55 @@ +# VULCANO LE + +Audio Visual Control for Vulcan121 Keyboard + +## DEPS: +``` +libpulse -> pipewire-pulse or pulseaudio +cmake +udev +hidapi +``` +### INSTALL +One of Booth should be installed :) a lot of systems are using pulseaudio already +#### ARCH +``` +pacman -S pipewire pipewire-pulse +OR +pacman -S pulseaudio +``` +## BUILD +``` +mkdir build +cd build +// FOR DEBUG +cmake -DCMAKE_BUILD_TYPE=Debug .. +// FOR RELEASE +make -DCMAKE_BUILD_TYPE=Release .. +``` + +## RUN +`./anyVulcanoLE` + +## CONFIG +The System should create a `state.env` file after first exit + +Location: ~/.config/VulcanoLE/state.env + +### EXAMPLE +``` +audio_scale=2.0 +visual_mode=1 +shutdown_color_red=235 +shutdown_color_green=0 +shutdown_color_blue=141 +shutdown_brightness=50 +``` + +# TODO + +- Support for custom Scripts without writing C++ +- VWeb Interface to control Configs without restarting +- Less CPU Usage +- Keyboard Mapping +- Macro Support +- Execute of Script on Hotkeys \ No newline at end of file diff --git a/cmake/FindHIDAPI.cmake b/cmake/FindHIDAPI.cmake new file mode 100644 index 0000000..c695e1b --- /dev/null +++ b/cmake/FindHIDAPI.cmake @@ -0,0 +1,228 @@ +#.rst: +# FindHIDAPI +# ---------- +# +# Try to find HIDAPI library, from http://www.signal11.us/oss/hidapi/ +# +# Cache Variables: (probably not for direct use in your Scripts) +# HIDAPI_INCLUDE_DIR +# HIDAPI_LIBRARY +# +# Non-cache variables you might use in your CMakeLists.txt: +# HIDAPI_FOUND +# HIDAPI_INCLUDE_DIRS +# HIDAPI_LIBRARIES +# +# COMPONENTS +# ^^^^^^^^^^ +# +# This module respects several COMPONENTS specifying the backend you prefer: +# ``any`` (the default), ``libusb``, and ``hidraw``. +# The availablility of the latter two depends on your platform. +# +# +# IMPORTED Targets +# ^^^^^^^^^^^^^^^^ + +# This module defines :prop_tgt:`IMPORTED` target ``HIDAPI::hidapi`` (in all cases or +# if no components specified), ``HIDAPI::hidapi-libusb`` (if you requested the libusb component), +# and ``HIDAPI::hidapi-hidraw`` (if you requested the hidraw component), +# +# Result Variables +# ^^^^^^^^^^^^^^^^ +# +# ``HIDAPI_FOUND`` +# True if HIDAPI or the requested components (if any) were found. +# +# We recommend using the imported targets instead of the following. +# +# ``HIDAPI_INCLUDE_DIRS`` +# ``HIDAPI_LIBRARIES`` +# +# Original Author: +# 2009-2010, 2019 Ryan Pavlik +# http://academic.cleardefinition.com +# +# Copyright Iowa State University 2009-2010. +# Copyright Collabora, Ltd. 2019. +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +set(HIDAPI_ROOT_DIR "${HIDAPI_ROOT_DIR}" CACHE PATH "Root to search for HIDAPI") + +# Clean up components +if("${HIDAPI_FIND_COMPONENTS}") + if(WIN32 OR APPLE) + # This makes no sense on Windows or Mac, which have native APIs + list(REMOVE "${HIDAPI_FIND_COMPONENTS}" libusb) + endif() + + if(NOT ${CMAKE_SYSTEM} MATCHES "Linux") + # hidraw is only on linux + list(REMOVE "${HIDAPI_FIND_COMPONENTS}" hidraw) + endif() +endif() +if(NOT "${HIDAPI_FIND_COMPONENTS}") + # Default to any + set("${HIDAPI_FIND_COMPONENTS}" any) +endif() + +# Ask pkg-config for hints +find_package(PkgConfig QUIET) +if(PKG_CONFIG_FOUND) + set(_old_prefix_path "${CMAKE_PREFIX_PATH}") + # So pkg-config uses HIDAPI_ROOT_DIR too. + if(HIDAPI_ROOT_DIR) + list(APPEND CMAKE_PREFIX_PATH ${HIDAPI_ROOT_DIR}) + endif() + pkg_check_modules(PC_HIDAPI_LIBUSB QUIET hidapi-libusb) + pkg_check_modules(PC_HIDAPI_HIDRAW QUIET hidapi-hidraw) + # Restore + set(CMAKE_PREFIX_PATH "${_old_prefix_path}") +endif() + +# Actually search +find_library(HIDAPI_UNDECORATED_LIBRARY + NAMES hidapi + PATHS + "${HIDAPI_ROOT_DIR}" + PATH_SUFFIXES + lib) + +find_library(HIDAPI_LIBUSB_LIBRARY + NAMES hidapi hidapi-libusb + PATHS + "${HIDAPI_ROOT_DIR}" + PATH_SUFFIXES + lib + HINTS + ${PC_HIDAPI_LIBUSB_LIBRARY_DIRS}) + +if(CMAKE_SYSTEM MATCHES "Linux") + find_library(HIDAPI_HIDRAW_LIBRARY + NAMES hidapi-hidraw + HINTS + ${PC_HIDAPI_HIDRAW_LIBRARY_DIRS}) +endif() + +find_path(HIDAPI_INCLUDE_DIR + NAMES hidapi.h + PATHS + "${HIDAPI_ROOT_DIR}" + PATH_SUFFIXES + hidapi + include + include/hidapi + HINTS + ${PC_HIDAPI_HIDRAW_INCLUDE_DIRS} + ${PC_HIDAPI_LIBUSB_INCLUDE_DIRS}) + +find_package(Threads QUIET) + +### +# Compute the "I don't care which backend" library +### +set(HIDAPI_LIBRARY) + +# First, try to use a preferred backend if supplied +if("${HIDAPI_FIND_COMPONENTS}" MATCHES "libusb" AND HIDAPI_LIBUSB_LIBRARY AND NOT HIDAPI_LIBRARY) + set(HIDAPI_LIBRARY ${HIDAPI_LIBUSB_LIBRARY}) +endif() +if("${HIDAPI_FIND_COMPONENTS}" MATCHES "hidraw" AND HIDAPI_HIDRAW_LIBRARY AND NOT HIDAPI_LIBRARY) + set(HIDAPI_LIBRARY ${HIDAPI_HIDRAW_LIBRARY}) +endif() + +# Then, if we don't have a preferred one, settle for anything. +if(NOT HIDAPI_LIBRARY) + if(HIDAPI_LIBUSB_LIBRARY) + set(HIDAPI_LIBRARY ${HIDAPI_LIBUSB_LIBRARY}) + elseif(HIDAPI_HIDRAW_LIBRARY) + set(HIDAPI_LIBRARY ${HIDAPI_HIDRAW_LIBRARY}) + elseif(HIDAPI_UNDECORATED_LIBRARY) + set(HIDAPI_LIBRARY ${HIDAPI_UNDECORATED_LIBRARY}) + endif() +endif() + +### +# Determine if the various requested components are found. +### +set(_hidapi_component_required_vars) + +foreach(_comp IN LISTS HIDAPI_FIND_COMPONENTS) + if("${_comp}" STREQUAL "any") + list(APPEND _hidapi_component_required_vars + HIDAPI_INCLUDE_DIR + HIDAPI_LIBRARY) + if(HIDAPI_INCLUDE_DIR AND EXISTS "${HIDAPI_LIBRARY}") + set(HIDAPI_any_FOUND TRUE) + mark_as_advanced(HIDAPI_INCLUDE_DIR) + else() + set(HIDAPI_any_FOUND FALSE) + endif() + + elseif("${_comp}" STREQUAL "libusb") + list(APPEND _hidapi_component_required_vars HIDAPI_INCLUDE_DIR HIDAPI_LIBUSB_LIBRARY) + if(HIDAPI_INCLUDE_DIR AND EXISTS "${HIDAPI_LIBUSB_LIBRARY}") + set(HIDAPI_libusb_FOUND TRUE) + mark_as_advanced(HIDAPI_INCLUDE_DIR HIDAPI_LIBUSB_LIBRARY) + else() + set(HIDAPI_libusb_FOUND FALSE) + endif() + + elseif("${_comp}" STREQUAL "hidraw") + list(APPEND _hidapi_component_required_vars HIDAPI_INCLUDE_DIR HIDAPI_HIDRAW_LIBRARY) + if(HIDAPI_INCLUDE_DIR AND EXISTS "${HIDAPI_HIDRAW_LIBRARY}") + set(HIDAPI_hidraw_FOUND TRUE) + mark_as_advanced(HIDAPI_INCLUDE_DIR HIDAPI_HIDRAW_LIBRARY) + else() + set(HIDAPI_hidraw_FOUND FALSE) + endif() + + else() + message(WARNING "${_comp} is not a recognized HIDAPI component") + set(HIDAPI_${_comp}_FOUND FALSE) + endif() +endforeach() +unset(_comp) + +### +# FPHSA call +### +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(HIDAPI + REQUIRED_VARS + ${_hidapi_component_required_vars} + THREADS_FOUND + HANDLE_COMPONENTS) + +if(HIDAPI_FOUND) + set(HIDAPI_LIBRARIES "${HIDAPI_LIBRARY}") + set(HIDAPI_INCLUDE_DIRS "${HIDAPI_INCLUDE_DIR}") + if(NOT TARGET HIDAPI::hidapi) + add_library(HIDAPI::hidapi UNKNOWN IMPORTED) + set_target_properties(HIDAPI::hidapi PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${HIDAPI_LIBRARY}) + set_property(TARGET HIDAPI::hidapi PROPERTY + IMPORTED_LINK_INTERFACE_LIBRARIES Threads::Threads) + endif() +endif() + +if(HIDAPI_libusb_FOUND AND NOT TARGET HIDAPI::hidapi-libusb) + add_library(HIDAPI::hidapi-libusb UNKNOWN IMPORTED) + set_target_properties(HIDAPI::hidapi-libusb PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${HIDAPI_LIBUSB_LIBRARY}) + set_property(TARGET HIDAPI::hidapi-libusb PROPERTY + IMPORTED_LINK_INTERFACE_LIBRARIES Threads::Threads) +endif() + +if(HIDAPI_hidraw_FOUND AND NOT TARGET HIDAPI::hidapi-hidraw) + add_library(HIDAPI::hidapi-hidraw UNKNOWN IMPORTED) + set_target_properties(HIDAPI::hidapi-hidraw PROPERTIES + IMPORTED_LINK_INTERFACE_LANGUAGES "C" + IMPORTED_LOCATION ${HIDAPI_HIDRAW_LIBRARY}) + set_property(TARGET HIDAPI::hidapi-hidraw PROPERTY + IMPORTED_LINK_INTERFACE_LIBRARIES Threads::Threads) +endif() \ No newline at end of file diff --git a/cmake/Findudev.cmake b/cmake/Findudev.cmake new file mode 100644 index 0000000..7e4a772 --- /dev/null +++ b/cmake/Findudev.cmake @@ -0,0 +1,76 @@ +# - try to find the udev library +# +# Cache Variables: (probably not for direct use in your Scripts) +# UDEV_INCLUDE_DIR +# UDEV_SOURCE_DIR +# UDEV_LIBRARY +# +# Non-cache variables you might use in your CMakeLists.txt: +# UDEV_FOUND +# UDEV_INCLUDE_DIRS +# UDEV_LIBRARIES +# +# Requires these CMake modules: +# FindPackageHandleStandardArgs (known included with CMake >=2.6.2) +# +# Original Author: +# 2014 Kevin M. Godby +# +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or copy at +# http://www.boost.org/LICENSE_1_0.txt) + +set(UDEV_ROOT_DIR + "${UDEV_ROOT_DIR}" + CACHE + PATH + "Directory to search for udev") + +find_package(PkgConfig QUIET) +if(PKG_CONFIG_FOUND) + pkg_check_modules(PC_LIBUDEV libudev) +endif() + +find_library(UDEV_LIBRARY + NAMES + udev + PATHS + ${PC_LIBUDEV_LIBRARY_DIRS} + ${PC_LIBUDEV_LIBDIR} + HINTS + "${UDEV_ROOT_DIR}" + PATH_SUFFIXES + lib + ) + +get_filename_component(_libdir "${UDEV_LIBRARY}" PATH) + +find_path(UDEV_INCLUDE_DIR + NAMES + libudev.h + PATHS + ${PC_LIBUDEV_INCLUDE_DIRS} + ${PC_LIBUDEV_INCLUDEDIR} + HINTS + "${_libdir}" + "${_libdir}/.." + "${UDEV_ROOT_DIR}" + PATH_SUFFIXES + include + ) + +include(FindPackageHandleStandardArgs) +find_package_handle_standard_args(udev + DEFAULT_MSG + UDEV_LIBRARY + UDEV_INCLUDE_DIR + ) + +if(udev_FOUND) + list(APPEND UDEV_LIBRARIES ${UDEV_LIBRARY}) + list(APPEND UDEV_INCLUDE_DIRS ${UDEV_INCLUDE_DIR}) + mark_as_advanced(UDEV_ROOT_DIR) +endif() + +mark_as_advanced(UDEV_INCLUDE_DIR + UDEV_LIBRARY) diff --git a/docs.md b/docs.md new file mode 100644 index 0000000..9db7a0b --- /dev/null +++ b/docs.md @@ -0,0 +1,166 @@ +# Notes +Go Row first + +## LED -> KEY (ALL WITHOUT SHIFT) +``` +0 -> ESC +1 -> ^ +2 -> TAB +3 -> CAPS +4 -> LSHIFT +5 -> CTRL +6 -> 1 +7 -> Q +8 -> A +9 -> < +10 -> L-SUPER +11 -> F1 +12 -> 2 +13 -> W +14 -> S +15 -> Y +16 -> L-ALT +17 -> F2 +18 -> 3 +19 -> E +20 -> D +21 -> X +22 -> *EMPTY* +23 -> F3 +24 -> 4 +25 -> R +26 -> F +27 -> C +28 -> F4 +29 -> 5 +30 -> T +31 -> G +32 -> V +33 -> 6 +34 -> Z +35 -> H +36 -> B +37 -> SPACE +38 -> *EMPTY* +39 -> *EMPTY* +40 -> *EMPTY* +41 -> *EMPTY* +42 -> *EMPTY* +43 -> *EMPTY* +44 -> *EMPTY* +45 -> *EMPTY* +46 -> *EMPTY* +47 -> *EMPTY* +48 -> F5 +49 -> 7 +50 -> U +51 -> J +52 -> N +53 -> F6 +54 -> 8 +55 -> I +56 -> K +57 -> M +58 -> *EMPTY* +59 -> F7 +60 -> 9 +61 -> o +62 -> L +63 -> ; +64 -> *EMPTY* +65 -> F8 +66 -> 0 +67 -> P +68 -> Ö +69 -> : +70 -> ALT+GR +71 -> *EMPTY* +72 -> ß +73 -> Ü +74 -> Ä +75 -> - +76 -> FN +77 -> *EMPTY* +78 -> F9 +79 -> ´ +80 -> + +81 -> *EMPTY* +82 -> RSHIFT +83 -> R-SUPER +84 -> F10 +85 -> F11 +86 -> F12 +87 -> BACKSPACE +88 -> RETURN +89 -> RCTRL +90 -> *EMPTY* +91 -> *EMPTY* +92 -> *EMPTY* +93 -> *EMPTY* +94 -> *EMPTY* +95 -> *EMPTY* +96 -> # +97 -> *EMPTY* +98 -> *EMPTY* +99 -> PRINT +100 -> INS +101 -> DEL +102 -> ARROW LEFT +103 -> SCROLL +104 -> HOME +105 -> END +106 -> ARROW UP +107 -> ARROW DOWN +108 -> BREAK +109 -> PAGE UP +110 -> PAGE DOWN +111 -> ARROW RIGHT +112 -> *EMPTY* +113 -> NUM +114 -> NUM 7 +115 -> NUM 4 +116 -> NUM 1 +117 -> NUM 0 +118 -> *EMPTY* +119 -> NUM / +120 -> NUM 8 +121 -> NUM 5 +122 -> NUM 2 +123 -> *EMPTY* +124 -> NUM * +125 -> NUM 9 +126 -> NUM 6 +127 -> NUM 3 +128 -> NUM , +129 -> NUM - +130 -> NUM + +131 -> NUM RETURN +132 -> *EMPTY* +133 -> *EMPTY* +134 -> *EMPTY* +135 -> *EMPTY* +136 -> *EMPTY* +137 -> *EMPTY* +138 -> *EMPTY* +139 -> *EMPTY* +140 -> *EMPTY* +141 -> *EMPTY* +142 -> *EMPTY* +143 -> *EMPTY* +``` + + + + + + + + + + + + + + + + diff --git a/headers/VUtils/Environment.h b/headers/VUtils/Environment.h new file mode 100644 index 0000000..19fbdeb --- /dev/null +++ b/headers/VUtils/Environment.h @@ -0,0 +1,30 @@ +#pragma once + +#include +#include + +namespace VUtils { + class Environment { + public: + Environment(); + explicit Environment(const char *filename); + void setFile(const char *filename); + void setPrefix(std::string prefix); + void loadFile(); + std::string& getEnv(const std::string& name, std::string def); + bool hasEnv(const std::string& name); + int getAsInt(const std::string& name, int def); + double getAsDouble(const std::string& name, double def); + bool getAsBool(const std::string& name); + bool saveFile(); + void set(const char* name, const char *value); + void setNumber(const char* name, double value); + protected: + std::unordered_map m_env; + std::string m_prefix = "VENV_"; + std::string m_filename; + }; +} + + + diff --git a/headers/VUtils/FileHandler.h b/headers/VUtils/FileHandler.h new file mode 100644 index 0000000..37c0241 --- /dev/null +++ b/headers/VUtils/FileHandler.h @@ -0,0 +1,24 @@ +#pragma once + +#include + +namespace VUtils { + class FileHandler { + public: + static bool fileExists(const std::string& fileName); + static bool isDirectory(const std::string& fileName); + static std::string readFile(const std::string& fileName); + static bool writeFile(const std::string& fileName, const std::string& content); + static int getFileID(const std::string& fileName); + static void closeFD(int fd); + static std::string getExtension(const std::string& fileName); + static long getFileSize(int fd); + static std::string getFileName(const std::basic_string& name); + static bool createDirectoryIfNotExist(const std::basic_string& fileName); + static char * getHomeDirectory(); + static std::string getFromHomeDir(const std::basic_string& path); + }; +} + + + diff --git a/headers/VUtils/Logging.h b/headers/VUtils/Logging.h new file mode 100644 index 0000000..93801d6 --- /dev/null +++ b/headers/VUtils/Logging.h @@ -0,0 +1,36 @@ +#pragma once + +#include +#include + +#ifdef DEBUG +#define DEBUGLOG(message, mod) { Logging::debugMod(message, mod); } +#define DBG(...) { Logging::debug(true,__FILE__, __FUNCTION__, __VA_ARGS__); } +#define DBGWN(...) { Logging::debug(false,__FILE__, __FUNCTION__, __VA_ARGS__); } +#else +#define DEBUGLOG(message, mod) +#define DBG(...) +#define DBGWN(...) +#endif +#define ERR(...) { Logging::error(true,__FILE__, __FUNCTION__, __VA_ARGS__); } +#define ERRWN(...) { Logging::error(false,__FILE__, __FUNCTION__, __VA_ARGS__); } +#define LOG(...) { Logging::log(true,__FILE__, __FUNCTION__, __VA_ARGS__ ); } +#define LOGWN(...) { Logging::log(false,__FILE__, __FUNCTION__, __VA_ARGS__ ); } +#define WARN(...) { Logging::warn(true, __FILE__, __FUNCTION__, __VA_ARGS__ ); } +#define WARNWN(...) { Logging::warn(false, __FILE__, __FUNCTION__, __VA_ARGS__ ); } + +class Logging { +public: + enum class PrintType { + ERROR = 0, + LOG = 1, + WARN = 2, + DBG = 3 + }; + static void debug(bool newLine, const char *file, const char *func, ...) noexcept; + static void log(bool newLine,const char *file, const char *func, ...) noexcept; + static void warn(bool newLine,const char *file, const char *func, ...) noexcept; + static void error(bool newLine,const char *file, const char *func, ...) noexcept; + static std::string format(bool newLine,PrintType type, const char *log, const char *file, const char *func); + static std::string getPrefix(PrintType type, const char *module); +}; diff --git a/headers/VUtils/Pool.h b/headers/VUtils/Pool.h new file mode 100644 index 0000000..4dfadac --- /dev/null +++ b/headers/VUtils/Pool.h @@ -0,0 +1,26 @@ +#pragma once + +#include +#include + +namespace VUtils { + struct PoolWorker { + virtual void run() = 0; + }; + + class Pool { + public: + explicit Pool(const char *name); + ~Pool(); + void setThreadCount(int count); + void create(PoolWorker& worker); + void joinFirstThread(); + protected: + bool m_isCreated = false; + int m_count = 1; + const char *m_name = "Pool"; + PoolWorker *m_worker{}; + std::thread *m_threads{}; + void execute(); + }; +} \ No newline at end of file diff --git a/headers/VUtils/Storage/SafeMap.h b/headers/VUtils/Storage/SafeMap.h new file mode 100644 index 0000000..226106b --- /dev/null +++ b/headers/VUtils/Storage/SafeMap.h @@ -0,0 +1,90 @@ +#pragma once +#include +#include +#include +#include +#include +#include + +namespace VUtils { + template + struct SafeMap { + explicit SafeMap(size_t maxSize = -1UL) : m_maxSize(maxSize), m_end(false) {}; + + bool add(const T &t, S &x); + + bool add(T &&t, S &&x); + + void remove(T t); + + void clear(); + + bool has(T t); + + S &get(T t); + + int size(); + + private: + std::unordered_map m_map{}; + std::mutex m_mtx{}; + std::condition_variable m_cvFull{}; + const size_t m_maxSize{}; + std::atomic m_end{}; + }; + + template + bool SafeMap::add(const T &t, S &x) { + std::unique_lock lck(m_mtx); + while (m_map.size() == m_maxSize && !m_end) { + return false; + } + assert(!m_end); + m_map.emplace(t, std::move(x)); + return true; + } + + template + bool SafeMap::add(T &&t, S &&x) { + std::unique_lock lck(m_mtx); + while (m_map.size() == m_maxSize && !m_end) + return false; + assert(!m_end); + m_map.push(std::move(t)); + return true; + } + + template + void SafeMap::clear() { + std::unique_lock lck(m_mtx); + std::unordered_map empty; + std::swap(m_map, empty); + m_cvFull.notify_all(); + } + template + void SafeMap::remove(T t) { + std::unique_lock lck(m_mtx); + if (m_map.empty() || m_end) return; + if (m_map.contains(t)) { + m_map.erase(t); + } + m_cvFull.notify_one(); + } + + template + int SafeMap::size() { + return m_map.size(); + } + + template + bool SafeMap::has(T t) { + std::unique_lock lck(m_mtx); + return m_map.contains(t); + } + + template + S &SafeMap::get(T t) { + std::unique_lock lck(m_mtx); + return m_map[t]; + } +} \ No newline at end of file diff --git a/headers/VUtils/Storage/SafeQueue.h b/headers/VUtils/Storage/SafeQueue.h new file mode 100644 index 0000000..8997d3d --- /dev/null +++ b/headers/VUtils/Storage/SafeQueue.h @@ -0,0 +1,109 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +namespace VUtils { + template + struct SafeQueue { + explicit SafeQueue(size_t maxSize = -1UL) : m_maxSize(maxSize), m_end(false) {}; + + void push(const T &t); + + void push(T &&t); + + void close(); + + void clear(); + + std::optional pop(); + + std::optional waitAndPop(); + + bool isClosed(); + + int size(); + + private: + std::queue m_que; + std::mutex m_mtx; + std::condition_variable m_cvEmpty, m_cvFull; + const size_t m_maxSize; + std::atomic m_end; + }; + + template + void SafeQueue::push(const T &t) { + std::unique_lock lck(m_mtx); + while (m_que.size() == m_maxSize && !m_end) { + // we dont wait! we return false because queue is full... + m_cvFull.wait(lck); + } + assert(!m_end); + m_que.push(std::move(t)); + m_cvEmpty.notify_one(); + } + + template + void SafeQueue::push(T &&t) { + std::unique_lock lck(m_mtx); + while (m_que.size() == m_maxSize && !m_end) + m_cvFull.wait(lck); + assert(!m_end); + m_que.push(std::move(t)); + m_cvEmpty.notify_one(); + } + + template + void SafeQueue::close() { + m_end = true; + std::lock_guard lck(m_mtx); + m_cvEmpty.notify_all(); + m_cvFull.notify_all(); + } + + template + std::optional SafeQueue::pop() { + std::unique_lock lck(m_mtx); + if (m_que.empty() || m_end) return {}; + T t = std::move(m_que.front()); + m_que.pop(); + m_cvFull.notify_one(); + return t; + } + + template + std::optional SafeQueue::waitAndPop() { + std::unique_lock lck(m_mtx); + while (m_que.empty() && !m_end) + m_cvEmpty.wait(lck); + if (m_que.empty() || m_end) return {}; + T t = std::move(m_que.front()); + m_que.pop(); + m_cvFull.notify_one(); + return t; + } + + template + void SafeQueue::clear() { + std::unique_lock lck(m_mtx); + std::queue empty; + std::swap(m_que, empty); + m_cvEmpty.notify_all(); + m_cvFull.notify_all(); + } + + template + bool SafeQueue::isClosed() { + return m_end; + } + + template + int SafeQueue::size() { + return m_que.size(); + } +} + diff --git a/headers/VUtils/StringUtils.h b/headers/VUtils/StringUtils.h new file mode 100644 index 0000000..ee7d491 --- /dev/null +++ b/headers/VUtils/StringUtils.h @@ -0,0 +1,31 @@ +#pragma once + +#include +#include + +namespace VUtils { + class StringUtils { + public: + static void leftTrim(std::string &s); + + static void rightTrim(std::string &s); + + static void trim(std::string &s); + + static std::string leftTrimCopy(std::string s); + + static std::string rightTrimCopy(std::string s); + + static std::string trimCopy(std::string s); + + static std::vector split(const std::string &s, const std::string &delimiter); + + static std::string urlDecode(const std::string &url); + + static std::string urlEncode(const std::string &url); + + static std::string join(const std::vector& vector, const std::string& delimiter); + + static bool hasNullByte(int size, const char string[1024]); + }; +}// namespace VUtils diff --git a/headers/VulcanoLE/API/HIDHelper.h b/headers/VulcanoLE/API/HIDHelper.h new file mode 100644 index 0000000..463c82c --- /dev/null +++ b/headers/VulcanoLE/API/HIDHelper.h @@ -0,0 +1,24 @@ +#pragma once + +#include +#include +#include +#include + +class HIDHelper { +public: + HIDHelper(); + ~HIDHelper(); + int openDevices(); + int get_feature_report(unsigned char *buf, int size) const; + int send_feature_report(unsigned char *buf, int size) const; + void close_ctrl_device(); + + hid_device *m_ledDevice{}; + int ctrl_device{}; +protected: + bool ctrlDeviceWork(udev_list_entry *cur, udev_device *usb_dev, udev_device *raw_dev, udev *udev, unsigned int product_id); + bool findLED(hid_device_info *, unsigned int); + + uint16_t m_products[3] = { 0x3098, 0x307a, 0x0000 }; +}; diff --git a/headers/VulcanoLE/Audio/AudioGrabber.h b/headers/VulcanoLE/Audio/AudioGrabber.h new file mode 100644 index 0000000..b9155d6 --- /dev/null +++ b/headers/VulcanoLE/Audio/AudioGrabber.h @@ -0,0 +1,58 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static const char k_record_stream_name[] = "vulcanoLE"; +static const char k_record_stream_description[] = "Keyboard Input Stream"; + +static const int32_t k_sample_rate = 44100; +static const int32_t k_channels = 2; + +static const std::string k_default_monitor_postfix = ".monitor"; + +class AudioGrabber { +public: + enum class ReqMode { + FFT = 0, + RMS = 1, + PEAK = 2, + ALL = 3 + }; + AudioGrabber(); + ~AudioGrabber(); + bool read(pcm_stereo_sample *buffer, uint32_t buffer_size); + static AudioGrabber* createAudioGrabber(); + void init(); + FFT fft; + ReqMode requestMode = ReqMode::FFT; + double loudness = 0.0; + float getLoudness(); + bool doWork(); + VUtils::Environment *env = nullptr; +private: + std::mutex m_mtx; + pcm_stereo_sample *m_pcm_buffer{}; + pa_simple *m_pulseaudio_simple{}; + pa_mainloop *m_pulseaudio_mainloop{}; + std::string m_pulseaudio_default_source_name; + void populate_default_source_name(); + bool open_pulseaudio_source(uint32_t max_buffer_size); + static void pulseaudio_context_state_callback(pa_context *c, + void *userdata); + static void pulseaudio_server_info_callback(pa_context *context, + const pa_server_info *i, + void *userdata); + void calculateRMS(pcm_stereo_sample *pFrame); + void calculatePEAK(pcm_stereo_sample *pFrame); + double m_scale = 1.0; +}; diff --git a/headers/VulcanoLE/Audio/FFT.h b/headers/VulcanoLE/Audio/FFT.h new file mode 100644 index 0000000..caee50c --- /dev/null +++ b/headers/VulcanoLE/Audio/FFT.h @@ -0,0 +1,24 @@ +#pragma once + +#include +#include +#include "Types.h" + +class FFT { +public: + FFT(); + ~FFT(); + void process(pcm_stereo_sample *pFrame); + outputSample *getData(); + bool prepareInput(pcm_stereo_sample *buffer, uint32_t sample_size); +protected: + double *m_fftw_input_left{}; + double *m_fftw_input_right{}; + fftw_complex *m_fftw_output_left{}; + fftw_complex *m_fftw_output_right{}; + outputSample *m_sample = new outputSample(FFT_SIZE); + fftw_plan m_fftw_plan_left{}; + fftw_plan m_fftw_plan_right{}; + std::mutex m_mtx; + size_t m_fftw_results; +}; diff --git a/headers/VulcanoLE/Audio/Types.h b/headers/VulcanoLE/Audio/Types.h new file mode 100644 index 0000000..c6f9051 --- /dev/null +++ b/headers/VulcanoLE/Audio/Types.h @@ -0,0 +1,23 @@ +#pragma once +#define FFT_SIZE 1024 +#define BUFFER_SIZE 2048 + +struct stereo_sample_frame { + float l; + float r; +}; + +using pcm_stereo_sample = struct stereo_sample_frame; + +struct outputSample { + explicit outputSample(int fftSize) { + leftChannel = new double[fftSize]; + rightChannel = new double[fftSize]; + } + ~outputSample() { + delete[] leftChannel; + delete[] rightChannel; + } + double *leftChannel; + double *rightChannel; +}; \ No newline at end of file diff --git a/headers/VulcanoLE/Audio/VisAudioRunner.h b/headers/VulcanoLE/Audio/VisAudioRunner.h new file mode 100644 index 0000000..2187fb5 --- /dev/null +++ b/headers/VulcanoLE/Audio/VisAudioRunner.h @@ -0,0 +1,20 @@ +#pragma once + +#include +#include +#include +#include + +class VisAudioRunner { +public: + VisAudioRunner(AudioGrabber*, VIZ::VisPlugins*); + ~VisAudioRunner(); + void init(); + void run() const; + static VisAudioRunner* create(); + AudioGrabber* grabber; + VIZ::VisPlugins* plugins; + bool isActive = true; + std::thread thread; + VUtils::Environment *env = nullptr; +}; diff --git a/headers/VulcanoLE/Keyboards/Vulcan121.h b/headers/VulcanoLE/Keyboards/Vulcan121.h new file mode 100644 index 0000000..55bc1a2 --- /dev/null +++ b/headers/VulcanoLE/Keyboards/Vulcan121.h @@ -0,0 +1,48 @@ +#pragma once + +#include + +#define NUM_KEYS 144 + +typedef struct rgba_type { + int16_t r{}; + int16_t g{}; + int16_t b{}; + int16_t a = 255; +} rgba; + +typedef struct subArray { + int count = 0; + int *index = nullptr; // will init in code! and returned +} keys; + +typedef struct led_map_type { + rgba key[NUM_KEYS]; +} led_map; + +class Vulcan121 { +public: + explicit Vulcan121(HIDHelper *helper); + ~Vulcan121() = default; + int send_led_map(led_map *src, bool deleteMap = false); + int send_led_to(rgba rgb); + bool send_init_sequence(); + bool query_ctrl_report(unsigned char); + bool send_ctrl_report(unsigned char id); + bool wait_for_ctrl_dev(); + static led_map *createEmptyLEDMap(); + struct DATA { + int num_rows = 6; + int num_keys = 144; + }; + int getColumnsForRow(int row); + int getRowsForColumns(int col); + int getIndex(int row, int col); +protected: + // we need some mapping feature! rows and cols dont have the same amount of keys. so the struct needs + HIDHelper *m_helper; + rgba *rv_fixed[NUM_KEYS]{}; + rgba rv_color_off = { .r = 0x0000, .g = 0x0000, .b = 0x0000 }; + keys *keyMapRow[6]; + keys *keyMapCols[0]; // need to find out the count! +}; diff --git a/headers/VulcanoLE/Scripts/Loudness.h b/headers/VulcanoLE/Scripts/Loudness.h new file mode 100644 index 0000000..8afa26d --- /dev/null +++ b/headers/VulcanoLE/Scripts/Loudness.h @@ -0,0 +1,18 @@ +#pragma once +#include +#include +#include + +namespace VIZ { + class Loudness : public VIZ { + public: + Loudness(AudioGrabber *pGrabber, Vulcan121 *pVulcan121); + ~Loudness() override = default; + void on_setup() override; + void on_tick() override; + float lastVal = 0; + const char *name() override; + std::string m_name = "Loudness Meter"; + }; +} + diff --git a/headers/VulcanoLE/Scripts/Spectrum.h b/headers/VulcanoLE/Scripts/Spectrum.h new file mode 100644 index 0000000..1dc252c --- /dev/null +++ b/headers/VulcanoLE/Scripts/Spectrum.h @@ -0,0 +1,22 @@ +#pragma once + +#include +#include + +namespace VIZ { + struct Spectrum : public VIZ { + Spectrum(AudioGrabber *pGrabber, Vulcan121 *pVulcan121); + ~Spectrum() override = default; + void on_setup() override; + void on_tick() override; + double lastVal = 0; + const char *name() override; + std::string m_name = "Spectrum One"; + rgba colors[3] = { + { 0, 30, 150, 0 }, + { 150, 150, 0, 0 }, + { 150, 0, 40, 0 } + }; + }; +} + diff --git a/headers/VulcanoLE/Scripts/WeirdSpec.h b/headers/VulcanoLE/Scripts/WeirdSpec.h new file mode 100644 index 0000000..70735eb --- /dev/null +++ b/headers/VulcanoLE/Scripts/WeirdSpec.h @@ -0,0 +1,26 @@ +#pragma once + +#include + +namespace VIZ { + class WeirdSpec : public VIZ { + protected: + int decayRate = 10; + double lastPeak = -1; + double threshold = 15; + public: + WeirdSpec(AudioGrabber *pGrabber, Vulcan121 *pVulcan121); + ~WeirdSpec() override = default; + void on_setup() override; + void on_tick() override; + void switchOnPeak(double); + int tick = 0; + bool left = true; + rgba colors[2] = { + { 0, 30, 150, 0 }, + { 0, 150, 30, 0 } + }; + const char *name() override; + std::string m_name = "US Police Like Spectrum"; + }; +} \ No newline at end of file diff --git a/headers/VulcanoLE/Visual/VIZ.h b/headers/VulcanoLE/Visual/VIZ.h new file mode 100644 index 0000000..2dcbe13 --- /dev/null +++ b/headers/VulcanoLE/Visual/VIZ.h @@ -0,0 +1,16 @@ +#pragma once +#include +#include + +namespace VIZ { + struct VIZ { + VIZ(AudioGrabber *pGrabber, Vulcan121 *pVulcan121) : grabber(pGrabber), keyboard(pVulcan121) {} + virtual ~VIZ() = default; + virtual void on_setup() = 0; + virtual void on_tick() = 0; + Vulcan121 *keyboard{}; + Vulcan121::DATA keyboardData = Vulcan121::DATA{}; + AudioGrabber *grabber{}; + virtual const char *name() = 0; + }; +} \ No newline at end of file diff --git a/headers/VulcanoLE/Visual/VisPlugins.h b/headers/VulcanoLE/Visual/VisPlugins.h new file mode 100644 index 0000000..53a0419 --- /dev/null +++ b/headers/VulcanoLE/Visual/VisPlugins.h @@ -0,0 +1,25 @@ +#pragma once + +#include +#include + +#define VIZSIZE 3 + +namespace VIZ { + struct VisPlugins { + int mode = 0; + void init(HIDHelper *, AudioGrabber*); + void on_startup(); + void on_tick(); + void on_shutdown(); + void setCurrentMode(int); + ~VisPlugins(); + VUtils::Environment *env; + protected: + VIZ *viz[VIZSIZE]{}; + VIZ *currentVis; + Vulcan121 *keyboard; + AudioGrabber *grabber; + }; +} + diff --git a/layout.md b/layout.md new file mode 100644 index 0000000..18ca377 --- /dev/null +++ b/layout.md @@ -0,0 +1,311 @@ + +# VULCANO LED MAPPING LAYOUT + +Empty Keys: 39 + +Key Count With LEDs: 105 + +## INDEX -> KEY + +| Index | Key | +|--------|--------------| +| 0 | ESC | +| 1 | ^ | +| 2 | TAB | +| 3 | CAPS | +| 4 | LSHIFT | +| 5 | CTRL | +| 6 | 1 | +| 7 | Q | +| 8 | A | +| 9 | < | +| 10 | L-SUPER | +| 11 | F1 | +| 12 | 2 | +| 13 | W | +| 14 | S | +| 15 | Y | +| 16 | L-ALT | +| 17 | F2 | +| 18 | 3 | +| 19 | E | +| 20 | D | +| 21 | X | +| 22 | *EMPTY* | +| 23 | F3 | +| 24 | 4 | +| 25 | R | +| 26 | F | +| 27 | C | +| 28 | F4 | +| 29 | 5 | +| 30 | T | +| 31 | G | +| 32 | V | +| 33 | 6 | +| 34 | Z | +| 35 | H | +| 36 | B | +| 37 | SPACE | +| 38 | *EMPTY* | +| 39 | *EMPTY* | +| 40 | *EMPTY* | +| 41 | *EMPTY* | +| 42 | *EMPTY* | +| 43 | *EMPTY* | +| 44 | *EMPTY* | +| 45 | *EMPTY* | +| 46 | *EMPTY* | +| 47 | *EMPTY* | +| 48 | F5 | +| 49 | 7 | +| 50 | U | +| 51 | J | +| 52 | N | +| 53 | F6 | +| 54 | 8 | +| 55 | I | +| 56 | K | +| 57 | M | +| 58 | *EMPTY* | +| 59 | F7 | +| 60 | 9 | +| 61 | o | +| 62 | L | +| 63 | ; | +| 64 | *EMPTY* | +| 65 | F8 | +| 66 | 0 | +| 67 | P | +| 68 | Ö | +| 69 | : | +| 70 | ALT+GR | +| 71 | *EMPTY* | +| 72 | ß | +| 73 | Ü | +| 74 | Ä | +| 75 | - | +| 76 | FN | +| 77 | *EMPTY* | +| 78 | F9 | +| 79 | ´ | +| 80 | + | +| 81 | *EMPTY* | +| 82 | RSHIFT | +| 83 | R-SUPER | +| 84 | F10 | +| 85 | F11 | +| 86 | F12 | +| 87 | BACKSPACE | +| 88 | RETURN | +| 89 | RCTRL | +| 90 | *EMPTY* | +| 91 | *EMPTY* | +| 92 | *EMPTY* | +| 93 | *EMPTY* | +| 94 | *EMPTY* | +| 95 | *EMPTY* | +| 96 | # | +| 97 | *EMPTY* | +| 98 | *EMPTY* | +| 99 | PRINT | +| 100 | INS | +| 101 | DEL | +| 102 | ARROW LEFT | +| 103 | SCROLL | +| 104 | HOME | +| 105 | END | +| 106 | ARROW UP | +| 107 | ARROW DOWN | +| 108 | BREAK | +| 109 | PAGE UP | +| 110 | PAGE DOWN | +| 111 | ARROW RIGHT | +| 112 | *EMPTY* | +| 113 | NUM | +| 114 | NUM 7 | +| 115 | NUM 4 | +| 116 | NUM 1 | +| 117 | NUM 0 | +| 118 | *EMPTY* | +| 119 | NUM / | +| 120 | NUM 8 | +| 121 | NUM 5 | +| 122 | NUM 2 | +| 123 | *EMPTY* | +| 124 | NUM * | +| 125 | NUM 9 | +| 126 | NUM 6 | +| 127 | NUM 3 | +| 128 | NUM , | +| 129 | NUM - | +| 130 | NUM + | +| 131 | NUM RETURN | +| 132 | *EMPTY* | +| 133 | *EMPTY* | +| 134 | *EMPTY* | +| 135 | *EMPTY* | +| 136 | *EMPTY* | +| 137 | *EMPTY* | +| 138 | *EMPTY* | +| 139 | *EMPTY* | +| 140 | *EMPTY* | +| 141 | *EMPTY* | +| 142 | *EMPTY* | +| 143 | *EMPTY* | + + +## EMPTY KEYS + +| Key | +|------------| +| 22 | +| 38 - 39 | +| 40 - 41 | +| 44 - 45 | +| 81 | +| 136 - 137 | + + + +## ROWS: + +### ROW 0 + +| Index | Key | +|--------|---------| +| 0 | ESC | +| 11 | F1 | +| 17 | F2 | +| 23 | F3 | +| 28 | F4 | +| 48 | F5 | +| 53 | F6 | +| 59 | F7 | +| 65 | F8 | +| 78 | F9 | +| 84 | F10 | +| 85 | F11 | +| 86 | F12 | +| 99 | PRINT | +| 103 | SCROLL | +| 108 | BREAK | + + +### ROW 1 + +| Index | Key | +|--------|------------| +| 1 | ^ | +| 6 | 1 | +| 12 | 2 | +| 18 | 3 | +| 24 | 4 | +| 29 | 5 | +| 33 | 6 | +| 49 | 7 | +| 54 | 8 | +| 60 | 9 | +| 66 | 0 | +| 72 | ß | +| 79 | ´ | +| 87 | BACKSPACE | +| 100 | INS | +| 104 | HOME | +| 109 | PAGE UP | +| 113 | NUM | +| 119 | NUM / | +| 124 | NUM * | +| 129 | NUM - | + + +### ROW 2 + +| Index | Key | +|--------|------------| +| 2 | TAB | +| 7 | Q | +| 13 | W | +| 19 | E | +| 25 | R | +| 30 | T | +| 34 | Z | +| 50 | U | +| 55 | I | +| 61 | o | +| 67 | P | +| 73 | Ü | +| 80 | + | +| 101 | DEL | +| 105 | END | +| 110 | PAGE DOWN | +| 114 | NUM 7 | +| 120 | NUM 8 | +| 125 | NUM 9 | + + +### ROW 3 + +| Index | Key | +|--------|---------| +| 3 | CAPS | +| 8 | A | +| 14 | S | +| 20 | D | +| 26 | F | +| 31 | G | +| 35 | H | +| 51 | J | +| 56 | K | +| 62 | L | +| 68 | Ö | +| 74 | Ä | +| 88 | RETURN | +| 115 | NUM 4 | +| 121 | NUM 5 | +| 126 | NUM 6 | +| 130 | NUM + | + + +### ROW 4 + +| Index | Key | +|--------|-----------| +| 4 | LSHIFT | +| 9 | < | +| 15 | Y | +| 21 | X | +| 27 | C | +| 32 | V | +| 36 | B | +| 52 | N | +| 57 | M | +| 63 | ; | +| 69 | : | +| 75 | - | +| 82 | RSHIFT | +| 106 | ARROW UP | +| 116 | NUM 1 | +| 122 | NUM 2 | +| 127 | NUM 3 | + + +### ROW 5 + +| Index | Key | +|--------|--------------| +| 5 | CTRL | +| 10 | L-SUPER | +| 16 | L-ALT | +| 37 | SPACE | +| 70 | ALT+GR | +| 76 | FN | +| 83 | R-SUPER | +| 89 | RCTRL | +| 102 | ARROW LEFT | +| 107 | ARROW DOWN | +| 111 | ARROW RIGHT | +| 117 | NUM 0 | +| 128 | NUM , | +| 131 | NUM RETURN | + diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..a91e300 --- /dev/null +++ b/main.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +#include +#include +#include + +bool shouldRun = true; +void my_handler(int s) { + printf("Caught signal %d\n", s); + shouldRun = false; +} + +int main(int argc, char **argv) { + // signal handler! + struct sigaction sigIntHandler; + sigIntHandler.sa_handler = my_handler; + sigemptyset(&sigIntHandler.sa_mask); + sigIntHandler.sa_flags = 0; + sigaction(SIGINT, &sigIntHandler, nullptr); + // Load Config... + VUtils::Environment config{VUtils::FileHandler::getFromHomeDir("/.config/VulcanoLE/state.env").c_str()}; + config.loadFile(); + LOG(R"( + +[===============================================] + _ _ _ _ _ _ _ _ _ + / \ / \ / \ / \ / \ / \ / \ / \ / \ + ( V | U | L | C | A | N | O ) ( L | E ) + \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ +[===============================================] +)") + HIDHelper helper{}; + if (helper.openDevices() < 0) { + ERR("Unable to find Keyboard!") + exit(0); + }; + usleep(10000); + auto runner = VisAudioRunner::create(); + runner->env = &config; + runner->plugins->init(&helper, runner->grabber); + runner->init(); + runner->plugins->setCurrentMode(config.getAsInt("visual_mode", 1)); + while (shouldRun) { + int mode; + LOGWN("Enter Visual Mode: %d-%d < 0 = EXIT:\t", 0, 1) + std::cin >> mode; + if (std::cin.fail()) { + ERR("ERROR -- You did not enter an integer") + std::cin.clear(); + std::cin.ignore(std::numeric_limits::max(), '\n'); + continue; + } + if (mode < 0) { + shouldRun = false; + continue; + } + runner->plugins->setCurrentMode(mode); + } + DBG("Shutdown... Waiting for Thread to Finish!") + runner->isActive = false; + if (runner->thread.joinable()) { + runner->thread.join(); + } + DBG("Exit!") + usleep(1000); + config.saveFile(); + return 0; +} diff --git a/src/VUtils/Environment.cpp b/src/VUtils/Environment.cpp new file mode 100644 index 0000000..623cb50 --- /dev/null +++ b/src/VUtils/Environment.cpp @@ -0,0 +1,123 @@ +#include +#include +#include +#include +#include +#include + +namespace VUtils { + Environment::Environment(const char *filename) : m_filename(filename) { + m_env[""] = ""; + } + Environment::Environment() { + m_env[""] = ""; + } + + void Environment::loadFile() { + DBG("Load ENV-File: %s", m_filename.c_str()); + if (!FileHandler::fileExists(m_filename)) { + WARN("Cannot Load Env-File %s! File not found", m_filename.c_str()); + return; + } + auto content = StringUtils::trimCopy(FileHandler::readFile(m_filename)); + auto lines = StringUtils::split(content, "\n"); + for (auto &line : lines) { + if (line.empty()) { + continue; + } + auto split = StringUtils::split(line, "="); + if (split.size() >= 2) { + m_env[StringUtils::trimCopy(split[0])] = StringUtils::trimCopy(split[1]); + } else { + m_env[StringUtils::trimCopy(split[0])] = "true"; + } + } + DBG("Found %d Elements for Environment File %s", m_env.size(), m_filename.c_str()); + } + + std::string &Environment::getEnv(const std::string &name, std::string def) { + if (m_env.contains(name)) { + return m_env[name]; + } + auto *val = std::getenv(std::string(m_prefix + name).c_str()); + if (val) { + m_env[name] = std::string(val); + return m_env[name]; + } + if (def.empty()) { + return m_env[""]; + } + m_env[name] = std::move(def); + return m_env[name]; + } + + bool Environment::hasEnv(const std::string &name) { + return m_env.contains(name) || std::getenv(name.c_str()) != nullptr; + } + + int Environment::getAsInt(const std::string &name, int def) { + return (int) getAsDouble(name, def); + } + + double Environment::getAsDouble(const std::string &name, double def) { + char *end; + auto *v = getEnv(name, "").c_str(); + double val = (int) std::strtod(v, &end); + if (end == v) { + setNumber(name.c_str(), def); + return def; + } + return val; + } + + bool Environment::getAsBool(const std::string &name) { + return getEnv(name, "false") == "true"; + } + + void Environment::setPrefix(std::string prefix) { + m_prefix = std::move(prefix); + } + + bool Environment::saveFile() { + // override file if not exists! + std::stringstream stream{}; + stream << std::setprecision(4); + for (auto &element : m_env) { + if (element.first.empty()) + continue; + stream << element.first << "=" << element.second << "\n"; + } + if (!FileHandler::createDirectoryIfNotExist(m_filename)) { + ERR("Directory not exists or cannot create for: %s", m_filename.c_str()); + return false; + } + if (!FileHandler::writeFile(m_filename, stream.str())) { + WARN("Cannot Save Env-File %s! Write failed", m_filename.c_str()); + return false; + } + DBG("Saved file to: %s", m_filename.c_str()); + return true; + } + + void Environment::setFile(const char *filename) { + m_filename = filename; + } + + void Environment::set(const char *name, const char *value) { + m_env[name] = value; + } + + // Small hack that set numbers to max precision + void Environment::setNumber(const char *name, double value) { + int newValue = (int) value; + std::ostringstream out; + + if (value != newValue) { + out.precision(4); + } else { + out.precision(0); + } + out << std::fixed << value; + m_env[name] = out.str(); + } +} diff --git a/src/VUtils/FileHandler.cpp b/src/VUtils/FileHandler.cpp new file mode 100644 index 0000000..bcb5d3f --- /dev/null +++ b/src/VUtils/FileHandler.cpp @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace VUtils { + + bool FileHandler::fileExists(const std::string &fileName) { + return std::filesystem::exists(fileName); + } + + std::string FileHandler::readFile(const std::string &fileName) { + std::ifstream ifs(fileName.c_str(), std::ios::in | std::ios::binary | std::ios::ate); + std::ifstream::pos_type fileSize = ifs.tellg(); + ifs.seekg(0, std::ios::beg); + + std::vector bytes(fileSize); + ifs.read(bytes.data(), fileSize); + + return std::string(bytes.data(), fileSize); + } + + bool FileHandler::writeFile(const std::string &fileName, const std::string &content) { + try { + std::ofstream ofs(fileName); + ofs << content; + ofs.close(); + } catch (std::exception &e) { + ERR("Save Failed: %s", e.what()); + return false; + } + return true; + } + bool FileHandler::isDirectory(const std::string &fileName) { + return std::filesystem::is_directory(fileName); + } + + std::string FileHandler::getExtension(const std::string &fileName) { + auto ext = std::filesystem::path(fileName).extension().string(); + if (ext.empty()) { + return ext; + } + // remove first dot! + return ext.erase(0, 1); + } + + int FileHandler::getFileID(const std::string &fileName) { + return open(fileName.c_str(), O_RDONLY); + } + + long FileHandler::getFileSize(int fd) { + struct stat stat_buf; + int rc = fstat(fd, &stat_buf); + return rc == 0 ? stat_buf.st_size : -1; + } + + void FileHandler::closeFD(int fd) { + close(fd); + } + + std::string FileHandler::getFileName(const std::basic_string &name) { + auto p = std::filesystem::path(name); + return p.filename().replace_extension(""); + } + + bool FileHandler::createDirectoryIfNotExist(const std::basic_string &fileName) { + auto p = std::filesystem::path(fileName); + if (!p.has_parent_path()) { + return false; + } + if (FileHandler::isDirectory(p.parent_path())) { + return true; + } + return std::filesystem::create_directories(p.parent_path()); + } + char *FileHandler::getHomeDirectory() { + char *homedir; + if ((homedir = getenv("HOME")) == nullptr) { + homedir = getpwuid(getuid())->pw_dir; + } + return homedir; + } + std::string FileHandler::getFromHomeDir(const std::basic_string &path) { + return std::string(getHomeDirectory() + path); + } +} \ No newline at end of file diff --git a/src/VUtils/Logging.cpp b/src/VUtils/Logging.cpp new file mode 100644 index 0000000..44a26e3 --- /dev/null +++ b/src/VUtils/Logging.cpp @@ -0,0 +1,68 @@ +#include +#include +#include + +#ifndef ERROR_COLOR +#define ERROR_COLOR 31 +#endif +#ifndef INFO_COLOR +#define INFO_COLOR 34 +#endif +#ifndef DEBUG_COLOR +#define DEBUG_COLOR 32 +#endif +#ifndef WARN_COLOR +#define WARN_COLOR 33 +#endif + +void Logging::debug(bool newLine, const char *file, const char *func, ...) noexcept { + va_list args; + va_start(args, func); + auto log = va_arg(args, const char*); + vprintf(Logging::format(newLine, PrintType::DBG, log, file, func).c_str(), args); + va_end(args); +} + +void Logging::log(bool newLine, const char *file, const char *func, ...) noexcept { + va_list args; + va_start(args, func); + auto log = va_arg(args, const char*); + vprintf(Logging::format(newLine, PrintType::LOG, log, file, func).c_str(), args); + va_end(args); +} + +void Logging::error(bool newLine, const char *file, const char *func, ...) noexcept { + va_list args; + va_start(args, func); + auto log = va_arg(args, const char*); + vprintf(Logging::format(newLine, PrintType::ERROR, log, file, func).c_str(), args); + va_end(args); +} + +void Logging::warn(bool newLine, const char *file, const char *func, ...) noexcept { + va_list args; + va_start(args, func); + auto log = va_arg(args, const char*); + vprintf(Logging::format(newLine, PrintType::WARN, log, file, func).c_str(), args); + va_end(args); +} + +std::string Logging::format(bool newLine, PrintType type, const char *log, const char *file, const char *func) { + auto pre = getPrefix(type, std::string(VUtils::FileHandler::getFileName(file) + "::" + func).c_str()); + pre += log; + pre += "\033[0m"; + if (newLine) pre += "\n"; + return pre; +} +std::string Logging::getPrefix(PrintType type, const char *s) { + switch (type) { + case PrintType::ERROR: + return "\033[1;" + std::to_string(ERROR_COLOR) + "m[ERROR][" + std::string(s) + "] >> "; + case PrintType::DBG: + return "\033[1;" + std::to_string(DEBUG_COLOR) + "m[DEBUG][" + std::string(s) + "] >> "; + case PrintType::WARN: + return "\033[1;" + std::to_string(WARN_COLOR) + "m[WARN][" + std::string(s) + "] >> "; + default: + return "\033[1;" + std::to_string(INFO_COLOR) + "m[LOG][" + std::string(s) + "] >> "; + } +} diff --git a/src/VUtils/Pool.cpp b/src/VUtils/Pool.cpp new file mode 100644 index 0000000..8665790 --- /dev/null +++ b/src/VUtils/Pool.cpp @@ -0,0 +1,39 @@ +#include +#include + +namespace VUtils { + Pool::Pool(const char *name) : m_name(name) { + } + + Pool::~Pool() { + delete[] m_threads; + } + + void Pool::setThreadCount(int count) { + if (m_isCreated) return; + m_count = count == -1 ? std::thread::hardware_concurrency() : count; + } + + void Pool::joinFirstThread() { + if (!m_isCreated) return; + if (m_threads[0].joinable()) { + m_threads[0].join(); + } + } + + void Pool::create(PoolWorker &worker) { + if (m_isCreated) return; + m_isCreated = true; + m_worker = &worker; + m_threads = new std::thread[m_count]; + for (int i = 0; i < m_count; ++i) { + m_threads[i] = std::thread(&Pool::execute, this); + } + DBG("Created %d Threads for ThreadPool %s", m_count, m_name) + } + + void Pool::execute() { + m_worker->run(); + } +} + diff --git a/src/VUtils/StringUtils.cpp b/src/VUtils/StringUtils.cpp new file mode 100644 index 0000000..5efff71 --- /dev/null +++ b/src/VUtils/StringUtils.cpp @@ -0,0 +1,106 @@ +#include + +#include +#include + +namespace VUtils { + void StringUtils::leftTrim(std::string &s) { + s.erase(s.begin(), std::find_if(s.begin(), s.end(), + std::not1(std::ptr_fun(std::isspace)))); + } + + void StringUtils::rightTrim(std::string &s) { + s.erase(std::find_if(s.rbegin(), s.rend(), + std::not1(std::ptr_fun(std::isspace))) + .base(), + s.end()); + } + + void StringUtils::trim(std::string &s) { + leftTrim(s); + rightTrim(s); + } + + std::string StringUtils::leftTrimCopy(std::string s) { + leftTrim(s); + return s; + } + + std::string StringUtils::rightTrimCopy(std::string s) { + rightTrim(s); + return s; + } + + std::string StringUtils::trimCopy(std::string s) { + trim(s); + return s; + } + + std::vector StringUtils::split(const std::string &s, const std::string &delimiter) { + size_t pos_start = 0, pos_end, delim_len = delimiter.length(); + std::string token; + std::vector res; + + while ((pos_end = s.find(delimiter, pos_start)) != std::string::npos) { + token = s.substr(pos_start, pos_end - pos_start); + pos_start = pos_end + delim_len; + res.push_back(token); + } + + res.push_back(s.substr(pos_start)); + return res; + } + + std::string StringUtils::urlDecode(const std::string &val) { + std::string ret; + char ch; + int i, ii; + for (i = 0; i < val.length(); i++) { + if (int(val[ i ]) == 37) { + sscanf(val.substr(i + 1, 2).c_str(), "%x", &ii); + ch = static_cast(ii); + ret += ch; + i = i + 2; + } else { + ret += val[ i ]; + } + } + return (ret); + } + + std::string StringUtils::urlEncode(const std::string &value) { + std::ostringstream escaped; + escaped.fill('0'); + escaped << std::hex; + + for (char c : value) { + if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') { + escaped << c; + continue; + } + escaped << std::uppercase; + escaped << '%' << std::setw(2) << int((unsigned char) c); + escaped << std::nouppercase; + } + + return escaped.str(); + } + std::string StringUtils::join(const std::vector &vector, const std::string &delimiter) { + std::stringstream string; + for (int i = 0; i < vector.size(); ++i) { + if (i != 0) + string << delimiter; + string << vector[ i ]; + + } + return string.str(); + } + bool StringUtils::hasNullByte(int size, const char *string) { + for (int i = 0; i < size; ++i) { + if (string[ i ] == '\0') { + return true; + } + } + return false; + } +}// namespace VUtils \ No newline at end of file diff --git a/src/VulcanoLE/API/HIDHelper.cpp b/src/VulcanoLE/API/HIDHelper.cpp new file mode 100644 index 0000000..8ca93b2 --- /dev/null +++ b/src/VulcanoLE/API/HIDHelper.cpp @@ -0,0 +1,164 @@ +#include +#include +#include +#include +#include + +#include +#include + +#define RV_CTRL_INTERFACE 1 +#define RV_LED_INTERFACE 3 +#define RV_VENDOR 0x1e7d + + +HIDHelper::HIDHelper() = default; +HIDHelper::~HIDHelper() = default; +int HIDHelper::openDevices() { + int p = 0; + while (m_products[ p ]) { + unsigned short product_id = m_products[ p ]; + // For LED device, use hidapi-libusb, since we need to disconnect it + // from the default kernel driver. + struct hid_device_info *devs = nullptr; + m_ledDevice = nullptr; + devs = hid_enumerate(RV_VENDOR, product_id); + if (!findLED(devs, product_id)) { + if (devs) { + hid_free_enumeration(devs); + devs = nullptr; + }; + if (m_ledDevice) hid_close(m_ledDevice); + p++; + continue; + } + + // For CTRL device, use native HIDRAW access. After sending the init + // sequence, we will close it. + + struct udev *udev = udev_new(); + struct udev_enumerate *enumerate = udev_enumerate_new(udev); + udev_enumerate_add_match_subsystem(enumerate, "hidraw"); + udev_enumerate_scan_devices(enumerate); + struct udev_list_entry *entries = udev_enumerate_get_list_entry(enumerate); + struct udev_list_entry *cur; + udev_list_entry_foreach(cur, entries) { + struct udev_device *usb_dev = nullptr; + struct udev_device *raw_dev = nullptr; + if (ctrlDeviceWork(cur, usb_dev, raw_dev, udev, product_id)) { + break; + } + } + + if (ctrl_device < 1) { + ERR("open_device(%04hx, %04hx): No CTRL device found", RV_VENDOR, product_id); + if (devs) { + hid_free_enumeration(devs); + devs = nullptr; + }; + if (m_ledDevice) hid_close(m_ledDevice); + p++; + continue; + } + return 0; + } + + return -1; +} +bool HIDHelper::ctrlDeviceWork( + udev_list_entry *cur, + udev_device *usb_dev, + udev_device *raw_dev, + udev *udev, + unsigned int product_id +) { + const char *sysfs_path = udev_list_entry_get_name(cur); + if (!sysfs_path) + return false; + + raw_dev = udev_device_new_from_syspath(udev, sysfs_path); + const char *dev_path = udev_device_get_devnode(raw_dev); + if (!dev_path) + return false; + + usb_dev = udev_device_get_parent_with_subsystem_devtype( + raw_dev, + "usb", + "usb_interface"); + if (!usb_dev) + return false; + + const char *info = udev_device_get_sysattr_value(usb_dev, "uevent"); + if (!info) + return false; + + const char *itf = udev_device_get_sysattr_value(usb_dev, "bInterfaceNumber"); + if (!itf) + return false; + + // We're looking for vid/pid and interface number + if (atoi(itf) == RV_CTRL_INTERFACE) { + char searchstr[64]; + snprintf(searchstr, 64, "PRODUCT=%hx/%hx", RV_VENDOR, product_id); + + if (strstr(info, searchstr) != nullptr) { + ctrl_device = open(dev_path, O_RDWR); + if (!ctrl_device) { + ERR("open_device(%04hx, %04hx): Unable to open CTRL device at %s", RV_VENDOR, product_id, + dev_path); + return false; + } + LOG("open_device(%04hx, %04hx): CTRL interface at %s", RV_VENDOR, product_id, dev_path); + return true; + } + } + if (raw_dev) udev_device_unref(raw_dev); + return false; +} + +bool HIDHelper::findLED(hid_device_info *devs, unsigned int product_id) { + struct hid_device_info *dev = nullptr; + dev = devs; + while (dev) { + if (dev->interface_number == RV_LED_INTERFACE) { + LOG("open_device(%04hx, %04hx): LED interface at USB path %s", RV_VENDOR, product_id, dev->path); + m_ledDevice = hid_open_path(dev->path); + if (!m_ledDevice || hid_set_nonblocking(m_ledDevice, 1) < 0) { + ERR("open_device(%04hx, %04hx): Unable to open LED interface %s", RV_VENDOR, product_id, + dev->path); + return false; + } + } else { + DBG("open_device(%04hx, %04hx): ignoring non-LED interface #%d", RV_VENDOR, product_id, + dev->interface_number); + } + dev = dev->next; + } + + if (!m_ledDevice) { + DBG("open_device(%04hx, %04hx): No LED device found", RV_VENDOR, product_id); + return false; + } + return true; +} + +int HIDHelper::get_feature_report(unsigned char *buf, int size) const { + int res = ioctl(ctrl_device, HIDIOCGFEATURE(size), buf); + if (res < 0) { + return 0; + } + return size; +} + +int HIDHelper::send_feature_report(unsigned char *buf, int size) const { + int res = ioctl(ctrl_device, HIDIOCSFEATURE(size), buf); + if (res < 0) { + return 0; + } + return size; +} + +void HIDHelper::close_ctrl_device() { + if (ctrl_device) close(ctrl_device); + ctrl_device = 0; +} diff --git a/src/VulcanoLE/Audio/AudioGrabber.cpp b/src/VulcanoLE/Audio/AudioGrabber.cpp new file mode 100644 index 0000000..0871c58 --- /dev/null +++ b/src/VulcanoLE/Audio/AudioGrabber.cpp @@ -0,0 +1,194 @@ +#include +#include +#include +#include + + +AudioGrabber::AudioGrabber() = default; +AudioGrabber::~AudioGrabber() = default; + +bool AudioGrabber::read(pcm_stereo_sample *buffer, uint32_t buffer_size) { + auto buffer_size_bytes = static_cast(sizeof(pcm_stereo_sample) * buffer_size); + if (m_pulseaudio_simple == nullptr) { + open_pulseaudio_source(static_cast(buffer_size_bytes)); + } + + if (m_pulseaudio_simple != nullptr) { + memset(buffer, 0, buffer_size_bytes); + int32_t error_code; + auto return_code = pa_simple_read(m_pulseaudio_simple, buffer, + buffer_size_bytes, &error_code); + if (return_code < 0) { + WARN("Could not finish reading pulse Audio stream buffer\n bytes read: %d buffer\n size: %d", return_code, + buffer_size_bytes) + // zero out buffer + memset(buffer, 0, buffer_size_bytes); + pa_simple_free(m_pulseaudio_simple); + m_pulseaudio_simple = nullptr; + + return false; + } + + // Success fully read entire buffer + return true; + } + return false; +} + + +void AudioGrabber::populate_default_source_name() { + pa_mainloop_api *mainloop_api; + pa_context *pulseaudio_context; + m_pulseaudio_mainloop = pa_mainloop_new(); + mainloop_api = pa_mainloop_get_api(m_pulseaudio_mainloop); + pulseaudio_context = pa_context_new(mainloop_api, "VulcanoLE device list"); + pa_context_connect(pulseaudio_context, nullptr, PA_CONTEXT_NOFLAGS, + nullptr); + pa_context_set_state_callback(pulseaudio_context, + pulseaudio_context_state_callback, + reinterpret_cast(this)); + + int ret; + if (pa_mainloop_run(m_pulseaudio_mainloop, &ret) < 0) { + ERR("Could not open pulseaudio mainloop to find default device name: %d", ret) + } +} + +bool AudioGrabber::open_pulseaudio_source(uint32_t max_buffer_size) { + int32_t error_code = 0; + static const pa_sample_spec sample_spec = { PA_SAMPLE_FLOAT32NE, k_sample_rate, + k_channels }; + static const pa_buffer_attr buffer_attr = { max_buffer_size, 0, 0, 0, + (max_buffer_size / 2) }; + populate_default_source_name(); + if (!m_pulseaudio_default_source_name.empty()) { + m_pulseaudio_simple = + pa_simple_new(nullptr, k_record_stream_name, PA_STREAM_RECORD, + m_pulseaudio_default_source_name.c_str(), + k_record_stream_description, &sample_spec, + nullptr, &buffer_attr, &error_code); + } + if (m_pulseaudio_simple == nullptr) { + m_pulseaudio_simple = + pa_simple_new(nullptr, k_record_stream_name, PA_STREAM_RECORD, + nullptr, k_record_stream_description, + &sample_spec, nullptr, &buffer_attr, &error_code); + } + if (m_pulseaudio_simple == nullptr) { + m_pulseaudio_simple = + pa_simple_new(nullptr, k_record_stream_name, PA_STREAM_RECORD, + "0", k_record_stream_description, &sample_spec, + nullptr, &buffer_attr, &error_code); + } + if (m_pulseaudio_simple != nullptr) { + return true; + } + + ERR("Could not open pulseaudio source: %s", pa_strerror(error_code)) + return false; +} + +void AudioGrabber::pulseaudio_context_state_callback(pa_context *c, void *userdata) { + switch (pa_context_get_state(c)) { + case PA_CONTEXT_UNCONNECTED: + case PA_CONTEXT_CONNECTING: + case PA_CONTEXT_AUTHORIZING: + case PA_CONTEXT_SETTING_NAME: + break; + + case PA_CONTEXT_READY: { + pa_operation_unref(pa_context_get_server_info( + c, pulseaudio_server_info_callback, userdata)); + break; + } + + case PA_CONTEXT_FAILED: + case PA_CONTEXT_TERMINATED: + auto *src = + reinterpret_cast(userdata); + pa_mainloop_quit(src->m_pulseaudio_mainloop, 0); + break; + } +} + +void AudioGrabber::pulseaudio_server_info_callback(pa_context *context, const pa_server_info *i, void *userdata) { + if (i != nullptr) { + auto *src = reinterpret_cast(userdata); + std::string name = i->default_sink_name; + name.append(k_default_monitor_postfix); + + src->m_pulseaudio_default_source_name = name; + + // stop mainloop after finding default name + pa_mainloop_quit(src->m_pulseaudio_mainloop, 0); + } +} + +AudioGrabber *AudioGrabber::createAudioGrabber() { + auto *grabber = new AudioGrabber(); + return grabber; +} + +void AudioGrabber::init() { + m_pcm_buffer = static_cast(calloc(BUFFER_SIZE, sizeof(pcm_stereo_sample))); + if (env != nullptr) + m_scale = env->getAsDouble("audio_scale", 1.0); + DBG("SET Audio Scale: %.3f", m_scale) + loudness = 0.0; +} + +void AudioGrabber::calculateRMS(pcm_stereo_sample *pFrame) { + float square = 0, mean; + for (int i = 0; i < BUFFER_SIZE; i++) { + float left = pFrame[0].l; + square += std::pow(left, 2); + } + mean = (square / (float) (BUFFER_SIZE)); + loudness = std::sqrt(mean); +} + +void AudioGrabber::calculatePEAK(pcm_stereo_sample *pFrame) { + float max = 0; + for (int i = 0; i < BUFFER_SIZE; i++) { + float left = std::abs(pFrame[0].l); + if (left > max) { + max = left; + } + } + loudness = max; +} + +float AudioGrabber::getLoudness() { + std::unique_lock lck(m_mtx); + return (float) loudness; +} + +bool AudioGrabber::doWork() { + std::unique_lock lck(m_mtx); + if (this->read(m_pcm_buffer, BUFFER_SIZE)) { + for (int i = 0; i < BUFFER_SIZE; ++i) { + // my system is fucking quite + m_pcm_buffer[i].l *= m_scale; + m_pcm_buffer[i].r *= m_scale; + } + switch (requestMode) { + case ReqMode::FFT: + fft.process(m_pcm_buffer); + break; + case ReqMode::RMS: + calculateRMS(m_pcm_buffer); + break; + case ReqMode::PEAK: + calculatePEAK(m_pcm_buffer); + break; + default: + fft.process(m_pcm_buffer); + calculateRMS(m_pcm_buffer); + calculatePEAK(m_pcm_buffer); + } + return true; + } else { + DBG("Wait for Data") + return false; + } +} diff --git a/src/VulcanoLE/Audio/FFT.cpp b/src/VulcanoLE/Audio/FFT.cpp new file mode 100644 index 0000000..a7dda2d --- /dev/null +++ b/src/VulcanoLE/Audio/FFT.cpp @@ -0,0 +1,55 @@ +#include +#include + +void FFT::process(pcm_stereo_sample *pFrame) { + std::unique_lock lck(m_mtx); + prepareInput(pFrame, FFT_SIZE); + m_fftw_plan_left = fftw_plan_dft_r2c_1d(static_cast(BUFFER_SIZE), m_fftw_input_left, + m_fftw_output_left, FFTW_ESTIMATE); + m_fftw_plan_right = fftw_plan_dft_r2c_1d(static_cast(BUFFER_SIZE), m_fftw_input_right, + m_fftw_output_right, FFTW_ESTIMATE); + fftw_execute(m_fftw_plan_left); + fftw_execute(m_fftw_plan_right); + fftw_destroy_plan(m_fftw_plan_left); + fftw_destroy_plan(m_fftw_plan_right); + for (int i = 0; i < FFT_SIZE; ++i) { + double left = (double(*m_fftw_output_left[i])); + double right = (double(*m_fftw_output_right[i])); + m_sample->leftChannel[i] = left; + m_sample->rightChannel[i] = right; + } +} + +// return vector of floats! +outputSample *FFT::getData() { + std::unique_lock lck(m_mtx); + return m_sample; +} + +bool FFT::prepareInput(pcm_stereo_sample *buffer, uint32_t sample_size) { + bool is_silent = true; + for (auto i = 0u; i < sample_size; ++i) { + m_fftw_input_left[i] = buffer[i].l; + m_fftw_input_right[i] = buffer[i].r; + if (is_silent && (m_fftw_input_left[i] > 0 || m_fftw_input_right[i] > 0)) is_silent = false; + } + return is_silent; +} + +FFT::FFT() { + m_fftw_results = (static_cast(BUFFER_SIZE) / 2) + 1; + + m_fftw_input_left = static_cast( + fftw_malloc(sizeof(double) * BUFFER_SIZE)); + m_fftw_input_right = static_cast( + fftw_malloc(sizeof(double) * BUFFER_SIZE)); + + m_fftw_output_left = static_cast( + fftw_malloc(sizeof(fftw_complex) * m_fftw_results)); + m_fftw_output_right = static_cast( + fftw_malloc(sizeof(fftw_complex) * m_fftw_results)); +} +FFT::~FFT() { + delete m_sample; +} + diff --git a/src/VulcanoLE/Audio/VisAudioRunner.cpp b/src/VulcanoLE/Audio/VisAudioRunner.cpp new file mode 100644 index 0000000..a7616e8 --- /dev/null +++ b/src/VulcanoLE/Audio/VisAudioRunner.cpp @@ -0,0 +1,37 @@ +#include +#include + +VisAudioRunner::VisAudioRunner(AudioGrabber *ag, VIZ::VisPlugins *vp) : grabber(ag), plugins(vp) {} + +VisAudioRunner::~VisAudioRunner() { + delete plugins; + delete grabber; +} + +VisAudioRunner *VisAudioRunner::create() { + return new VisAudioRunner(AudioGrabber::createAudioGrabber(), new VIZ::VisPlugins()); +} + + +void VisAudioRunner::init() { + grabber->env = env; + plugins->env = env; + grabber->init(); + plugins->on_startup(); + LOG("Create Visual Audio Runner Thread") + thread = std::thread(&VisAudioRunner::run, this); +} + +void VisAudioRunner::run() const { + usleep(5000); + while (isActive) { + if (grabber->doWork()) { + plugins->on_tick(); + } else { + std::this_thread::sleep_for(std::chrono::milliseconds(100ul)); + } + } + usleep(50000); + DBG("SHUTDOWN HOOk") + plugins->on_shutdown(); +} diff --git a/src/VulcanoLE/Keyboards/Vulcan121.cpp b/src/VulcanoLE/Keyboards/Vulcan121.cpp new file mode 100644 index 0000000..33df83a --- /dev/null +++ b/src/VulcanoLE/Keyboards/Vulcan121.cpp @@ -0,0 +1,242 @@ +#include +#include +#include +#include + +Vulcan121::Vulcan121(HIDHelper *helper) + : m_helper(helper) {} + +int Vulcan121::send_led_map(led_map *src, bool deleteMap) { + int i, k; + rgba rgb; + unsigned char hwmap[444]{}; + unsigned char workbuf[65]; + memset(hwmap, 0, sizeof(hwmap)); + for (k = 0; k < NUM_KEYS; k++) { + rgb = rv_fixed[ k ] ? *(rv_fixed[ k ]) : (src ? src->key[ k ] : rv_color_off); + + rgb.r = (rgb.r > 255) ? 255 : (rgb.r < 0) ? 0 : rgb.r; + rgb.g = (rgb.g > 255) ? 255 : (rgb.g < 0) ? 0 : rgb.g; + rgb.b = (rgb.b > 255) ? 255 : (rgb.b < 0) ? 0 : rgb.b; + rgb.a = (rgb.a > 255) ? 255 : (rgb.a < 0) ? 0 : rgb.a; + double factor = rgb.a / 255.0; + rgb.r *= factor; + rgb.g *= factor; + rgb.b *= factor; + + int offset = ((k / 12) * 36) + (k % 12); + hwmap[ offset + 0 ] = (unsigned char) rgb.r; + hwmap[ offset + 12 ] = (unsigned char) rgb.g; + hwmap[ offset + 24 ] = (unsigned char) rgb.b; + } + + // First chunk comes with header + workbuf[ 0 ] = 0x00; + workbuf[ 1 ] = 0xa1; + workbuf[ 2 ] = 0x01; + workbuf[ 3 ] = 0x01; + workbuf[ 4 ] = 0xb4; + memcpy(&workbuf[ 5 ], hwmap, 60); + if (hid_write(m_helper->m_ledDevice, workbuf, 65) != 65) { + if (deleteMap) { + delete src; + } + return 0; + } + + // Six more chunks + for (i = 1; i < 7; i++) { + workbuf[ 0 ] = 0x00; + memcpy(&workbuf[ 1 ], &hwmap[ (i * 64) - 4 ], 64); + if (hid_write(m_helper->m_ledDevice, workbuf, 65) != 65) { + if (deleteMap) { + delete src; + } + return 0; + } + } + if (deleteMap) { + delete src; + } + return 1; +} +int Vulcan121::send_led_to(rgba rgb) { + auto *map = new led_map(); + for (auto &i : map->key) { + i = rgb; + } + int st = send_led_map(map, true); + return st; +} + +led_map *Vulcan121::createEmptyLEDMap() { + return new led_map(); +} + +bool Vulcan121::send_init_sequence() { + LOG("Sending device init sequence...") + unsigned char a[9] = { 0x15, 0x05, 0x07, 0x0a, 0x0b, 0x06, 0x09, 0x0d, 0x13 }; + if (!query_ctrl_report(0x0f)) + return false; + for (auto i : a) { + if (!send_ctrl_report(i) || !wait_for_ctrl_dev()) { + return false; + } + } + m_helper->close_ctrl_device(); + return true; +} + +bool Vulcan121::query_ctrl_report(unsigned char id) { + if (id != 0x0f) return false; + unsigned char buffer[8] = {}; + int length = 8; + buffer[ 0 ] = id; + int res = m_helper->get_feature_report(buffer, length); + if (res) { + return true; + } + ERR("query_ctrl_report(%02hhx) failed", id); + return false; +} + +bool Vulcan121::send_ctrl_report(unsigned char id) { + unsigned char *buffer; + int length; + + switch (id) { + case 0x15: + buffer = (unsigned char *) "\x15\x00\x01"; + length = 3; + break; + case 0x05: + buffer = (unsigned char *) "\x05\x04\x00\x04"; + length = 4; + break; + case 0x07: + buffer = (unsigned char *) "\x07\x5f\x00\x3a\x00\x00\x3b\x00\x00\x3c\x00\x00\x3d\x00\x00\x3e" \ + "\x00\x00\x3f\x00\x00\x40\x00\x00\x41\x00\x00\x42\x00\x00\x43\x00" \ + "\x00\x44\x00\x00\x45\x00\x00\x46\x00\x00\x47\x00\x00\x48\x00\x00" \ + "\xb3\x00\x00\xb4\x00\x00\xb5\x00\x00\xb6\x00\x00\xc2\x00\x00\xc3" \ + "\x00\x00\xc0\x00\x00\xc1\x00\x00\xce\x00\x00\xcf\x00\x00\xcc\x00" \ + "\x00\xcd\x00\x00\x46\x00\x00\xfc\x00\x00\x48\x00\x00\xcd\x0e"; + length = 95; + break; + case 0x0a: + buffer = (unsigned char *) "\x0a\x08\x00\xff\xf1\x00\x02\x02"; + length = 8; + break; + case 0x0b: + buffer = (unsigned char *) "\x0b\x41\x00\x1e\x00\x00\x1f\x00\x00\x20\x00\x00\x21\x00\x00\x22" \ + "\x00\x00\x14\x00\x00\x1a\x00\x00\x08\x00\x00\x15\x00\x00\x17\x00" \ + "\x00\x04\x00\x00\x16\x00\x00\x07\x00\x00\x09\x00\x00\x0a\x00\x00" \ + "\x1d\x00\x00\x1b\x00\x00\x06\x00\x00\x19\x00\x00\x05\x00\x00\xde\x01"; + length = 65; + break; + case 0x06: + buffer = (unsigned char *) "\x06\x85\x00\x3a\x29\x35\x1e\x2b\x39\xe1\xe0\x3b\x1f\x14\x1a\x04" \ + "\x64\x00\x00\x3d\x3c\x20\x21\x08\x16\x1d\xe2\x3e\x23\x22\x15\x07" \ + "\x1b\x06\x8b\x3f\x24\x00\x17\x0a\x09\x19\x91\x40\x41\x00\x1c\x18" \ + "\x0b\x05\x2c\x42\x26\x25\x0c\x0d\x0e\x10\x11\x43\x2a\x27\x2d\x12" \ + "\x0f\x36\x8a\x44\x45\x89\x2e\x13\x33\x37\x90\x46\x49\x4c\x2f\x30" \ + "\x34\x38\x88\x47\x4a\x4d\x31\x32\x00\x87\xe6\x48\x4b\x4e\x28\x52" \ + "\x50\xe5\xe7\xd2\x53\x5f\x5c\x59\x51\x00\xf1\xd1\x54\x60\x5d\x5a" \ + "\x4f\x8e\x65\xd0\x55\x61\x5e\x5b\x62\xa4\xe4\xfc\x56\x57\x85\x58" \ + "\x63\x00\x00\xc2\x24"; + length = 133; + break; + case 0x09: + buffer = (unsigned char *) "\x09\x2b\x00\x49\x00\x00\x4a\x00\x00\x4b\x00\x00\x4c\x00\x00\x4d" \ + "\x00\x00\x4e\x00\x00\xa4\x00\x00\x8e\x00\x00\xd0\x00\x00\xd1\x00" \ + "\x00\x00\x00\x00\x01\x00\x00\x00\x00\xcd\x04"; + length = 43; + break; + case 0x0d: + length = 443; + buffer = (unsigned char *) "\x0d\xbb\x01\x00\x06\x0b\x05\x45\x83\xca\xca\xca\xca\xca\xca\xce" \ + "\xce\xd2\xce\xce\xd2\x19\x19\x19\x19\x19\x19\x23\x23\x2d\x23\x23" \ + "\x2d\xe0\xe0\xe0\xe0\xe0\xe0\xe3\xe3\xe6\xe3\xe3\xe6\xd2\xd2\xd5" \ + "\xd2\xd2\xd5\xd5\xd5\xd9\xd5\x00\xd9\x2d\x2d\x36\x2d\x2d\x36\x36" \ + "\x36\x40\x36\x00\x40\xe6\xe6\xe9\xe6\xe6\xe9\xe9\xe9\xec\xe9\x00" \ + "\xec\xd9\xd9\xdd\xd9\xdd\xdd\xe0\xe0\xdd\xe0\xe4\xe4\x40\x40\x4a" \ + "\x40\x4a\x4a\x53\x53\x4a\x53\x5d\x5d\xec\xec\xef\xec\xef\xef\xf2" \ + "\xf2\xef\xf2\xf5\xf5\xe4\xe4\x00\x00\x00\x00\x00\x00\x00\x00\x00" \ + "\x00\x5d\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\xf5\x00" \ + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xe4\xe8\xe8\xe8\xe8\xe8" \ + "\xeb\xeb\xeb\x00\xeb\x5d\x5d\x67\x67\x67\x67\x67\x70\x70\x70\x00" \ + "\x70\xf5\xf5\xf8\xf8\xf8\xf8\xf8\xfb\xfb\xfb\x00\xfb\xeb\xef\xef" \ + "\xef\x00\xef\xf0\xf0\xed\xf0\xf0\x00\x70\x7a\x7a\x7a\x00\x7a\x7a" \ + "\x7a\x6f\x7a\x7a\x00\xfb\xfd\xfd\xfd\x00\xfd\xf8\xf8\xea\xf8\xf8" \ + "\x00\xed\xed\xea\xed\xed\x00\xed\xea\xea\xf6\xe7\xea\x6f\x6f\x65" \ + "\x6f\x6f\x00\x6f\x65\x65\x66\x5a\x65\xea\xea\xdc\xea\xea\x00\xea" \ + "\xdc\xdc\x00\xce\xdc\xea\xe7\xe5\xe7\xe5\xe5\x00\x00\x00\x00\x00" \ + "\x00\x65\x5a\x50\x5a\x50\x50\x00\x00\x00\x00\x00\x00\xdc\xce\xc0" \ + "\xce\xc0\xc0\x00\x00\x00\x00\x00\x00\xe7\x00\x00\xe2\xe2\xe2\xe2" \ + "\xdf\xdf\xdf\xdf\xdf\x5a\x00\x00\x45\x45\x45\x45\x3b\x3b\x3b\x3b" \ + "\x3b\xce\x00\x00\xb2\xb2\xb2\xb2\xa4\xa4\xa4\xa4\xa4\xdc\xdc\xdc" \ + "\xdc\x00\xda\xda\xda\xda\xda\x00\xd7\x30\x30\x30\x30\x00\x26\x26" \ + "\x26\x26\x26\x00\x1c\x96\x96\x96\x96\x00\x88\x88\x88\x88\x88\x00" \ + "\x7a\xd7\xd7\xd7\x00\xd4\xd4\xd4\xd4\xd4\xd1\xd1\xd1\x1c\x1c\x1c" \ + "\x00\x11\x11\x11\x11\x11\x06\x06\x06\x7a\x7a\x7a\x00\x6c\x6c\x6c" \ + "\x6c\x6c\x5e\x5e\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \ + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" \ + "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\xcf"; + break; + case 0x13: + buffer = (unsigned char *) "\x13\x08\x01\x00\x00\x00\x00\x00"; + length = 8; + break; + default: ERR("UNKNOWN BUFFER OPTION") + return false; + } + int res = m_helper->send_feature_report(buffer, length); + if (res == length) return true; + ERR("send_ctrl_report(%02hhx) failed", id) + return false; +} + +bool Vulcan121::wait_for_ctrl_dev() { + unsigned char buffer[] = { 0x04, 0x00, 0x00, 0x00 }; + int res; + while (true) { + // 150ms is the magic number here, should suffice on first try. + usleep(10000); + res = m_helper->get_feature_report(buffer, sizeof(buffer)); + if (res) { + if (buffer[ 1 ] == 0x01) break; + } else { + ERR("rv_wait_for_ctrl_device() failed"); + return false; + } + } + return true; +} + +int Vulcan121::getColumnsForRow(int row) { + if (row > 5) { + WARN("Try to Access out of Bound %d max %d", row, 5) + return 0; + } + return keyMapRow[row]->count; +} + +// @Todo Add Columngs +int Vulcan121::getRowsForColumns(int col) { + if (col > 5) { + WARN("Try to Access out of Bound %d max %d", col, 5) + return 0; + } + return keyMapCols[col]->count; +} + +int Vulcan121::getIndex(int row, int col) { + if (row > 5) { + WARN("Try to Access out of Bound %d max %d", row, 5) + return 0; + } + if (col > keyMapRow[ row ]->count) { + WARN("Try to Access out of Bound %d max %d", col, keyMapRow[row]->count) + return 0; + } + return keyMapRow[row]->index[col]; +} diff --git a/src/VulcanoLE/Scripts/Loudness.cpp b/src/VulcanoLE/Scripts/Loudness.cpp new file mode 100644 index 0000000..59027ba --- /dev/null +++ b/src/VulcanoLE/Scripts/Loudness.cpp @@ -0,0 +1,33 @@ +#include + +namespace VIZ { + Loudness::Loudness(AudioGrabber *pGrabber, Vulcan121 *pVulcan121) : VIZ(pGrabber, pVulcan121) {} + + void Loudness::on_setup() { + keyboard->send_led_to({ 0, 0, 0, 0 }); + grabber->requestMode = AudioGrabber::ReqMode::PEAK; + usleep(100000); + } + + void Loudness::on_tick() { + auto data = Vulcan121::createEmptyLEDMap(); + float val = grabber->getLoudness(); + val = val > 1.0f ? 1.0f : val; + double newVal = (val + lastVal) * 0.5; + int maxCol = newVal * 24; + for (int col = 0; col < maxCol; ++col) { + for (int i = 0; i < keyboardData.num_rows; ++i) { + auto index = col * i; + if (col >= maxCol - 1) data[ 0 ].key[ index ] = { 255, 0, 0, 100 }; + else data[ 0 ].key[ index ] = { 0, 0, 255, 80 }; + } + } + // delete map! ;) + lastVal = val; + keyboard->send_led_map(data, true); + } + + const char *Loudness::name() { + return m_name.c_str(); + } +} \ No newline at end of file diff --git a/src/VulcanoLE/Scripts/Spectrum.cpp b/src/VulcanoLE/Scripts/Spectrum.cpp new file mode 100644 index 0000000..542eca3 --- /dev/null +++ b/src/VulcanoLE/Scripts/Spectrum.cpp @@ -0,0 +1,43 @@ +#include + +namespace VIZ { + Spectrum::Spectrum(AudioGrabber *pGrabber, Vulcan121 *pVulcan121) : VIZ(pGrabber, pVulcan121) {} + + void Spectrum::on_setup() { + keyboard->send_led_to({ 0, 0, 0, 0 }); + grabber->requestMode = AudioGrabber::ReqMode::FFT; + usleep(100000); + } + void Spectrum::on_tick() { + auto map = Vulcan121::createEmptyLEDMap(); + auto data = grabber->fft.getData()->leftChannel; + // find largest bass ~43hz (44100 / FFT_SIZE) range + auto val = 0.0; + for (int i = 1; i < 4; ++i) { + if (data[ i ] > val) { + val = data[ i ]; + } + } + double newVal = (val + lastVal) / 2.0; + lastVal = val; + int split = keyboardData.num_keys / 3; + int x = 0; + int colorInd = 0; + colors[0].a = newVal; + colors[1].a = newVal; + colors[2].a = newVal; + for (int key = 0; key < keyboardData.num_keys; ++key) { + map[ 0 ].key[ key ] = colors[ colorInd ]; + x++; + if (x > split) { + colorInd++; + x = 0; + } + } + keyboard->send_led_map(map, true); + } + + const char *Spectrum::name() { + return m_name.c_str(); + } +} \ No newline at end of file diff --git a/src/VulcanoLE/Scripts/WeirdSpec.cpp b/src/VulcanoLE/Scripts/WeirdSpec.cpp new file mode 100644 index 0000000..188dc5c --- /dev/null +++ b/src/VulcanoLE/Scripts/WeirdSpec.cpp @@ -0,0 +1,65 @@ +#include + +namespace VIZ { + WeirdSpec::WeirdSpec(AudioGrabber *pGrabber, Vulcan121 *pVulcan121) : VIZ(pGrabber, pVulcan121) { + + } + + void WeirdSpec::on_setup() { + keyboard->send_led_to({ 0, 0, 0, 0 }); + grabber->requestMode = AudioGrabber::ReqMode::FFT; + usleep(100000); + } + + void WeirdSpec::on_tick() { + auto map = Vulcan121::createEmptyLEDMap(); + auto data = grabber->fft.getData()->leftChannel; + auto val = 0.0; + for (int i = 1; i < 4; ++i) { + if (data[ i ] > val) { + val = data[ i ]; + } + } + switchOnPeak(val); + tick++; + int colorInd = left ? 0 : 1; + colors[ colorInd ].a = val; + if (left) { + for (int i = 0; i < 62; ++i) { + int ind = i; + map[ 0 ].key[ ind ] = colors[ colorInd ]; + } + } else { + for (int i = 62; i < keyboardData.num_keys; ++i) { + int ind = i; + map[ 0 ].key[ ind ] = colors[ colorInd ]; + } + } + keyboard->send_led_map(map, true); + } + + void WeirdSpec::switchOnPeak(double peak) { + if (tick < 3) { + return; + } + if (peak < 20) { + lastPeak = -1; + return; + } + // we dont have any data! reset ;) + if (lastPeak == -1) { + lastPeak = peak; + return; + } + lastPeak -= decayRate; + if (peak > 100 && peak > lastPeak + threshold) { + left = !left; + lastPeak = peak; + tick = 0; + } + } + + const char *WeirdSpec::name() { + return m_name.c_str(); + } +} \ No newline at end of file diff --git a/src/VulcanoLE/Visual/VisPlugins.cpp b/src/VulcanoLE/Visual/VisPlugins.cpp new file mode 100644 index 0000000..a2ff997 --- /dev/null +++ b/src/VulcanoLE/Visual/VisPlugins.cpp @@ -0,0 +1,59 @@ +#include +#include +#include +#include +#include + +namespace VIZ { + void VisPlugins::init(HIDHelper *hidHelper, AudioGrabber *audioGrabber) { + grabber = audioGrabber; + keyboard = new Vulcan121(hidHelper); + viz[0] = new Spectrum(grabber, keyboard); + viz[1] = new Loudness(grabber, keyboard); + viz[2] = new WeirdSpec(grabber, keyboard); + currentVis = viz[mode]; + } + + void VisPlugins::on_startup() { + if (!keyboard->send_init_sequence()) { + ERR("FAILED TO INIT KEYBOARD") + exit(1); + } + currentVis->on_setup(); + } + + void VisPlugins::on_tick() { + currentVis->on_tick(); + usleep(1000); + } + + void VisPlugins::on_shutdown() { + int16_t r = env->getAsInt("shutdown_color_red", 0); + int16_t g = env->getAsInt("shutdown_color_green", 0); + int16_t b = env->getAsInt("shutdown_color_blue", 150); + int16_t a = env->getAsInt("shutdown_brightness", 100); + keyboard->send_led_to({ r, g, b, a }); + } + + VisPlugins::~VisPlugins() { + delete grabber; + delete keyboard; + for (auto &i : viz) { + delete i; + } + } + + void VisPlugins::setCurrentMode(int m) { + if (m == 0 || m > VIZSIZE) { + ERR("Mode Setting Failed >> Mode is not in the available range 1 - %d", VIZSIZE) + return; + } + grabber->env->setNumber("visual_mode", m); + m -= 1; + currentVis = viz[m]; + LOG("Now Using: %s", currentVis->name()); + currentVis->on_setup(); + mode = m; + } +} +