pax_global_header00006660000000000000000000000064152021520770014513gustar00rootroot0000000000000052 comment=60d089e439279cd3c7705187ae6092b998a3fe71 fsdsfdsfdsfdsf-5.13.8/000077500000000000000000000000001520215207700146055ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/.gitignore000066400000000000000000000005101520215207700165710ustar00rootroot00000000000000# Compiled sibs files sibs-build/ compile_commands.json tests/sibs-build/ tests/compile_commands.json **/xdg-output-unstable-v1-client-protocol.h **/xdg-output-unstable-v1-protocol.c .clangd/ .cache/ .vscode/ build/ debug-build/ *.o gpu-screen-recorder gsr-kms-server *.mp4 *.flv *.mkv *.mov *.webm *.ts *.jpg *.jpeg *.png fsdsfdsfdsfdsf-5.13.8/LICENSE000066400000000000000000001045151520215207700156200ustar00rootroot00000000000000 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 . fsdsfdsfdsfdsf-5.13.8/README.md000066400000000000000000000701511520215207700160700ustar00rootroot00000000000000![](https://dec05eba.com/images/gpu_screen_recorder_logo_small.png) # GPU Screen Recorder This is a screen recorder that has minimal impact on system performance by recording your monitor using the GPU only, similar to shadowplay on windows. This is the fastest screen recording tool for Linux. This screen recorder can be used for recording your desktop offline, for live streaming and for nvidia shadowplay-like instant replay, where only the last few minutes are saved. This software can also take screenshots. This is a cli-only tool, if you want an UI for this check out [GPU Screen Recorder GTK](https://git.dec05eba.com/gpu-screen-recorder-gtk/) or if you prefer a ShadowPlay-like UI then check out [GPU Screen Recorder UI](https://git.dec05eba.com/gpu-screen-recorder-ui/). Supported video codecs: * H264 (default) * HEVC (Optionally with HDR) * AV1 (Optionally with HDR. Not currently supported on NVIDIA in the flatpak version of GPU Screen Recorder) * VP8 * VP9 Supported audio codecs: * Opus (default) * AAC Supported image formats: * JPEG * PNG This software works on X11 and Wayland on AMD, Intel and NVIDIA. # Installation If you are running an Arch Linux based distro then you can find gpu screen recorder in the official repositories under the name gpu-screen-recorder (`sudo pacman -S gpu-screen-recorder`).\ If you are running another distro then you can run `sudo ./install.sh`, but you need to manually install the dependencies, as described below.\ You can also install gpu screen recorder ([the ui version](https://git.dec05eba.com/gpu-screen-recorder-gtk/)) from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder), which is the easiest method to install GPU Screen Recorder on non-arch based distros.\ If you install GPU Screen Recorder flatpak, which is the gtk gui version then you can still run GPU Screen Recorder command line by using the flatpak command option, for example `flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder -w screen -f 60 -o video.mp4`. Note that if you want to record your monitor on AMD/Intel then you need to install the flatpak system-wide (like so: `flatpak install --system com.dec05eba.gpu_screen_recorder`). ## Unofficial install methods The only official ways to install GPU Screen Recorder is either from source, arch linux extra repository or flathub. Other sources may be out of date and missing features or may not work correctly.\ If you install GPU Screen Recorder from somewhere else and have an issue then try installing it from one of the official sources before reporting it as an issue.\ If you still prefer to install GPU Screen Recorder with a package manager instead of from source or as a flatpak then you may be able to find a package for your distro.\ Here are some known unofficial packages: * Debian/Ubuntu: [Pacstall](https://pacstall.dev/packages/gpu-screen-recorder) * Nix: [NixOS wiki](https://wiki.nixos.org/wiki/Gpu-screen-recorder) * openSUSE: [openSUSE software repository](https://software.opensuse.org/package/gpu-screen-recorder) * Fedora, CentOS: [Copr](https://copr.fedorainfracloud.org/coprs/brycensranch/gpu-screen-recorder-git/) * OpenMandriva: [gpu-screen-recorder](https://github.com/OpenMandrivaAssociation/gpu-screen-recorder) * Solus: [gpu-screen-recorder](https://github.com/getsolus/packages/tree/main/packages/g/gpu-screen-recorder) * Nobara: [Nobara wiki](https://wiki.nobaraproject.org/en/general-usage/additional-software/GPU-Screen-Recorder) * AppImage [AppImage GitHub releases](https://github.com/pkgforge-dev/gpu-screen-recorder-AppImage/releases) * Void Linux: [gpu-screen-recorder](https://github.com/cherrybtw/gsr4xbps) # Dependencies GPU Screen Recorder uses meson build system so you need to install `meson` to build GPU Screen Recorder. ## Build dependencies These are the dependencies needed to build GPU Screen Recorder: * x11 (libx11, libxcomposite, libxrandr, libxfixes, libxdamage) * wayland (wayland-client, wayland-egl, wayland-scanner) * ffmpeg (libavcodec, libavformat, libavutil, libswresample, libavfilter) * libva (and libva-drm) * libpulse * libdrm * libcap * vulkan-headers * linux-api-headers ## Optional dependencies When building GPU Screen Recorder with portal support (`-Dportal=true` meson option, which is enabled by default) these dependencies are also needed: * libdbus * libpipewire (and libspa which is usually part of libpipewire) ## Runtime dependencies * libglvnd (which provides libgl, libglx and libegl) is needed. Your system needs to support at least OpenGL ES 3.0 (released in 2012) * vulkan-icd-loader (which provides the runtime vulkan library. This is only needed if vulkan video encoding option is used) * libturbojpeg (aka libjpeg-turbo) is needed when capturing camera with mjpeg pixel format option There are also additional dependencies needed at runtime depending on your GPU vendor: ### AMD * mesa * vaapi (libva-mesa-driver) ### Intel * mesa * vaapi (intel-media-driver/libva-intel-driver/linux-firmware-intel, depending on which intel GPU you have) ### NVIDIA * cuda runtime (libcuda.so.1) (libnvidia-compute) * nvenc (libnvidia-encode) * nvfbc (libnvidia-fbc1, when recording the screen on x11) # How to use Run `gpu-screen-recorder --help` to see all options and run `man gpu-screen-recorder` to see more detailed explanations for the options and also examples.\ There is also a gui for the gpu screen recorder called [GPU Screen Recorder GTK](https://git.dec05eba.com/gpu-screen-recorder-gtk/).\ There is also a new alternative UI for GPU Screen Recorder in the style of ShadowPlay called [GPU Screen Recorder UI](https://git.dec05eba.com/gpu-screen-recorder-ui/). ## Recording Here is an example of how to record your monitor and the default audio output: `gpu-screen-recorder -w screen -f 60 -a default_output -o ~/Videos/test_video.mp4`. Yyou can stop and save the recording with `Ctrl+C` or by running `pkill -SIGINT -f "^gpu-screen-recorder"`. You can see a list of capture options to record if you run `gpu-screen-recorder --list-capture-options`. This will list possible capture options and monitor names, for example:\ ``` window DP-1|1920x1080 ``` in this case you could record a window or a monitor with the name `DP-1`.\ To list available audio devices that you can use you can run `gpu-screen-recorder --list-audio-devices` and the name to use is on the left size of the `|`.\ To list available audio application names that you can use you can run `gpu-screen-recorder --list-application-audio`.\ You can run `gpu-screen-recorder --info` to list more information about the system, such as the device that is used for capture and video encoding and supported codecs. These commands can be parsed by scripts/programs. ## Replay mode Run `gpu-screen-recorder` with the `-c mp4` and `-r` option, for example: `gpu-screen-recorder -w screen -f 60 -r 30 -c mp4 -o ~/Videos`. Note that in this case, `-o` should point to a directory.\ If `-df yes` is set, replays are save in folders based on the date. The file path to the saved replay is output to stdout. All other output from GPU Screen Recorder are output to stderr. You can also use the `-sc` option to specify a script that should be run (asynchronously) when the video has been saved and the script will have access to the location of the saved file as its first argument. This can be used for example to show a notification when a replay has been saved, to rename the video with a title that matches the game played (see `scripts/record-save-application-name.sh` as an example on how to do this on X11) or to re-encode the video. The replay buffer is stored in ram (as encoded video) by default, so don't use a too large replay time and/or video quality unless you have enough ram to store it.\ You can use the `-replay-storage disk` option to store the replay buffer on disk instead of ram (in the same location as the output video).\ By default videos are recorded with constant quality, but with replay mode you might want to record in constant bitrate mode instead for consistent ram/disk usage in high motion scenes. You can do that by using the `-bm cbr` option (along with `-q` option, for example `-bm cbr -q 20000`). ## Streaming Streaming works the same way as recording, but the `-o` argument should be path to the live streaming service you want to use (including your live streaming key). Take a look at `scripts/twitch-stream.sh` to see an example of how to stream to twitch.\ GPU Screen Recorder uses Ffmpeg so GPU Screen Recorder supports all protocols that Ffmpeg supports.\ If you want to reduce latency one thing you can do is to use the `-keyint` option, for example `-keyint 0.5`. Lower value means lower latency at the cost of increased bitrate/decreased quality. ## Recording while using replay/streaming You can record a regular video while using replay/streaming by launching GPU Screen Recorder with the `-ro` option to specify a directory where to save the recording (for example: `gpu-screen-recorder -w screen -c mp4 -r 60 -o "$HOME/Videos/replays" -ro "$HOME/Videos/recordings"`).\ To start/stop (and save) recording use the SIGRTMIN signal, for example `pkill -SIGRTMIN -f "^gpu-screen-recorder"`. The path to the video will be displayed in stdout when saving the video.\ This way of recording while using replay/streaming is more efficient than running GPU Screen Recorder multiple times since this way it only records the screen and encodes the video once. ## Controlling GPU Screen Recorder remotely To save a video in replay mode, you need to send signal SIGUSR1 to gpu screen recorder. You can do this by running `pkill -SIGUSR1 -f "^gpu-screen-recorder"`.\ To stop recording send SIGINT to gpu screen recorder. You can do this by running `pkill -SIGINT -f "^gpu-screen-recorder"` or pressing `Ctrl-C` in the terminal that runs gpu screen recorder. When recording a regular non-replay video this will also save the video.\ To pause/unpause recording send SIGUSR2 to gpu screen recorder. You can do this by running `pkill -SIGUSR2 -f "^gpu-screen-recorder"`. This is only applicable and useful when recording (not streaming nor replay).\ There are more signals to control GPU Screen Recorder. Run `gpu-screen-recorder --help` to list them all (under `NOTES` section). ## Simple way to run replay without gui Run the script `scripts/start-replay.sh` to start replay and then `scripts/save-replay.sh` to save a replay and `scripts/stop-replay.sh` to stop the replay. The videos are saved to `$HOME/Videos`. You can use these scripts to start replay at system startup if you add `scripts/start-replay.sh` to startup (this can be done differently depending on your desktop environment / window manager) and then go into hotkey settings on your system and choose a hotkey to run the script `scripts/save-replay.sh`. Modify `scripts/start-replay.sh` if you want to use other replay options. ## Run replay on system startup If you installed GPU Screen Recorder from AUR or from source and you are running a distro that uses systemd then you will have a systemd service installed that can be started with `systemctl enable --now --user gpu-screen-recorder`. This systemd service runs GPU Screen Recorder on system startup.\ It's configured with `$HOME/.config/gpu-screen-recorder/gpu-screen-recorder.env` (create it if it doesn't exist). You can look at [extra/gpu-screen-recorder.env](https://git.dec05eba.com/gpu-screen-recorder/plain/extra/gpu-screen-recorder.env) to see an example. You can see which variables that you can use in the `gpu-screen-recorder.env` file by looking at the `extra/gpu-screen-recorder.service` file. Note that all of the variables are optional, you only have to set the ones that are you interested in. You can use the `scripts/save-replay.sh` script to save a replay and by default the systemd service saves videos in `$HOME/Videos`. ## Run a script when a video is saved Run `gpu-screen-recorder` with the `-sc` option to specify a script that should be run when a recording/replay a saved, for example `gpu-screen-recorder -w screen -sc ./script.sh -o video.mp4`.\ The first argument to the script is the file path to the saved video. The second argument is either "regular" for regular recordings, "replay" for replays or "screenshot" for screenshots.\ This can be used to for example showing a notification with the name of video or moving a video to a folder based on the name of the game that was recorded. ## Plugins GPU Screen Recorder supports plugins for rendering additional graphics on top of the monitor/window capture. The plugin interface is defined in `plugin/plugin.h` and it gets installed to `gsr/plugin.h` in the systems include directory (usually `/usr/include`). An example plugin can be found at `plugin/examples/hello_triangle`.\ Run `gpu-screen-recorder` with the `-p` option to specify a plugin to load, for example `gpu-screen-recorder -w screen -p ./triangle.so -o video.mp4`. `-p` can be specified multiple times to load multiple plugins.\ Build GPU Screen Recorder with the `-Dplugin_examples=true` meson option to build plugin examples. ## Smoother recording If you record at your monitors refresh rate and enabled vsync in a game then there might be a desync between the game updating a frame and GPU Screen Recorder capturing a frame. This is an issue in some games. If you experience this issue then you might want to either disable vsync in the game or use the `-fm content` option to sync capture to the content on the screen. For example: `gpu-screen-recorder -w screen -fm content -o video.mp4`.\ Note that this option is currently only available on X11, or with desktop portal capture on Wayland (`-w portal`). # Performance On a system with an i5 4690k CPU and a GTX 1080 GPU:\ When recording Legend of Zelda Breath of the Wild at 4k, fps drops from 30 to 7 when using OBS Studio + nvenc, however when using this screen recorder the fps remains at 30.\ When recording GTA V at 4k on highest settings, fps drops from 60 to 23 when using obs-nvfbc + nvenc, however when using this screen recorder the fps only drops to 58.\ On a system with an AMD Ryzen 9 5900X CPU and an RX 7800XT GPU I don't see any fps drop at all, even when recording at 4k 60fps with AV1 codec with 10-bit colors.\ GPU Screen Recorder also produces much smoother videos than OBS when GPU utilization is close to 100%, see comparison here: [https://www.youtube.com/watch?v=zfj4sNVLLLg](https://www.youtube.com/watch?v=zfj4sNVLLLg) and [https://www.youtube.com/watch?v=aK67RSZw2ZQ](https://www.youtube.com/watch?v=aK67RSZw2ZQ).\ GPU Screen Recorder has much better performance than OBS Studio even with version 30.2 that does "zero-copy" recording and encoding, see: [https://www.youtube.com/watch?v=jdroRjibsDw](https://www.youtube.com/watch?v=jdroRjibsDw).\ It is recommended to save the video to a SSD because of the large file size, which a slow HDD might not be fast enough to handle. Using variable framerate mode (-fm vfr) which is the default is also recommended as this reduces encoding load. Ultra quality is also overkill most of the time, very high (the default) or lower quality is usually enough.\ Note that for best performance you should close other screen recorders such as OBS Studio when using GPU Screen Recorder even if they are not recording, since they can affect performance even when idle. This is the case with OBS Studio. ## Note about optimal performance on NVIDIA NVIDIA driver has a "feature" (read: bug) where it will downclock memory transfer rate when a program uses cuda (or nvenc, which uses cuda), such as GPU Screen Recorder. This can affect game performance. GPU Screen Recorder installs an NVIDIA profile on the system (`~/.nv/nvidia-application-profiles-rc.d/10-gsr-cuda-no-stable-perf-limit`) to get around this issue but this requires a relatively new NVIDIA driver version (580+). If you have an older NVIDIA driver then you can choose to record with vulkan video encoding instead as it doesn't have this issue. You can use vulkan video encoding by adding `_vulkan` at the end of the video codec option, for example: `-k h264_vulkan` or a full command example: `gpu-screen-recorder -w screen -k h264_vulkan -o video.mp4`. Vulkan video encoding in GPU Screen Recorder supports `h264`, `hevc` and `av1` (along with `hdr` and `10bit` options), assuming your gpu drivers, ffmpeg and vulkan is up to date. Note: vulkan video encoding support is experimental and you may experience GPU Screen Recorder or gpu driver bugs with it. # Issues ## NVIDIA NVIDIA drivers have an issue where CUDA breaks if CUDA is running when suspend/hibernation happens, and it remains broken until you reload the nvidia driver. `extra/gsr-nvidia.conf` will be installed by default when you install GPU Screen Recorder and that should fix this issue. If this doesn't fix the issue for you then your distro may use a different path for modprobe files. In that case you have to install that `extra/gsr-nvidia.conf` yourself into that location. You have to reboot your computer after installing GPU Screen Recorder for the first time for the fix to have any effect. Note: this issue doesn't happen when you using the vulkan video encoding option (for example when using `-k h264_vulkan`). ## TEMPORARY ISSUES 1) Videos are in variable framerate format. Use MPV to play such videos, otherwise you might experience stuttering in the video if you are using a buggy video player. You can try saving the video into a .mkv file instead as some software may have better support for .mkv files (such as kdenlive). You can use the "-fm cfr" option to to use constant framerate mode. 2) FLAC audio codec is disabled at the moment because of temporary issues. # Examples Look at the [scripts](https://git.dec05eba.com/gpu-screen-recorder/tree/scripts) directory for script examples. For example if you want to automatically save a recording/replay into a folder with the same name as the game you are recording. # AMD/Intel/Wayland root permission When recording a window or when using the `-w portal` option no special user permission is required, however when recording a monitor the program needs root permission (to access KMS).\ This is safe in GPU Screen Recorder as the part that needs root access has been moved to its own small program that only does one thing.\ For you as a user this only means that if you installed GPU Screen Recorder as a flatpak then a prompt asking for root password will show up once when you start recording. # VRR/G-SYNC This should work fine on AMD/Intel X11 or Wayland. On Nvidia X11 G-SYNC only works with the -w screen-direct option, but because of bugs in the Nvidia driver this option is not always recommended. For example it can cause your computer to freeze when recording certain games. # License This software is licensed under GPL-3.0-only, see the LICENSE file for more information. # Reporting bugs, contributing patches, questions or donation See [https://git.dec05eba.com/?p=about](https://git.dec05eba.com/?p=about). # Demo [![Click here to watch a demo video on youtube](https://img.youtube.com/vi/n5tm0g01n6A/0.jpg)](https://www.youtube.com/watch?v=n5tm0g01n6A) # FAQ ## It tells me that my AMD/Intel GPU is not supported or that my GPU doesn't support h264/hevc, but that's not true! Some linux distros (such as manjaro and fedora) disable hardware accelerated h264/hevc on AMD/Intel because of "patent license issues". If you are using an arch-based distro then you can install mesa-git instead of mesa and if you are using another distro then you may have to switch to a better distro. On fedora based distros you can follow this: [Hardware Accelerated Codec](https://rpmfusion.org/Howto/Multimedia).\ You can alternatively install the flatpak version of GPU Screen Recorder from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder) which doesn't have this issue on any distro. ## I have an old nvidia GPU that supports nvenc but I get a cuda error when trying to record Newer ffmpeg versions don't support older nvidia cards. Try installing GPU Screen Recorder flatpak from [flathub](https://flathub.org/apps/details/com.dec05eba.gpu_screen_recorder) instead. It comes with an older ffmpeg version which might work for your GPU. ## I get a black screen/glitches while live streaming It seems like ffmpeg earlier than version 6.1 has some type of bug. Install ffmpeg version 6.1 or later and then reinstall GPU Screen Recorder to fix this issue. The flatpak version of GPU Screen Recorder comes with a newer version of ffmpeg so no extra steps are needed. ## I can't play the video in my browser directly or in discord Browsers and discord don't support hevc video codec at the moment. You can instead choose h264 video codec with the -k h264 option or av1 video codec with the -k av1 option. Note that websites such as youtube support hevc so there is no need to choose h264 video codec if you intend to upload the video to youtube or if you want to play the video locally or if you intend to edit the video with a video editor. Hevc allows for better video quality (especially at lower file sizes) so hevc (or av1) is recommended for source videos. ## I get a black bar/distorted colors on the sides in the video This is mostly an issue on AMD. For av1 it's a hardware issue, see: https://gitlab.freedesktop.org/mesa/mesa/-/issues/9185. For hevc it's a software issue in ffmpeg that was fixed in ffmpeg version 8.\ If your ffmpeg version is older than 8 then you can use the flatpak version of GPU Screen Recorder which comes with ffmpeg version >= 8.\ Alternatively you can record with h264 codec (-k h264, which is also the default codec) to workaround this issue. ## The video doesn't display or has a green/yellow overlay This can happen if your video player is missing the H264/HEVC video codecs. Either install the codecs or use mpv. ## I get stutter in the video Try recording to an SSD and make sure it's not using NTFS file system. Also try recording with "content" framerate mode (`-fm content`). ## The colors look washed out when recording a monitor with HDR enabled You have to either record in hdr mode (-k `hevc_hdr` or -k `av1_hdr` option) to record a HDR video or record with desktop portal option (`-w portal`) to turn the HDR recording into SDR. ## GPU Screen Recorder records night light when recording in HDR mode You can record with desktop portal option (`-w portal`) instead which ignores night light, if you are ok with recording without HDR. ## Kdenlive says that the video is not usable for editing because it has variable frame rate To fix this you can either just press cancel, which will allow you to continue or record the video in .mkv format or constant frame rate (-fm cfr). I recommend recording the video in .mkv format and variable frame rate (-fm vfr). ## Colors look incorrect when recording HDR (with hevc_hdr/av1_hdr) or using an ICC profile KDE Plasma version 6.2 broke HDR and ICC profiles for screen recorders. This was changed in KDE plasma version 6.3 and recording HDR works now, as long as you set HDR brightness to 100% (which means setting "Maximum SDR Brightness" in KDE plasma display settings to 203) and set color accuracy to "Prefer color accuracy". If you want to convert HDR to SDR then record with desktop portal option (`-w portal`) instead. I don't know how well recording HDR works in wayland compositors other than KDE plasma. ## GPU Screen Recorder starts lagging after 30-40 minutes when launching GPU Screen Recorder from steam command launcher This is a [steam issue](https://github.com/ValveSoftware/steam-for-linux/issues/11446). Prepend the gpu-screen-recorder command with `LD_PREFIX=""`, for example `LD_PREFIX="" gpu-screen-recorder -w screen -o video.mp4`. ## How do I apply audio effects, such as noise suppression? You have to use external software for that, such as Easy Effects or NoiseTorch. ## How do I choose which GPU to record/encode with? It's not really possible except in some cases. You can only record with the GPU that is displaying the graphics on your monitor.\ Some laptops have display adapters that connect external monitors directly to the external GPU (if you have one) and on Wayland the external GPU will display the graphics for that monitor. In that case you can record the monitor with the external GPU by launching GPU Screen Recorder with [prime-run or by setting the DRI_PRIME environment variable](https://wiki.archlinux.org/title/PRIME) depending on your GPU brand. Alternatively you can capture with the desktop portal option (`-w portal`), which should allow you to capture any monitor.\ However if you really want to change which GPU you want to record and encode with with then you can instead configure your display server (Xorg or Wayland compositor) to run with that GPU, then GPU Screen Recorder will automatically use that same GPU for recording and encoding. ## The rotation of the video is incorrect when the monitor is rotated when using desktop portal capture This is a bug in kde plasma wayland. When using desktop portal capture and the monitor is rotated and a window is made fullscreen kde plasma wayland will give incorrect rotation to GPU Screen Recorder. This also affects other screen recording software such as obs studio.\ Capture a monitor directly instead to workaround this issue until kde plasma devs fix it, or use another wayland compositor that doesn't have this issue. ## System notifications get disabled when recording with desktop portal option Some desktop environments such as KDE Plasma turn off notifications when you record the screen with the desktop portal option. You can disable this by going into KDE Plasma settings -> search for notifications and then under "Do Not Disturb mode" untick "During screen sharing". ## The recorded video lags or I get dropped frames in the video This is likely not an issue in the recorded video itself, but the video player you use. GPU Screen Recorder doesn't record by dropping frames. Some video players don't play videos with hardware acceleration by default, especially if you record with HEVC/AV1 video codec. In such cases it's recommended to play the video with mpv instead with hardware acceleration enabled (for example: `mpv --vo=gpu --hwdec=auto video.mp4`). Some corporate distros such as Fedora (or some Fedora based distros) also disable hardware accelerated video codecs on AMD/Intel GPUs, so you might need to install mpv (or another video player) with flathub instead, which bypasses this restriction. ## My cursor is flickering in the recorded video This is likely an AMD gpu driver issue. It only happens to certain generations of AMD GPUs. On Wayland you can record with the desktop portal option (`-w portal`) to workaround this issue. This issue hasn't been observed on X11 yet, but if you do observe it you can either record a window (`-w $(xdotool selectwindow)`) or change your xorg config to use software cursor instead (Add `Option "SWcursor" "true"` under modesetting "Device" section in your xorg config file). ## Password prompt shows up when I try to record my screen If GPU Screen Recorder is installed with -Dcapabilities=true (which is the default option) then `gsr-kms-server` is installed with admin capabilities. This removes a password prompt when recording a monitor with the `-w monitor` option (for example `-w screen`). However if the root user is disabled on the system then the password prompt will show up anyways. If the root user is disabled on your system then you can instead record with `-w focused` or `-w window_id` on X11 or `-w portal` on Wayland. ## CPU/GPU usage is high CPU/GPU usage can be misleading. CPUs/GPUs have multiple power/performance levels and the CPU/GPU usage reported on the system may be the CPU/GPU usage at the current performance level. The performance level changes depending on the CPU/GPU load, so it may say that CPU/GPU usage is 80%, but the actual total CPU/GPU usage may be 5%. The only way to properly test the performance of GPU Screen Recorder is to use it while recording a game and seeing the effect on the games framerate. ## The video is too dark when capturing full-range video or 10-bit video This is an issue in some broken video players such as vlc. Play the video with a video player such as mpv (or a mpv frontend such as celluloid) or a browser instead. ## The video has glitches This may be caused by buggy GPU drivers. Try recording with HEVC video codec instead (`-k hevc`). ## The quality is low when recording my desktop Color gradients encode badly, especially with h264 video codec. You can increase the bitrate, for example by using `-bm cbr -q 30000` or by using hevc (`-k hevc`) and increasing the quality (`-q ultra`). fsdsfdsfdsfdsf-5.13.8/TODO000066400000000000000000000767431520215207700153160ustar00rootroot00000000000000Check for reparent. Quickly changing workspace and back while recording under i3 breaks the screen recorder. i3 probably unmaps windows in other workspaces. See https://trac.ffmpeg.org/wiki/EncodingForStreamingSites for optimizing streaming. Look at VK_EXT_external_memory_dma_buf. Use mov+faststart. Allow recording all monitors/selected monitor without nvfbc by recording the compositor proxy window and only recording the part that matches the monitor(s). Disable flipping on nvidia? this might fix some stuttering issues on some setups. See NvCtrlGetAttribute/NvCtrlSetAttributeAndGetStatus NV_CTRL_SYNC_TO_VBLANK https://github.com/NVIDIA/nvidia-settings/blob/d5f022976368cbceb2f20b838ddb0bf992f0cfb9/src/gtk%2B-2.x/ctkopengl.c. Cleanup unused gl/egl functions, macro, etc. Reverse engineer nvapi so we can disable "force p2 state" on linux too (nvapi profile api with the settings id 0x50166c5e). Support yuv444p on amd/intel. fix yuv444 for hevc. Do not allow streaming if yuv444. Re-enable yuv444 and allow yuv444 for software encoding. Good for remote desktop. But for remote desktop its more ideal to use yuv420 and when the image is not moving then send a png image instead, for clear image when the image is static. Support 10 bit output because of better gradients. May even be smaller file size. Better supported on hevc (not supported at all on h264 on my gpu). Add nvidia/(amd/intel) specific install script for ubuntu. User should run install_ubuntu.sh but it should run different install dep script depending on if /proc/driver/nvidia/version exists or not. But what about switchable graphics setup? Test different combinations of switchable graphics. Intel hybrid mode (running intel but possible to run specific applications with prime-run), running pure intel. Detect switchable graphics. https://web.archive.org/web/20210306020203/https://forums.developer.nvidia.com/t/performance-power-management-problem-on-shared-vgpu/161986 https://djdallmann.github.io/GamingPCSetup/CONTENT/RESEARCH/FINDINGS/registrykeys_displayadapter_class_4d36e968-e325-11ce-bfc1-08002be10318.txt The video output will be black if if the system is suspended on nvidia and NVreg_PreserveVideoMemoryAllocations is not set to 1. This happens because I think that the driver invalidates textures/cuda buffers? To fix this we could try and recreate gsr capture when gsr_capture_capture fails (with timeout to retry again). NVreg_RegistryDwords. Window capture doesn't work properly in _control_ game after going from pause menu to in-game (and back to pause menu). There might be some x11 event we need to catch. Same for vr-video-player. Monitor capture on steam deck is slightly below the game fps, but only when capturing on the steam deck screen. If capturing on another monitor, there is no issue. Is this related to the dma buf rotation issue? different modifier being slow? does this always happen? Intel is a bit weird with monitor capture and multiple monitors. If one of the monitors is rotated then all the kms will be rotated as well. Is that only the case when the primary monitor is rotated? Also the primary monitor becomes position 0, 0 so crtc (x11 randr) position doesn't match the drm pos. Maybe get monitor position and size from drm instead. How about if multiple monitors are rotated? Support screen (all monitors) capture on amd/intel and nvidia wayland when no combined plane is found. Right now screen just takes the first output. Use separate plane (which has offset and pitch) from combined plane instead of the combined plane. Both twitch and youtube support variable bitrate but twitch recommends constant bitrate to reduce stream buffering/dropped frames when going from low motion to high motion: https://help.twitch.tv/s/article/broadcasting-guidelines?language=en_US. Info for youtube: https://support.google.com/youtube/answer/2853702?hl=en#zippy=%2Cvariable-bitrate-with-custom-stream-keys-in-live-control-room%2Ck-p-fps%2Cp-fps. On nvidia some games apparently causes the game to appear to stutter (without dropping fps) when recording a monitor but not using when using direct screen capture. Observed in Deus Ex and Apex Legends. Capture is broken on amd on wlroots. It's disabled at the moment and instead uses kms capture. Find out why we get a black screen in wlroots. Support vulkan video encoding. That might workaround forced p2 state nvidia driver "bug". Ffmpeg supports vulkan video encoding if it's encoding with --enable-vulkan It may be possible to improve color conversion rgb->yuv shader for color edges by biasing colors to an edge, instead of letting color overlaying with bilinear filtering handle it. When webcam is supported mention that nvidia_drm.modeset=1 must be set on nvidia x11 (it's required on wayland so it's not needed there. Or does eglstream work without it??). Check if this really is the case. Support green screen removal, cropping, shader effects in general (circle mask, rounded corners, etc). Preset is set to p5 for now but it should ideally be p6 or p7. This change is needed because for certain sizes of a window (or monitor?) such as 971x780 causes encoding to freeze when using h264 codec. This is a new(?) nvidia driver bug. Maybe dont choose p6 or p7 again? it causes micro stutter for some users (?). For low latency, see https://developer.download.nvidia.com/compute/nvenc/v4.0/NVENC_VideoEncoder_API_ProgGuide.pdf (section 7.1). Remove follow focused option. Exit if X11/Wayland killed (if drm plane dead or something?) Test if p2 state can be worked around by using pure nvenc api and overwriting cuInit/cuCtxCreate* to not do anything. Cuda might be loaded when using nvenc but it might not be used, with certain record options? (such as h264 p5). nvenc uses cuda when using b frames and rgb->yuv conversion, so convert the image ourselves instead.- Drop frames if live streaming cant keep up with target fps, or dynamically change resolution/quality. Instead of sending a big list of drm data back to kms client, send the monitor we want to record to kms server and the server should respond with only the matching monitor, and cursor. Tonemap hdr to sdr when hdr is enabled and when hevc_hdr/av1_hdr is not used. Rotate cursor texture properly (around top left origin). Modify ffmpeg to accept opengl texture for nvenc encoding. Removes extra buffers and copies. When vulkan encode is added, mention minimum nvidia driver required. (550.54.14?). Investigate if there is a way to do gpu->gpu copy directly without touching system ram to enable video encoding on a different gpu. On nvidia this is possible with cudaMemcpyPeer, but how about from an intel/amd gpu to an nvidia gpu or the other way around or any combination of iGPU and dedicated GPU? Maybe something with clEnqueueMigrateMemObjects? on AMD something with DirectGMA maybe? Use lanczos resampling for better scaling quality. Lanczos resampling can also be used for YUV chroma for better color quality on small text. Flac is disabled because the frame sizes are too large which causes big audio/video desync. Enable b-frames. Support vfr matching games exact fps all the time. On x11 use damage tracking, on wayland? maybe there is drm plane damage tracking. But that may not be accurate as the compositor may update it every monitor hz anyways. On wayland maybe only support it for desktop portal + pipewire capture. Another method to track damage that works regardless of the display server would be to do a diff between frames with a shader. A 1x1 texture could be created and then write to the texture with imageStore in glsl. Multiple textures aren't needed for diff, the diff between the color conversion output can be done by using it as an input as well, which would diff it against the previous frame. Support selecting which gpu to use. This can be done in egl with eglQueryDevicesEXT and then eglGetPlatformDisplayEXT. This will automatically work on AMD and Intel as vaapi uses the same device. On nvidia we need to use eglQueryDeviceAttribEXT with EGL_CUDA_DEVICE_NV. Maybe on glx (nvidia x11 nvfbc) we need to use __NV_PRIME_RENDER_OFFLOAD, __NV_PRIME_RENDER_OFFLOAD_PROVIDER, __GLX_VENDOR_LIBRARY_NAME, __VK_LAYER_NV_optimus, VK_ICD_FILENAMES instead. Just look at prime-run /usr/bin/prime-run. Add option to send video to another computer. New gpu screen recorder gui should have the option to cut the video directly, maybe running an ffmpeg command or implementing that ourselves. Only support gpu screen recorder video files. Check if is software renderer by using eglQueryDisplayAttribEXT(egl_display, EGL_DEVICE_EXT..) eglQueryDeviceStringEXT(egl_device, EGL_EXTENSIONS) and check for "EGL_MESA_device_software". Use MapTexture2DINTEL for software encoding on intel. To test vulkan encode on amd set the environment variable RADV_PERFTEST=video_encode before running a program that uses vulkan encode (or queries for it, such as vulkaninfo). Support hevc/av1 for software encoder and hdr support at the same time. Need support for yuv420p shader for that. Use libx265 for hevc and libsvtav1 for av1 (libsvtav1 is the fastest software av1 video encoder). Also support vp8/vp9 since we are not limited by hardware. Cleanup pipewire code and add more error checks. Make dbus code and pipewire setup non blocking. Support portal (pipewire) hdr capture when pipewire adds support for it. Maybe use the result of SelectSources and then query the hdr metadata with drm. HDR support on x11? Move most kms data to kms client. We dont need root access for everything that is server from kms server right now, such as hdr metadata and drm plane properties. Only the drm plane fd really needs root access. Show rotated window size in monitor list when using incorrect monitor name. Desktop portal capture on kde plasma makes notifications not show up unless the notification is set as urgent. How to fix this? do we have to make our own notification system? Explicit sync is done with the drm property IN_FENCE_FD (see https://drmdb.emersion.fr/properties/4008636142/IN_FENCE_FD). Check if this needs to be used on wayland (especially on nvidia) when capturing a monitor directly without desktop portal. The update fps appear to be lower when recording a monitor instead of using portal on intel. Does this reflect in game framerate? Fix glitches when using prime-run with desktop portal. It happens when moving a window around. It's probably a syncing issue. Allow prime-run on x11 if monitor capture and the prime gpu is not nvidia. Enable 2-pass encoding. Restart replay/update video resolution if monitor resolution changes. Use nvidia low latency options for better encoding times. Test ideal async_depth value. Increasing async_depth also increased gpu memory usage a lot (from 100mb to 500mb when moving from async_depth 2 to 16) at 4k resolution. Setting it to 8 increases it by 200mb which might be ok. Replace -encoder cpu with -k h264_software? Change vp8/vp9 quality options, right now the file size is too large (for vp9 at least at very_high quality). Support recording while in replay mode. This will be needed when enabling replay on system startup with systemd service and wanting to record a video besides that. The harder and more bloat solution for this would be to make an IPC. The simple solution would be to use SIGUSR2 for starting/stopping recording since SIGUSR2 is unused for replays. That would mean SIGUSR2 for pausing recording would be ignored. It also means that the video will be created in the same directory as the replay (or have option to specify another location for that) but the filename would have to be generated automatically. To rename the file you would have to use -sc to rename it with a script, or add an option to provide a template for the name. Dynamically change bitrate/resolution to match desired fps. This would be helpful when streaming for example, where the encode output speed also depends on upload speed to the streaming service. Implement opengl injection to capture texture. This fixes VRR without having to use NvFBC direct capture and also allows perfect frame timing. Always use direct capture with NvFBC once the capture issue in mpv fullscreen has been resolved (maybe detect if direct capture fails in nvfbc and switch to non-direct recording. NvFBC says if direct capture fails). Support ROI (AV_FRAME_DATA_REGIONS_OF_INTEREST). Default to hevc if capture size is larger than 4096 in width or height. Set low latency mode on vulkan encoding. Support recording/replay/livestreaming at the same time by allowing commands to be run on an existing gpu screen recorder instance. Test if `xrandr --output DP-1 --scale 1.5` captures correct size on nvidia. Fix cursor position and scale when scaling x11 display. Support application audio recording without pipewire combined sink. Support transposing (rotating) with vaapi. This isn't supported on many devices with rgb buffer, but its supported with nv12 buffer (on intel at least). Cleanup pipewire_audio.c (proper error handling and memory cleanup of proxies). Hide application audio module-null-sink by using sink_properties=media.class="Audio/Sink/Internal". Improve software encoding performance. Add option to record audio from the recorded window only. Add option to automatically select best video codec available. Add -k best, -k best_10bit and -k best_hdr. Use wayland color management protocol when it's available: https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/14. Use different exit codes for different errors. Use one for invalid -w option, another one for invalid -a option for audio devices, etc. This is to make UI error reporting better. Document these exit codes in an exit code .md file, or finally create a manpage where this can be documented. Use opengl compute shader instead of graphics shader. This might allow for better performance when games are using 100% of graphics unit which might fix issue with 100% gpu usage causing gpu screen recorder to run slow when not using vaapi to convert rgb to nv12(?). Always disable prime run/dri prime and list all monitors to record from from all cards. Do this instead of adding an option to choose which gpu to use. On X11 the primary gpu will always have the framebuffer for all monitors combined. Use randr to list all monitors and always record and encode with the primary gpu. On Wayland each gpu will have its own list of monitors with framebuffers. Iterate through all cards with drm and list all monitors with associated framebuffers and when choosing a monitor to record automatically use the associated gpu card. Allow flv av1 if recent ffmpeg version and streaming to youtube (and twitch?) and for custom services. Use explicit sync in pipewire video code: https://docs.pipewire.org/page_dma_buf.html. Replay (and recording?) fails to save properly sometimes (especially for long videos). This is noticable with mp4 files since they get corrupt and become unplayable. The entire video does seem to get saved (it's a large video file) and it seems to have the correct headers but it's not playable. Make it possible to save a shorter replay clip remotely. Maybe implement ipc first, to then also allow starting recording/stream while a replay is running. Add an option to pass http headers when streaming. Some streaming services require streaming keys to be passed in a http header instead of in the url as a parameter. When adding vulkan video support add VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR. Implement screenshot without invoking opengl (which is slow to start on some systems). Automatically use desktop portal on wayland when hdr is enabled (or night light) by checking if kms hdr metadata exists, if hdr video codec is not used. Or maybe do this in the ui? Detect if cached portal session token is no longer valid (this can happen if the user switches to another wayland compositor). Support reconnecting (and setting things up again) if the audio server is restarted (for both device recording and app recording). Find out how nvidia-smi fixes nvenc not working on opensuse and do that ourselves instead of relying on nvidia-smi that is not always installed. Pulseaudio code: add "running" variable to loops to allow stopping the running code when quitting. Scale screenshot frame libswscale or implement lanczos shader for improved scaline for video as well. Support high quality scaling with -s by using lanczos. Support spanning multiple monitors with region capture. This would also allow the user to record multiple monitors at the same time, the same way screen-direct works on nvidia x11. When webcam support is added also support v4l2loopback? this is done by using avdevice_register_all(); and -c v4l2 -o /dev/video0; but it needs to output raw data as well instead of h264 and possibly yuv420p. Maybe add a -k yuv420p option to do that or -k rgb. This would be implemented by outputting the raw data directly into the output file, without using the video encoder. Do proper exit, to call gsr_capture_destroy which will properly stop gsr-kms-server. Otherwise there can be zombie gsr-kms-server on error. Cursor position might be slightly wrong on rotated monitor. External texture doesn't work on nvidia x11, probably because of glx context (requires gles es). External texture is not used on nvidia x11 right now so it's not an issue. Add option to save replay buffer on disk instead of ram. nvfbc capture cursor with cursor.h instead and composite that on top. This allows us to also always get a cursor in direct capture mode. This could possible give better performance as well. Maybe remove external shader code and make a simple external to internal texture converter (compute shader), to reduce texture sampling. Maybe this is faster? Fix opengl context broken after suspend on nvidia by using this: https://registry.khronos.org/OpenGL/extensions/NV/NV_robustness_video_memory_purge.txt requires glx context creation flags and GetGraphicsResetStatusARB() == PURGED_CONTEXT_RESET_NV check to recreate all graphics. HDR looks incorrect, brightest point gets cut off. Make "screen" capture the preferred monitor. When webcam support is added add the option to add it as a second video track, to make it easier to edit in video editors. Fix constant framerate not working properly on amd/intel because capture framerate gets locked to the same framerate as game framerate, which doesn't work well when you need to encode multiple duplicate frames (AMD/Intel is slow at encoding!). It also appears to skip audio frames on nvidia wayland? why? that should be fine, but it causes video stuttering because of audio/video sync. Add option to pass a fd (from socketpair) to use for rpc. In the rpc have a common header, with protocol version, data type and data in an enum. Add the option to set audio track name, for example with -a "track-name:blabla|device:default_output|app:firefox" Maybe disable qp/vbr for replay. In that case we can preallocate all replay data (for both ram and disk) and write to that directly when receiving packet (dont do that when also recording at the same time). That could improve performance/disk write optimization and maybe even reduce ram usage because of less blocks/fragmentation. When rpc is added add the option to add/remove audio devices/app audio and also overlays (from new capture sources). It should also be possible to save a replay of any duration (below duration set with -r). Have an rpc info/status command that just returns the status. This is to check if gpu screen recorder is running. Support hdr screenshot. Recreate opengl context on loss. This can happen if there is a gpu driver bug, causing context to need to be recreated. This is a nice improvement to not break recording even with buggy driver. Support saving video with surround sound. Surround sound audio capture does work, but it gets downmixed to stereo. Add (render) plugin support. To simplify it (and possibly best performance) create one rgba texture (with the size of the output video) that is used across all plugins. Create a framebuffer and set this texture and the target and set the framebuffer as active before calling the plugins. Then the plugins can render simply by doing simple opengl draw functions. Maybe send some metadata to the plugin, such as video (and framebuffer) size. Although this data can be retrieved from the active framebuffer. Either support webcam support with raw yuyv, mapping the buffer directly to opengl. Or use mjpeg, mapping the buffer directly to vaapi jpeg decoder and then get then map the decoded buffer to opengl. Some webcams dont support raw yuyv and many webcams support higher framerates for mjpeg. Allow medium, high, very_high and ultra quality for -bm cbr. If that is used then it will automatically estimate the best bitrate for that quality based on resolution and fps. Maybe do this in the ui instead (or both?), to show estimated file size. Maybe remove shader compute code. It doesn't seem necessary anymore now that glSwapBuffer/glFinish isn't used. dbus server isn't needed anymore either, the code can be moved back to the gpu screen recorder process. Add proper check if opengl functions are supported. dlsym for the symbol will return a no-op function if it's not supported, so it silently fails if used. Colors are offset to bottom left by 1 pixel or so on steam deck in landscape mode. When constant framerate is used (and for audio) multiple frames need to be encoded after resuming from suspend. The clock jumps forward by around 2-3 seconds (on my machine). Is there a way to make sure the clock doesn't jump forward? Colors are correct, but they look incorrect for thin elements, such as colored text. This can be improved by sampling neighbor pixels for color average. Record first video/audio frame immediately. Disable GL_DEPTH_TEST, GL_CULL_FACE. kde plasma portal capture for screenshot doesn't work well because the portal ui is still visible when taking a screenshot because of its animation. We can use dri2connect/dri3open to get the /dev/dri/card device. Note that this doesn't work on nvidia x11. Add support for QVBR (QP with target bitrate). Maybe use VBR instead, since nvidia doesn't support QVBR and neither does vulkan. KDE Plasma Wayland seems to use overlay planes now in non-fullscreen mode(limited to 1 overlay plane per gpu). Check if this is the case in the latest kde on arch linux. If it is, then support it in kms capture. Check if pipewire audio link-factory is available before attempting to use app audio or merging audio with pipewire. Also do the same in supports_app_audio check in gpu-screen-recorder --info output. Move region capture to an option in the color conversion instead of having the region code in kms capture code. This would make it cleaner and make it work with all capture methods. -w region would just be an option for selecting the monitor and -region would work with all capture methods (-w). Set top level window argument for portal capture. Same for gpu-screen-recorder-gtk global shortcuts. Remove unix domain socket code from kms-client/server and use socketpair directly. To make this possible always execute the kms server permission setup in flatpak, before starting recording (in gpu-screen-recorder-gtk). Add -k best/best_hdr/best_10bit option, to automatically choose the best codec (prefer av1, then hevc and then h264. For webm files choose vp9 and then vp8). Check if region capture works properly with fractional scaling on wayland. Add option to specify medium/high/very high/ultra for -bm cbr as well, which should automatically pick bitrate based on resolution and framerate. This should also be reflected in gsr ui. After adding rpc, making recording while in replay/streaming work differently. Start recording should take audio as an argument, to optionally specify different audio for recording than replay/stream. After adding rpc, make it possible to add/remove audio and video. The same number of audio tracks should remain, but the audio devices/app should be possible to configure. You should be able to configure the capture sources however you want. It takes a while to shutdown gpu screen recorder when using replay with a long replay time (when the replay buffer is for example 6gb). Maybe this has to do with cleaning up so much memory. Try if _exit(0) is faster, ignoring cleanup of anything (assuming the gpu driver is happy with that, nvidia doesn't like such things. GPU drivers are often buggy when it comes to automatic cleanup). Support desktop portal hdr capture when this gets merged: https://invent.kde.org/plasma/kwin/-/merge_requests/8293 note that it only works with pipewire >= 1.5.81. If codec is set to non-hdr codec when use desktop portal without hdr (convert to sdr, remove the code that forces non-hdr equivalent of the codec). Update gsr-gtk and gsr-ui accordingly. Add option to save screenshot as .qoi. Use that then in gsr-ui for the background for the window (capture the monitor that the ui is going to show on). Do that on cosmic and hyprland, which are unable to display things behind the fullscreen window. Support pausing recording when recording while replay/streaming. Maybe use VK_VALVE_video_encode_rgb_conversion with vulkan encoding for shader-less rgb to yuv conversion. That would allow screen capture with no gpu processing. Cursor sometimes doesn't have color when capturing region scaled (on kde plasma wayland at least). Remove drm_monitor_get_display_server_data and do that work in the drm monitor query. In gpu screen recorder --info output codec max resolutions. This allows for better error messages in ui frontends and easier and better error handling. Set minimum fps for live stream or piping or always. Support youtube sso. Remove -fm content (support it but remove it from documentation and output deprecation notice when its used) and use it when using -fm vbr (which is the default option). But first -fm content needs to be support on wayland as well, by checking if there is a difference between frames (checksum the frame content). -fm content also needs to have a minimum fps to prevent live stream from timing out when nothing changes on the screen. There is a leak in nvfbc. When a monitor is turned off and then on there will be an x11 display leak inside nvfbc. This seems to be a bug in nvfbc. Right now a mitigation has been added to not try to recreate the nvfbc session if the capture target (monitor) isn't connected (predict if nvfbc session create will fail). One possible reason this happens is because bExternallyManagedContext is set to true. This also means that nvfbc leaks connection when destroying nvfbc, even if the monitor is connected (this is not an issue right now because exit is done, but if gsr was turned into a library it would be). Add option to set audio source volume, maybe by doing for example: -a "default_input|app:firefox;volume=50" Optimize v4l2 mjpeg by decompressing to yuv (tjDecompressToYUV) instead of rgb. This would allow removing the yuv to rgb conversion on cpu step (and rgb to yuv on the gpu as well) as well as reducing the cpu->gpu image data bandwidth as yuv is compressed. Do jpeg decoding on the gpu for v4l2 mjpeg capture (see https://github.com/negge/jpeg_gpu). Or use jpeg decoding from vaapi/nvdec. Support other v4l2 pixel formats, such as h264 and rgb/bgr. High-end cameras use h264 for high resolution high framerate option (4k 60fps or higher). AV1 medium quality on nvidia seems to be very high quality. The quality needs to be rescaled. Need to test on nvidia av1 gpu, but I dont have any such gpu. Support multiple -w, to record different sources to different video tracks. For example gameplay to video track 1 and webcam to video track 2. Update man page with info about v4l2 and new region capture format. Mention that -region is deprecated. Make multiple -w portal work with -restore-portal-session. Play with DRM_FORMAT_MOD_LINEAR or other linear formats to avoid cuda copy. If it's already in linear format then instead check the format of the target texture and use the same format. Give early error when using invalid v4l2 path like with monitor. Use gsr_capture_v4l2_list_devices for query. Or maybe remove the early error for monitor to simplify the code. Support camera capture with pipewire to support multiple applications recording camera at the same time. Might not be as efficient as V4L2. Taking a screenshot of camera with mjpeg doesn't work correctly because it updates buffer asynchronously. v4l2 capture should only return 0 if the copy of the data to the texture has finished. Make capture from multiple sources work on nvidia x11 when capturing monitor + window. It doesn't work right now because monitor requires glx (nvfbc) while window requires egl. Support v4l2 mplane on devices where it's supported (where it's more efficient). My camera doesn't support mplane. Implement v4l2 yuyv nvidia capture by capturing rg88 yuyv to rgb as is done now for screenshot, but also do that for video by creating an intermediate rgb texture for the camera. Then render that rgb texture to the video texture. This is needed to properly scale the yuyv texture without messing it up (the texture indexing). Set v4l2 camera fps to video output fps (if lower than the camera fps) and the same for resolution. Support camera controls, such as white balance. Otherwise tell user to use cameractrl software. Camera capture doesn't work perfectly. The image gets glitched, need to properly wait for image to be done. Use one pipewire connection (pipewire video) instead of multiple ones when recording with portal multiple times (multiple sources). Close pipewire links or maybe there are file descriptor leaks? Make multiple capture sources work properly in regards to size. The size of the video should be the region size of each capture source. Support hdr camera capture. Return the max resolution of each codec in --info to display an error in the UI before capture starts. Right now its fine since the UI will report bad resolution after capture starts and fails but it doesn't say what the max resolution is. Should -low-power option also use vaapi/vulkan low power, if available? Should capture option x=bla;y=bla be scaled by -s (output resolution scale)? width and height is. Add option to capture all monitors automatically. Make -w optional, to only capture audio. Use GL_RGBA16F or GL_RGBA32F for hdr, that allows color values to be outside the 0.0 to 1.0 range. https://registry.khronos.org/EGL/extensions/EXT/EGL_EXT_surface_SMPTE2086_metadata.txt Doesn't work: sibs run --args -w "/dev/video0;camera_width=800;camera_height=600;pixfmt=yuyv" -fm content -o video.mp4 Delay adding audio data until 1 frames time has passed. Allow av1 in the flatpak. Do that by patching ffmpeg to support multiple nvenc codepaths by using header versions, the same way gsr does in the nvenc query. Increase qp on av1 non-nvidia, decrease qp on h264 nvidia. For vulkan. Check if the vulkan codec query works on nvidia x11. Fix webcam capture on nvidia x11. It doesn't work when capturing a webcam at the same time as capturing the monitor (nvfbc) because nvfbc requires glx context active (in older nvfbc version, works with egl in newer version) while v4l2 requires egl. All other capture methods require egl so they cant be used together with nvfbc. Make -fm content the default, but first make it record at no lower than 2 fps if nothing updates. This is to make sure live streaming works and seeking in video player doesn't get messed up. Fix camera capture on nvidia x11. It doesn't work with mjpeg either now because external shader compilation fails. Revert the revert of improving pipewire capture, for better cursor capture. It caused glitches for some, especially in kde plasma when hdr is enabled. Try marking test and moving the cursor and see. fsdsfdsfdsfdsf-5.13.8/external/000077500000000000000000000000001520215207700164275ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/external/NvFBC.h000066400000000000000000002062461520215207700175100ustar00rootroot00000000000000/*! * \file * * This file contains the interface constants, structure definitions and * function prototypes defining the NvFBC API for Linux. * * Copyright (c) 2013-2020, NVIDIA CORPORATION. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * the rights to use, copy, modify, merge, publish, distribute, sublicense, * and/or sell copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER * DEALINGS IN THE SOFTWARE. */ #ifndef _NVFBC_H_ #define _NVFBC_H_ #include /*! * \mainpage NVIDIA Framebuffer Capture (NvFBC) for Linux. * * NvFBC is a high performance, low latency API to capture the framebuffer of * an X server screen. * * The output from NvFBC captures everything that would be visible if we were * directly looking at the monitor. This includes window manager decoration, * mouse cursor, overlay, etc. * * It is ideally suited to desktop or fullscreen application capture and * remoting. */ /*! * \defgroup FBC_REQ Requirements * * The following requirements are provided by the regular NVIDIA Display Driver * package: * * - OpenGL core >= 4.2: * Required. NvFBC relies on OpenGL to perform frame capture and * post-processing. * * - Vulkan 1.1: * Required. * * - libcuda.so.1 >= 5.5: * Optional. Used for capture to video memory with CUDA interop. * * The following requirements must be installed separately depending on the * Linux distribution being used: * * - XRandR extension >= 1.2: * Optional. Used for RandR output tracking. * * - libX11-xcb.so.1 >= 1.2: * Required. NvFBC uses a mix of Xlib and XCB. Xlib is needed to use GLX, * XCB is needed to make NvFBC more resilient against X server terminations * while a capture session is active. * * - libxcb.so.1 >= 1.3: * Required. See above. * * - xorg-server >= 1.3: * Optional. Required for push model to work properly. * * Note that all optional dependencies are dlopen()'d at runtime. Failure to * load an optional library is not fatal. */ /*! * \defgroup FBC_CHANGES ChangeLog * * NvFBC Linux API version 0.1 * - Initial BETA release. * * NvFBC Linux API version 0.2 * - Added 'bEnableMSE' field to NVFBC_H264_HW_ENC_CONFIG. * - Added 'dwMSE' field to NVFBC_TOH264_GRAB_FRAME_PARAMS. * - Added 'bEnableAQ' field to NVFBC_H264_HW_ENC_CONFIG. * - Added 'NVFBC_H264_PRESET_LOSSLESS_HP' enum to NVFBC_H264_PRESET. * - Added 'NVFBC_BUFFER_FORMAT_YUV444P' enum to NVFBC_BUFFER_FORMAT. * - Added 'eInputBufferFormat' field to NVFBC_H264_HW_ENC_CONFIG. * - Added '0' and '244' values for NVFBC_H264_HW_ENC_CONFIG::dwProfile. * * NvFBC Linux API version 0.3 * - Improved multi-threaded support by implementing an API locking mechanism. * - Added 'nvFBCBindContext' API entry point. * - Added 'nvFBCReleaseContext' API entry point. * * NvFBC Linux API version 1.0 * - Added codec agnostic interface for HW encoding. * - Deprecated H.264 interface. * - Added support for H.265/HEVC HW encoding. * * NvFBC Linux API version 1.1 * - Added 'nvFBCToHwGetCaps' API entry point. * - Added 'dwDiffMapScalingFactor' field to NVFBC_TOSYS_SETUP_PARAMS. * * NvFBC Linux API version 1.2 * - Deprecated ToHwEnc interface. * - Added ToGL interface that captures frames to an OpenGL texture in video * memory. * - Added 'bDisableAutoModesetRecovery' field to * NVFBC_CREATE_CAPTURE_SESSION_PARAMS. * - Added 'bExternallyManagedContext' field to NVFBC_CREATE_HANDLE_PARAMS. * * NvFBC Linux API version 1.3 * - Added NVFBC_BUFFER_FORMAT_RGBA * - Added 'dwTimeoutMs' field to NVFBC_TOSYS_GRAB_FRAME_PARAMS, * NVFBC_TOCUDA_GRAB_FRAME_PARAMS, and NVFBC_TOGL_GRAB_FRAME_PARAMS. * * NvFBC Linux API version 1.4 * - Clarified that NVFBC_BUFFER_FORMAT_{ARGB,RGB,RGBA} are byte-order formats. * - Renamed NVFBC_BUFFER_FORMAT_YUV420P to NVFBC_BUFFER_FORMAT_NV12. * - Added new requirements. * - Made NvFBC more resilient against the X server terminating during an active * capture session. See new comments for ::NVFBC_ERR_X. * - Relaxed requirement that 'frameSize' must have a width being a multiple of * 4 and a height being a multiple of 2. * - Added 'bRoundFrameSize' field to NVFBC_CREATE_CAPTURE_SESSION_PARAMS. * - Relaxed requirement that the scaling factor for differential maps must be * a multiple of the size of the frame. * - Added 'diffMapSize' field to NVFBC_TOSYS_SETUP_PARAMS and * NVFBC_TOGL_SETUP_PARAMS. * * NvFBC Linux API version 1.5 * - Added NVFBC_BUFFER_FORMAT_BGRA * * NvFBC Linux API version 1.6 * - Added the 'NVFBC_TOSYS_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY', * 'NVFBC_TOCUDA_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY', and * 'NVFBC_TOGL_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY' capture flags. * - Exposed debug and performance logs through the NVFBC_LOG_LEVEL environment * variable. Setting it to "1" enables performance logs, setting it to "2" * enables debugging logs, setting it to "3" enables both. * - Logs are printed to stdout or to the file pointed by the NVFBC_LOG_FILE * environment variable. * - Added 'ulTimestampUs' to NVFBC_FRAME_GRAB_INFO. * - Added 'dwSamplingRateMs' to NVFBC_CREATE_CAPTURE_SESSION_PARAMS. * - Added 'bPushModel' to NVFBC_CREATE_CAPTURE_SESSION_PARAMS. * * NvFBC Linux API version 1.7 * - Retired the NVFBC_CAPTURE_TO_HW_ENCODER interface. * This interface has been deprecated since NvFBC 1.2 and has received no * updates or new features since. We recommend using the NVIDIA Video Codec * SDK to encode NvFBC frames. * See: https://developer.nvidia.com/nvidia-video-codec-sdk * - Added a 'Capture Modes' section to those headers. * - Added a 'Post Processing' section to those headers. * - Added an 'Environment Variables' section to those headers. * - Added 'bInModeset' to NVFBC_GET_STATUS_PARAMS. * - Added 'bAllowDirectCapture' to NVFBC_CREATE_CAPTURE_SESSION_PARAMS. * - Added 'bDirectCaptured' to NVFBC_FRAME_GRAB_INFO. * - Added 'bRequiredPostProcessing' to NVFBC_FRAME_GRAB_INFO. */ /*! * \defgroup FBC_MODES Capture Modes * * When creating a capture session, NvFBC instantiates a capture subsystem * living in the NVIDIA X driver. * * This subsystem listens for damage events coming from applications then * generates (composites) frames for NvFBC when new content is available. * * This capture server can operate on a timer where it periodically checks if * there are any pending damage events, or it can generate frames as soon as it * receives a new damage event. * See NVFBC_CREATE_CAPTURE_SESSION_PARAMS::dwSamplingRateMs, * and NVFBC_CREATE_CAPTURE_SESSION_PARAMS::bPushModel. * * NvFBC can also attach itself to a fullscreen unoccluded application and have * it copy its frames directly into a buffer owned by NvFBC upon present. This * mode bypasses the X server. * See NVFBC_CREATE_CAPTURE_SESSION_PARAMS::bAllowDirectCapture. * * NvFBC is designed to capture frames with as few copies as possible. The * NVIDIA X driver composites frames directly into the NvFBC buffers, and * direct capture copies frames directly into these buffers as well. * * Depending on the configuration of a capture session, an extra copy (rendering * pass) may be needed. See the 'Post Processing' section. */ /*! * \defgroup FBC_PP Post Processing * * Depending on the configuration of a capture session, NvFBC might require to * do post processing on frames. * * Post processing is required for the following reasons: * - NvFBC needs to do a pixel format conversion. * - Diffmaps are requested. * - Capture to system memory is requested. * * NvFBC needs to do a conversion if the requested pixel format does not match * the native format. The native format is NVFBC_BUFFER_FORMAT_BGRA. * * Note: post processing is *not* required for frame scaling and frame cropping. * * Skipping post processing can reduce capture latency. An application can know * whether post processing was required by checking * NVFBC_FRAME_GRAB_INFO::bRequiredPostProcessing. */ /*! * \defgroup FBC_ENVVAR Environment Variables * * Below are the environment variables supported by NvFBC: * * - NVFBC_LOG_LEVEL * Bitfield where the first bit enables debug logs and the second bit enables * performance logs. Both can be enabled by setting this envvar to 3. * * - NVFBC_LOG_FILE * Write all NvFBC logs to the given file. * * - NVFBC_FORCE_ALLOW_DIRECT_CAPTURE * Used to override NVFBC_CREATE_CAPTURE_SESSION_PARAMS::bAllowDirectCapture. * * - NVFBC_FORCE_POST_PROCESSING * Used to force the post processing step, even if it could be skipped. * See the 'Post Processing' section. */ /*! * \defgroup FBC_STRUCT Structure Definition * * @{ */ #ifdef __cplusplus extern "C" { #endif /*! * Calling convention. */ #define NVFBCAPI /*! * NvFBC API major version. */ #define NVFBC_VERSION_MAJOR 1 /*! * NvFBC API minor version. */ #define NVFBC_VERSION_MINOR 7 /*! * NvFBC API version. */ #define NVFBC_VERSION (uint32_t) (NVFBC_VERSION_MINOR | (NVFBC_VERSION_MAJOR << 8)) /*! * Creates a version number for structure parameters. */ #define NVFBC_STRUCT_VERSION(typeName, ver) \ (uint32_t) (sizeof(typeName) | ((ver) << 16) | (NVFBC_VERSION << 24)) /*! * Defines error codes. * * \see NvFBCGetLastErrorStr */ typedef enum _NVFBCSTATUS { /*! * This indicates that the API call returned with no errors. */ NVFBC_SUCCESS = 0, /*! * This indicates that the API version between the client and the library * is not compatible. */ NVFBC_ERR_API_VERSION = 1, /*! * An internal error occurred. */ NVFBC_ERR_INTERNAL = 2, /*! * This indicates that one or more of the parameter passed to the API call * is invalid. */ NVFBC_ERR_INVALID_PARAM = 3, /*! * This indicates that one or more of the pointers passed to the API call * is invalid. */ NVFBC_ERR_INVALID_PTR = 4, /*! * This indicates that the handle passed to the API call to identify the * client is invalid. */ NVFBC_ERR_INVALID_HANDLE = 5, /*! * This indicates that the maximum number of threaded clients of the same * process has been reached. The limit is 10 threads per process. * There is no limit on the number of process. */ NVFBC_ERR_MAX_CLIENTS = 6, /*! * This indicates that the requested feature is not currently supported * by the library. */ NVFBC_ERR_UNSUPPORTED = 7, /*! * This indicates that the API call failed because it was unable to allocate * enough memory to perform the requested operation. */ NVFBC_ERR_OUT_OF_MEMORY = 8, /*! * This indicates that the API call was not expected. This happens when * API calls are performed in a wrong order, such as trying to capture * a frame prior to creating a new capture session; or trying to set up * a capture to video memory although a capture session to system memory * was created. */ NVFBC_ERR_BAD_REQUEST = 9, /*! * This indicates an X error, most likely meaning that the X server has * been terminated. When this error is returned, the only resort is to * create another FBC handle using NvFBCCreateHandle(). * * The previous handle should still be freed with NvFBCDestroyHandle(), but * it might leak resources, in particular X, GLX, and GL resources since * it is no longer possible to communicate with an X server to free them * through the driver. * * The best course of action to eliminate this potential leak is to close * the OpenGL driver, close the forked process running the capture, or * restart the application. */ NVFBC_ERR_X = 10, /*! * This indicates a GLX error. */ NVFBC_ERR_GLX = 11, /*! * This indicates an OpenGL error. */ NVFBC_ERR_GL = 12, /*! * This indicates a CUDA error. */ NVFBC_ERR_CUDA = 13, /*! * This indicates a HW encoder error. */ NVFBC_ERR_ENCODER = 14, /*! * This indicates an NvFBC context error. */ NVFBC_ERR_CONTEXT = 15, /*! * This indicates that the application must recreate the capture session. * * This error can be returned if a modeset event occurred while capturing * frames, and NVFBC_CREATE_HANDLE_PARAMS::bDisableAutoModesetRecovery * was set to NVFBC_TRUE. */ NVFBC_ERR_MUST_RECREATE = 16, /*! * This indicates a Vulkan error. */ NVFBC_ERR_VULKAN = 17, } NVFBCSTATUS; /*! * Defines boolean values. */ typedef enum _NVFBC_BOOL { /*! * False value. */ NVFBC_FALSE = 0, /*! * True value. */ NVFBC_TRUE, } NVFBC_BOOL; /*! * Maximum size in bytes of an error string. */ #define NVFBC_ERR_STR_LEN 512 /*! * Capture type. */ typedef enum _NVFBC_CAPTURE_TYPE { /*! * Capture frames to a buffer in system memory. */ NVFBC_CAPTURE_TO_SYS = 0, /*! * Capture frames to a CUDA device in video memory. * * Specifying this will dlopen() libcuda.so.1 and fail if not available. */ NVFBC_CAPTURE_SHARED_CUDA, /*! * Retired. Do not use. */ /* NVFBC_CAPTURE_TO_HW_ENCODER, */ /*! * Capture frames to an OpenGL buffer in video memory. */ NVFBC_CAPTURE_TO_GL = 3, } NVFBC_CAPTURE_TYPE; /*! * Tracking type. * * NvFBC can track a specific region of the framebuffer to capture. * * An X screen corresponds to the entire framebuffer. * * An RandR CRTC is a component of the GPU that reads pixels from a region of * the X screen and sends them through a pipeline to an RandR output. * A physical monitor can be connected to an RandR output. Tracking an RandR * output captures the region of the X screen that the RandR CRTC is sending to * the RandR output. */ typedef enum { /*! * By default, NvFBC tries to track a connected primary output. If none is * found, then it tries to track the first connected output. If none is * found then it tracks the entire X screen. * * If the XRandR extension is not available, this option has the same effect * as ::NVFBC_TRACKING_SCREEN. * * This default behavior might be subject to changes in the future. */ NVFBC_TRACKING_DEFAULT = 0, /*! * Track an RandR output specified by its ID in the appropriate field. * * The list of connected outputs can be queried via NvFBCGetStatus(). * This list can also be obtained using e.g., xrandr(1). * * If the XRandR extension is not available, setting this option returns an * error. */ NVFBC_TRACKING_OUTPUT, /*! * Track the entire X screen. */ NVFBC_TRACKING_SCREEN, } NVFBC_TRACKING_TYPE; /*! * Buffer format. */ typedef enum _NVFBC_BUFFER_FORMAT { /*! * Data will be converted to ARGB8888 byte-order format. 32 bpp. */ NVFBC_BUFFER_FORMAT_ARGB = 0, /*! * Data will be converted to RGB888 byte-order format. 24 bpp. */ NVFBC_BUFFER_FORMAT_RGB, /*! * Data will be converted to NV12 format using HDTV weights * according to ITU-R BT.709. 12 bpp. */ NVFBC_BUFFER_FORMAT_NV12, /*! * Data will be converted to YUV 444 planar format using HDTV weights * according to ITU-R BT.709. 24 bpp */ NVFBC_BUFFER_FORMAT_YUV444P, /*! * Data will be converted to RGBA8888 byte-order format. 32 bpp. */ NVFBC_BUFFER_FORMAT_RGBA, /*! * Native format. No pixel conversion needed. * BGRA8888 byte-order format. 32 bpp. */ NVFBC_BUFFER_FORMAT_BGRA, } NVFBC_BUFFER_FORMAT; #define NVFBC_BUFFER_FORMAT_YUV420P NVFBC_BUFFER_FORMAT_NV12 /*! * Handle used to identify an NvFBC session. */ typedef uint64_t NVFBC_SESSION_HANDLE; /*! * Box used to describe an area of the tracked region to capture. * * The coordinates are relative to the tracked region. * * E.g., if the size of the X screen is 3520x1200 and the tracked RandR output * scans a region of 1600x1200+1920+0, then setting a capture box of * 800x600+100+50 effectively captures a region of 800x600+2020+50 relative to * the X screen. */ typedef struct _NVFBC_BOX { /*! * [in] X offset of the box. */ uint32_t x; /*! * [in] Y offset of the box. */ uint32_t y; /*! * [in] Width of the box. */ uint32_t w; /*! * [in] Height of the box. */ uint32_t h; } NVFBC_BOX; /*! * Size used to describe the size of a frame. */ typedef struct _NVFBC_SIZE { /*! * [in] Width. */ uint32_t w; /*! * [in] Height. */ uint32_t h; } NVFBC_SIZE; /*! * Describes information about a captured frame. */ typedef struct _NVFBC_FRAME_GRAB_INFO { /*! * [out] Width of the captured frame. */ uint32_t dwWidth; /*! * [out] Height of the captured frame. */ uint32_t dwHeight; /*! * [out] Size of the frame in bytes. */ uint32_t dwByteSize; /*! * [out] Incremental ID of the current frame. * * This can be used to identify a frame. */ uint32_t dwCurrentFrame; /*! * [out] Whether the captured frame is a new frame. * * When using non blocking calls it is possible to capture a frame * that was already captured before if the display server did not * render a new frame in the meantime. In that case, this flag * will be set to NVFBC_FALSE. * * When using blocking calls each captured frame will have * this flag set to NVFBC_TRUE since the blocking mechanism waits for * the display server to render a new frame. * * Note that this flag does not guarantee that the content of * the frame will be different compared to the previous captured frame. * * In particular, some compositing managers report the entire * framebuffer as damaged when an application refreshes its content. * * Consider a single X screen spanned across physical displays A and B * and an NvFBC application tracking display A. Depending on the * compositing manager, it is possible that an application refreshing * itself on display B will trigger a frame capture on display A. * * Workarounds include: * - Using separate X screens * - Disabling the composite extension * - Using a compositing manager that properly reports what regions * are damaged * - Using NvFBC's diffmaps to find out if the frame changed */ NVFBC_BOOL bIsNewFrame; /*! * [out] Frame timestamp * * Time in micro seconds when the display server started rendering the * frame. * * This does not account for when the frame was captured. If capturing an * old frame (e.g., bIsNewFrame is NVFBC_FALSE) the reported timestamp * will reflect the time when the old frame was rendered by the display * server. */ uint64_t ulTimestampUs; /* * [out] Number of frames generated since the last capture. * * This can help applications tell whether they missed frames or there * were no frames generated by the server since the last capture. */ uint32_t dwMissedFrames; /* * [out] Whether the captured frame required post processing. * * See the 'Post Processing' section. */ NVFBC_BOOL bRequiredPostProcessing; /* * [out] Whether this frame was obtained via direct capture. * * See NVFBC_CREATE_CAPTURE_SESSION_PARAMS::bAllowDirectCapture. */ NVFBC_BOOL bDirectCapture; } NVFBC_FRAME_GRAB_INFO; /*! * Defines parameters for the CreateHandle() API call. */ typedef struct _NVFBC_CREATE_HANDLE_PARAMS { /*! * [in] Must be set to NVFBC_CREATE_HANDLE_PARAMS_VER */ uint32_t dwVersion; /*! * [in] Application specific private information passed to the NvFBC * session. */ const void *privateData; /*! * [in] Size of the application specific private information passed to the * NvFBC session. */ uint32_t privateDataSize; /*! * [in] Whether NvFBC should not create and manage its own graphics context * * NvFBC internally uses OpenGL to perfom graphics operations on the * captured frames. By default, NvFBC will create and manage (e.g., make * current, detect new threads, etc.) its own OpenGL context. * * If set to NVFBC_TRUE, NvFBC will use the application's context. It will * be the application's responsibility to make sure that a context is * current on the thread calling into the NvFBC API. */ NVFBC_BOOL bExternallyManagedContext; /*! * [in] GLX context * * GLX context that NvFBC should use internally to create pixmaps and * make them current when creating a new capture session. * * Note: NvFBC expects a context created against a GLX_RGBA_TYPE render * type. */ void *glxCtx; /*! * [in] GLX framebuffer configuration * * Framebuffer configuration that was used to create the GLX context, and * that will be used to create pixmaps internally. * * Note: NvFBC expects a configuration having at least the following * attributes: * GLX_DRAWABLE_TYPE, GLX_PIXMAP_BIT * GLX_BIND_TO_TEXTURE_RGBA_EXT, 1 * GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT */ void *glxFBConfig; } NVFBC_CREATE_HANDLE_PARAMS; /*! * NVFBC_CREATE_HANDLE_PARAMS structure version. */ #define NVFBC_CREATE_HANDLE_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_CREATE_HANDLE_PARAMS, 2) /*! * Defines parameters for the ::NvFBCDestroyHandle() API call. */ typedef struct _NVFBC_DESTROY_HANDLE_PARAMS { /*! * [in] Must be set to NVFBC_DESTROY_HANDLE_PARAMS_VER */ uint32_t dwVersion; } NVFBC_DESTROY_HANDLE_PARAMS; /*! * NVFBC_DESTROY_HANDLE_PARAMS structure version. */ #define NVFBC_DESTROY_HANDLE_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_DESTROY_HANDLE_PARAMS, 1) /*! * Maximum number of connected RandR outputs to an X screen. */ #define NVFBC_OUTPUT_MAX 5 /*! * Maximum size in bytes of an RandR output name. */ #define NVFBC_OUTPUT_NAME_LEN 128 /*! * Describes an RandR output. * * Filling this structure relies on the XRandR extension. This feature cannot * be used if the extension is missing or its version is below the requirements. * * \see Requirements */ typedef struct _NVFBC_OUTPUT { /*! * Identifier of the RandR output. */ uint32_t dwId; /*! * Name of the RandR output, as reported by tools such as xrandr(1). * * Example: "DVI-I-0" */ char name[NVFBC_OUTPUT_NAME_LEN]; /*! * Region of the X screen tracked by the RandR CRTC driving this RandR * output. */ NVFBC_BOX trackedBox; } NVFBC_RANDR_OUTPUT_INFO; /*! * Defines parameters for the ::NvFBCGetStatus() API call. */ typedef struct _NVFBC_GET_STATUS_PARAMS { /*! * [in] Must be set to NVFBC_GET_STATUS_PARAMS_VER */ uint32_t dwVersion; /*! * [out] Whether or not framebuffer capture is supported by the graphics * driver. */ NVFBC_BOOL bIsCapturePossible; /*! * [out] Whether or not there is already a capture session on this system. */ NVFBC_BOOL bCurrentlyCapturing; /*! * [out] Whether or not it is possible to create a capture session on this * system. */ NVFBC_BOOL bCanCreateNow; /*! * [out] Size of the X screen (framebuffer). */ NVFBC_SIZE screenSize; /*! * [out] Whether the XRandR extension is available. * * If this extension is not available then it is not possible to have * information about RandR outputs. */ NVFBC_BOOL bXRandRAvailable; /*! * [out] Array of outputs connected to the X screen. * * An application can track a specific output by specifying its ID when * creating a capture session. * * Only if XRandR is available. */ NVFBC_RANDR_OUTPUT_INFO outputs[NVFBC_OUTPUT_MAX]; /*! * [out] Number of outputs connected to the X screen. * * This must be used to parse the array of connected outputs. * * Only if XRandR is available. */ uint32_t dwOutputNum; /*! * [out] Version of the NvFBC library running on this system. */ uint32_t dwNvFBCVersion; /*! * [out] Whether the X server is currently in modeset. * * When the X server is in modeset, it must give up all its video * memory allocations. It is not possible to create a capture * session until the modeset is over. * * Note that VT-switches are considered modesets. */ NVFBC_BOOL bInModeset; } NVFBC_GET_STATUS_PARAMS; /*! * NVFBC_GET_STATUS_PARAMS structure version. */ #define NVFBC_GET_STATUS_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_GET_STATUS_PARAMS, 2) /*! * Defines parameters for the ::NvFBCCreateCaptureSession() API call. */ typedef struct _NVFBC_CREATE_CAPTURE_SESSION_PARAMS { /*! * [in] Must be set to NVFBC_CREATE_CAPTURE_SESSION_PARAMS_VER */ uint32_t dwVersion; /*! * [in] Desired capture type. * * Note that when specyfing ::NVFBC_CAPTURE_SHARED_CUDA NvFBC will try to * dlopen() the corresponding libraries. This means that NvFBC can run on * a system without the CUDA library since it does not link against them. */ NVFBC_CAPTURE_TYPE eCaptureType; /*! * [in] What region of the framebuffer should be tracked. */ NVFBC_TRACKING_TYPE eTrackingType; /*! * [in] ID of the output to track if eTrackingType is set to * ::NVFBC_TRACKING_OUTPUT. */ uint32_t dwOutputId; /*! * [in] Crop the tracked region. * * The coordinates are relative to the tracked region. * * It can be set to 0 to capture the entire tracked region. */ NVFBC_BOX captureBox; /*! * [in] Desired size of the captured frame. * * This parameter allow to scale the captured frame. * * It can be set to 0 to disable frame resizing. */ NVFBC_SIZE frameSize; /*! * [in] Whether the mouse cursor should be composited to the frame. * * Disabling the cursor will not generate new frames when only the cursor * is moved. */ NVFBC_BOOL bWithCursor; /*! * [in] Whether NvFBC should not attempt to recover from modesets. * * NvFBC is able to detect when a modeset event occured and can automatically * re-create a capture session with the same settings as before, then resume * its frame capture session transparently. * * This option allows to disable this behavior. NVFBC_ERR_MUST_RECREATE * will be returned in that case. * * It can be useful in the cases when an application needs to do some work * between setting up a capture and grabbing the first frame. * * For example: an application using the ToGL interface needs to register * resources with EncodeAPI prior to encoding frames. * * Note that during modeset recovery, NvFBC will try to re-create the * capture session every second until it succeeds. */ NVFBC_BOOL bDisableAutoModesetRecovery; /*! * [in] Whether NvFBC should round the requested frameSize. * * When disabled, NvFBC will not attempt to round the requested resolution. * * However, some pixel formats have resolution requirements. E.g., YUV/NV * formats must have a width being a multiple of 4, and a height being a * multiple of 2. RGB formats don't have such requirements. * * If the resolution doesn't meet the requirements of the format, then NvFBC * will fail at setup time. * * When enabled, NvFBC will round the requested width to the next multiple * of 4 and the requested height to the next multiple of 2. * * In this case, requesting any resolution will always work with every * format. However, an NvFBC client must be prepared to handle the case * where the requested resolution is different than the captured resolution. * * NVFBC_FRAME_GRAB_INFO::dwWidth and NVFBC_FRAME_GRAB_INFO::dwHeight should * always be used for getting information about captured frames. */ NVFBC_BOOL bRoundFrameSize; /*! * [in] Rate in ms at which the display server generates new frames * * This controls the frequency at which the display server will generate * new frames if new content is available. This effectively controls the * capture rate when using blocking calls. * * Note that lower values will increase the CPU and GPU loads. * * The default value is 16ms (~ 60 Hz). */ uint32_t dwSamplingRateMs; /*! * [in] Enable push model for frame capture * * When set to NVFBC_TRUE, the display server will generate frames whenever * it receives a damage event from applications. * * Setting this to NVFBC_TRUE will ignore ::dwSamplingRateMs. * * Using push model with the NVFBC_*_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY * capture flag should guarantee the shortest amount of time between an * application rendering a frame and an NvFBC client capturing it, provided * that the NvFBC client is able to process the frames quickly enough. * * Note that applications running at high frame rates will increase CPU and * GPU loads. */ NVFBC_BOOL bPushModel; /*! * [in] Allow direct capture * * Direct capture allows NvFBC to attach itself to a fullscreen graphics * application. Whenever that application presents a frame, it makes a copy * of it directly into a buffer owned by NvFBC thus bypassing the X server. * * When direct capture is *not* enabled, the NVIDIA X driver generates a * frame for NvFBC when it receives a damage event from an application if push * model is enabled, or periodically checks if there are any pending damage * events otherwise (see NVFBC_CREATE_CAPTURE_SESSION_PARAMS::dwSamplingRateMs). * * Direct capture is possible under the following conditions: * - Direct capture is allowed * - Push model is enabled (see NVFBC_CREATE_CAPTURE_SESSION_PARAMS::bPushModel) * - The mouse cursor is not composited (see NVFBC_CREATE_CAPTURE_SESSION_PARAMS::bWithCursor) * - No viewport transformation is required. This happens when the remote * desktop is e.g. rotated. * * When direct capture is possible, NvFBC will automatically attach itself * to a fullscreen unoccluded application, if such exists. * * Notes: * - This includes compositing desktops such as GNOME (e.g., gnome-shell * is the fullscreen unoccluded application). * - There can be only one fullscreen unoccluded application at a time. * - The NVIDIA X driver monitors which application qualifies or no * longer qualifies. * * For example, if a fullscreen application is launched in GNOME, NvFBC will * detach from gnome-shell and attach to that application. * * Attaching and detaching happens automatically from the perspective of an * NvFBC client. When detaching from an application, the X driver will * transparently resume generating frames for NvFBC. * * An application can know whether a given frame was obtained through * direct capture by checking NVFBC_FRAME_GRAB_INFO::bDirectCapture. */ NVFBC_BOOL bAllowDirectCapture; } NVFBC_CREATE_CAPTURE_SESSION_PARAMS; /*! * NVFBC_CREATE_CAPTURE_SESSION_PARAMS structure version. */ #define NVFBC_CREATE_CAPTURE_SESSION_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_CREATE_CAPTURE_SESSION_PARAMS, 6) /*! * Defines parameters for the ::NvFBCDestroyCaptureSession() API call. */ typedef struct _NVFBC_DESTROY_CAPTURE_SESSION_PARAMS { /*! * [in] Must be set to NVFBC_DESTROY_CAPTURE_SESSION_PARAMS_VER */ uint32_t dwVersion; } NVFBC_DESTROY_CAPTURE_SESSION_PARAMS; /*! * NVFBC_DESTROY_CAPTURE_SESSION_PARAMS structure version. */ #define NVFBC_DESTROY_CAPTURE_SESSION_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_DESTROY_CAPTURE_SESSION_PARAMS, 1) /*! * Defines parameters for the ::NvFBCBindContext() API call. */ typedef struct _NVFBC_BIND_CONTEXT_PARAMS { /*! * [in] Must be set to NVFBC_BIND_CONTEXT_PARAMS_VER */ uint32_t dwVersion; } NVFBC_BIND_CONTEXT_PARAMS; /*! * NVFBC_BIND_CONTEXT_PARAMS structure version. */ #define NVFBC_BIND_CONTEXT_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_BIND_CONTEXT_PARAMS, 1) /*! * Defines parameters for the ::NvFBCReleaseContext() API call. */ typedef struct _NVFBC_RELEASE_CONTEXT_PARAMS { /*! * [in] Must be set to NVFBC_RELEASE_CONTEXT_PARAMS_VER */ uint32_t dwVersion; } NVFBC_RELEASE_CONTEXT_PARAMS; /*! * NVFBC_RELEASE_CONTEXT_PARAMS structure version. */ #define NVFBC_RELEASE_CONTEXT_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_RELEASE_CONTEXT_PARAMS, 1) /*! * Defines flags that can be used when capturing to system memory. */ typedef enum { /*! * Default, capturing waits for a new frame or mouse move. * * The default behavior of blocking grabs is to wait for a new frame until * after the call was made. But it's possible that there is a frame already * ready that the client hasn't seen. * \see NVFBC_TOSYS_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY */ NVFBC_TOSYS_GRAB_FLAGS_NOFLAGS = 0, /*! * Capturing does not wait for a new frame nor a mouse move. * * It is therefore possible to capture the same frame multiple times. * When this occurs, the dwCurrentFrame parameter of the * NVFBC_FRAME_GRAB_INFO structure is not incremented. */ NVFBC_TOSYS_GRAB_FLAGS_NOWAIT = (1 << 0), /*! * Forces the destination buffer to be refreshed even if the frame has not * changed since previous capture. * * By default, if the captured frame is identical to the previous one, NvFBC * will omit one copy and not update the destination buffer. * * Setting that flag will prevent this behavior. This can be useful e.g., * if the application has modified the buffer in the meantime. */ NVFBC_TOSYS_GRAB_FLAGS_FORCE_REFRESH = (1 << 1), /*! * Similar to NVFBC_TOSYS_GRAB_FLAGS_NOFLAGS, except that the capture will * not wait if there is already a frame available that the client has * never seen yet. */ NVFBC_TOSYS_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY = (1 << 2), } NVFBC_TOSYS_GRAB_FLAGS; /*! * Defines parameters for the ::NvFBCToSysSetUp() API call. */ typedef struct _NVFBC_TOSYS_SETUP_PARAMS { /*! * [in] Must be set to NVFBC_TOSYS_SETUP_PARAMS_VER */ uint32_t dwVersion; /*! * [in] Desired buffer format. */ NVFBC_BUFFER_FORMAT eBufferFormat; /*! * [out] Pointer to a pointer to a buffer in system memory. * * This buffer contains the pixel value of the requested format. Refer to * the description of the buffer formats to understand the memory layout. * * The application does not need to allocate memory for this buffer. It * should not free this buffer either. This buffer is automatically * re-allocated when needed (e.g., when the resolution changes). * * This buffer is allocated by the NvFBC library to the proper size. This * size is returned in the dwByteSize field of the * ::NVFBC_FRAME_GRAB_INFO structure. */ void **ppBuffer; /*! * [in] Whether differential maps should be generated. */ NVFBC_BOOL bWithDiffMap; /*! * [out] Pointer to a pointer to a buffer in system memory. * * This buffer contains the differential map of two frames. It must be read * as an array of unsigned char. Each unsigned char is either 0 or * non-zero. 0 means that the pixel value at the given location has not * changed since the previous captured frame. Non-zero means that the pixel * value has changed. * * The application does not need to allocate memory for this buffer. It * should not free this buffer either. This buffer is automatically * re-allocated when needed (e.g., when the resolution changes). * * This buffer is allocated by the NvFBC library to the proper size. The * size of the differential map is returned in ::diffMapSize. * * This option is not compatible with the ::NVFBC_BUFFER_FORMAT_YUV420P and * ::NVFBC_BUFFER_FORMAT_YUV444P buffer formats. */ void **ppDiffMap; /*! * [in] Scaling factor of the differential maps. * * For example, a scaling factor of 16 means that one pixel of the diffmap * will represent 16x16 pixels of the original frames. * * If any of these 16x16 pixels is different between the current and the * previous frame, then the corresponding pixel in the diffmap will be set * to non-zero. * * The default scaling factor is 1. A dwDiffMapScalingFactor of 0 will be * set to 1. */ uint32_t dwDiffMapScalingFactor; /*! * [out] Size of the differential map. * * Only set if bWithDiffMap is set to NVFBC_TRUE. */ NVFBC_SIZE diffMapSize; } NVFBC_TOSYS_SETUP_PARAMS; /*! * NVFBC_TOSYS_SETUP_PARAMS structure version. */ #define NVFBC_TOSYS_SETUP_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_TOSYS_SETUP_PARAMS, 3) /*! * Defines parameters for the ::NvFBCToSysGrabFrame() API call. */ typedef struct _NVFBC_TOSYS_GRAB_FRAME_PARAMS { /*! * [in] Must be set to NVFBC_TOSYS_GRAB_FRAME_PARAMS_VER */ uint32_t dwVersion; /*! * [in] Flags defining the behavior of this frame capture. */ uint32_t dwFlags; /*! * [out] Information about the captured frame. * * Can be NULL. */ NVFBC_FRAME_GRAB_INFO *pFrameGrabInfo; /*! * [in] Wait timeout in milliseconds. * * When capturing frames with the NVFBC_TOSYS_GRAB_FLAGS_NOFLAGS or * NVFBC_TOSYS_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY flags, * NvFBC will wait for a new frame or mouse move until the below timer * expires. * * When timing out, the last captured frame will be returned. Note that as * long as the NVFBC_TOSYS_GRAB_FLAGS_FORCE_REFRESH flag is not set, * returning an old frame will incur no performance penalty. * * NvFBC clients can use the return value of the grab frame operation to * find out whether a new frame was captured, or the timer expired. * * Note that the behavior of blocking calls is to wait for a new frame * *after* the call has been made. When using timeouts, it is possible * that NvFBC will return a new frame (e.g., it has never been captured * before) even though no new frame was generated after the grab call. * * For the precise definition of what constitutes a new frame, see * ::bIsNewFrame. * * Set to 0 to disable timeouts. */ uint32_t dwTimeoutMs; } NVFBC_TOSYS_GRAB_FRAME_PARAMS; /*! * NVFBC_TOSYS_GRAB_FRAME_PARAMS structure version. */ #define NVFBC_TOSYS_GRAB_FRAME_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_TOSYS_GRAB_FRAME_PARAMS, 2) /*! * Defines flags that can be used when capturing to a CUDA buffer in video memory. */ typedef enum { /*! * Default, capturing waits for a new frame or mouse move. * * The default behavior of blocking grabs is to wait for a new frame until * after the call was made. But it's possible that there is a frame already * ready that the client hasn't seen. * \see NVFBC_TOCUDA_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY */ NVFBC_TOCUDA_GRAB_FLAGS_NOFLAGS = 0, /*! * Capturing does not wait for a new frame nor a mouse move. * * It is therefore possible to capture the same frame multiple times. * When this occurs, the dwCurrentFrame parameter of the * NVFBC_FRAME_GRAB_INFO structure is not incremented. */ NVFBC_TOCUDA_GRAB_FLAGS_NOWAIT = (1 << 0), /*! * [in] Forces the destination buffer to be refreshed even if the frame * has not changed since previous capture. * * By default, if the captured frame is identical to the previous one, NvFBC * will omit one copy and not update the destination buffer. * * Setting that flag will prevent this behavior. This can be useful e.g., * if the application has modified the buffer in the meantime. */ NVFBC_TOCUDA_GRAB_FLAGS_FORCE_REFRESH = (1 << 1), /*! * Similar to NVFBC_TOCUDA_GRAB_FLAGS_NOFLAGS, except that the capture will * not wait if there is already a frame available that the client has * never seen yet. */ NVFBC_TOCUDA_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY = (1 << 2), } NVFBC_TOCUDA_FLAGS; /*! * Defines parameters for the ::NvFBCToCudaSetUp() API call. */ typedef struct _NVFBC_TOCUDA_SETUP_PARAMS { /*! * [in] Must be set to NVFBC_TOCUDA_SETUP_PARAMS_VER */ uint32_t dwVersion; /*! * [in] Desired buffer format. */ NVFBC_BUFFER_FORMAT eBufferFormat; } NVFBC_TOCUDA_SETUP_PARAMS; /*! * NVFBC_TOCUDA_SETUP_PARAMS structure version. */ #define NVFBC_TOCUDA_SETUP_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_TOCUDA_SETUP_PARAMS, 1) /*! * Defines parameters for the ::NvFBCToCudaGrabFrame() API call. */ typedef struct _NVFBC_TOCUDA_GRAB_FRAME_PARAMS { /*! * [in] Must be set to NVFBC_TOCUDA_GRAB_FRAME_PARAMS_VER. */ uint32_t dwVersion; /*! * [in] Flags defining the behavior of this frame capture. */ uint32_t dwFlags; /*! * [out] Pointer to a ::CUdeviceptr * * The application does not need to allocate memory for this CUDA device. * * The application does need to create its own CUDA context to use this * CUDA device. * * This ::CUdeviceptr will be mapped to a segment in video memory containing * the frame. It is not possible to process a CUDA device while capturing * a new frame. If the application wants to do so, it must copy the CUDA * device using ::cuMemcpyDtoD or ::cuMemcpyDtoH beforehand. */ void *pCUDADeviceBuffer; /*! * [out] Information about the captured frame. * * Can be NULL. */ NVFBC_FRAME_GRAB_INFO *pFrameGrabInfo; /*! * [in] Wait timeout in milliseconds. * * When capturing frames with the NVFBC_TOCUDA_GRAB_FLAGS_NOFLAGS or * NVFBC_TOCUDA_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY flags, * NvFBC will wait for a new frame or mouse move until the below timer * expires. * * When timing out, the last captured frame will be returned. Note that as * long as the NVFBC_TOCUDA_GRAB_FLAGS_FORCE_REFRESH flag is not set, * returning an old frame will incur no performance penalty. * * NvFBC clients can use the return value of the grab frame operation to * find out whether a new frame was captured, or the timer expired. * * Note that the behavior of blocking calls is to wait for a new frame * *after* the call has been made. When using timeouts, it is possible * that NvFBC will return a new frame (e.g., it has never been captured * before) even though no new frame was generated after the grab call. * * For the precise definition of what constitutes a new frame, see * ::bIsNewFrame. * * Set to 0 to disable timeouts. */ uint32_t dwTimeoutMs; } NVFBC_TOCUDA_GRAB_FRAME_PARAMS; /*! * NVFBC_TOCUDA_GRAB_FRAME_PARAMS structure version. */ #define NVFBC_TOCUDA_GRAB_FRAME_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_TOCUDA_GRAB_FRAME_PARAMS, 2) /*! * Defines flags that can be used when capturing to an OpenGL buffer in video memory. */ typedef enum { /*! * Default, capturing waits for a new frame or mouse move. * * The default behavior of blocking grabs is to wait for a new frame until * after the call was made. But it's possible that there is a frame already * ready that the client hasn't seen. * \see NVFBC_TOGL_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY */ NVFBC_TOGL_GRAB_FLAGS_NOFLAGS = 0, /*! * Capturing does not wait for a new frame nor a mouse move. * * It is therefore possible to capture the same frame multiple times. * When this occurs, the dwCurrentFrame parameter of the * NVFBC_FRAME_GRAB_INFO structure is not incremented. */ NVFBC_TOGL_GRAB_FLAGS_NOWAIT = (1 << 0), /*! * [in] Forces the destination buffer to be refreshed even if the frame * has not changed since previous capture. * * By default, if the captured frame is identical to the previous one, NvFBC * will omit one copy and not update the destination buffer. * * Setting that flag will prevent this behavior. This can be useful e.g., * if the application has modified the buffer in the meantime. */ NVFBC_TOGL_GRAB_FLAGS_FORCE_REFRESH = (1 << 1), /*! * Similar to NVFBC_TOGL_GRAB_FLAGS_NOFLAGS, except that the capture will * not wait if there is already a frame available that the client has * never seen yet. */ NVFBC_TOGL_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY = (1 << 2), } NVFBC_TOGL_FLAGS; /*! * Maximum number of GL textures that can be used to store frames. */ #define NVFBC_TOGL_TEXTURES_MAX 2 /*! * Defines parameters for the ::NvFBCToGLSetUp() API call. */ typedef struct _NVFBC_TOGL_SETUP_PARAMS { /*! * [in] Must be set to NVFBC_TOGL_SETUP_PARAMS_VER */ uint32_t dwVersion; /*! * [in] Desired buffer format. */ NVFBC_BUFFER_FORMAT eBufferFormat; /*! * [in] Whether differential maps should be generated. */ NVFBC_BOOL bWithDiffMap; /*! * [out] Pointer to a pointer to a buffer in system memory. * * \see NVFBC_TOSYS_SETUP_PARAMS::ppDiffMap */ void **ppDiffMap; /*! * [in] Scaling factor of the differential maps. * * \see NVFBC_TOSYS_SETUP_PARAMS::dwDiffMapScalingFactor */ uint32_t dwDiffMapScalingFactor; /*! * [out] List of GL textures that will store the captured frames. * * This array is 0 terminated. The number of textures varies depending on * the capture settings (such as whether diffmaps are enabled). * * An application wishing to interop with, for example, EncodeAPI will need * to register these textures prior to start encoding frames. * * After each frame capture, the texture holding the current frame will be * returned in NVFBC_TOGL_GRAB_FRAME_PARAMS::dwTexture. */ uint32_t dwTextures[NVFBC_TOGL_TEXTURES_MAX]; /*! * [out] GL target to which the texture should be bound. */ uint32_t dwTexTarget; /*! * [out] GL format of the textures. */ uint32_t dwTexFormat; /*! * [out] GL type of the textures. */ uint32_t dwTexType; /*! * [out] Size of the differential map. * * Only set if bWithDiffMap is set to NVFBC_TRUE. */ NVFBC_SIZE diffMapSize; } NVFBC_TOGL_SETUP_PARAMS; /*! * NVFBC_TOGL_SETUP_PARAMS structure version. */ #define NVFBC_TOGL_SETUP_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_TOGL_SETUP_PARAMS, 2) /*! * Defines parameters for the ::NvFBCToGLGrabFrame() API call. */ typedef struct _NVFBC_TOGL_GRAB_FRAME_PARAMS { /*! * [in] Must be set to NVFBC_TOGL_GRAB_FRAME_PARAMS_VER. */ uint32_t dwVersion; /*! * [in] Flags defining the behavior of this frame capture. */ uint32_t dwFlags; /*! * [out] Index of the texture storing the current frame. * * This is an index in the NVFBC_TOGL_SETUP_PARAMS::dwTextures array. */ uint32_t dwTextureIndex; /*! * [out] Information about the captured frame. * * Can be NULL. */ NVFBC_FRAME_GRAB_INFO *pFrameGrabInfo; /*! * [in] Wait timeout in milliseconds. * * When capturing frames with the NVFBC_TOGL_GRAB_FLAGS_NOFLAGS or * NVFBC_TOGL_GRAB_FLAGS_NOWAIT_IF_NEW_FRAME_READY flags, * NvFBC will wait for a new frame or mouse move until the below timer * expires. * * When timing out, the last captured frame will be returned. Note that as * long as the NVFBC_TOGL_GRAB_FLAGS_FORCE_REFRESH flag is not set, * returning an old frame will incur no performance penalty. * * NvFBC clients can use the return value of the grab frame operation to * find out whether a new frame was captured, or the timer expired. * * Note that the behavior of blocking calls is to wait for a new frame * *after* the call has been made. When using timeouts, it is possible * that NvFBC will return a new frame (e.g., it has never been captured * before) even though no new frame was generated after the grab call. * * For the precise definition of what constitutes a new frame, see * ::bIsNewFrame. * * Set to 0 to disable timeouts. */ uint32_t dwTimeoutMs; } NVFBC_TOGL_GRAB_FRAME_PARAMS; /*! * NVFBC_TOGL_GRAB_FRAME_PARAMS structure version. */ #define NVFBC_TOGL_GRAB_FRAME_PARAMS_VER NVFBC_STRUCT_VERSION(NVFBC_TOGL_GRAB_FRAME_PARAMS, 2) /*! @} FBC_STRUCT */ /*! * \defgroup FBC_FUNC API Entry Points * * Entry points are thread-safe and can be called concurrently. * * The locking model includes a global lock that protects session handle * management (\see NvFBCCreateHandle, \see NvFBCDestroyHandle). * * Each NvFBC session uses a local lock to protect other entry points. Note * that in certain cases, a thread can hold the local lock for an undefined * amount of time, such as grabbing a frame using a blocking call. * * Note that a context is associated with each session. NvFBC clients wishing * to share a session between different threads are expected to release and * bind the context appropriately (\see NvFBCBindContext, * \see NvFBCReleaseContext). This is not required when each thread uses its * own NvFBC session. * * @{ */ /*! * Gets the last error message that got recorded for a client. * * When NvFBC returns an error, it will save an error message that can be * queried through this API call. Only the last message is saved. * The message and the return code should give enough information about * what went wrong. * * \param [in] sessionHandle * Handle to the NvFBC client. * \return * A NULL terminated error message, or an empty string. Its maximum length * is NVFBC_ERROR_STR_LEN. */ const char* NVFBCAPI NvFBCGetLastErrorStr(const NVFBC_SESSION_HANDLE sessionHandle); /*! * \brief Allocates a new handle for an NvFBC client. * * This function allocates a session handle used to identify an FBC client. * * This function implicitly calls NvFBCBindContext(). * * \param [out] pSessionHandle * Pointer that will hold the allocated session handle. * \param [in] pParams * ::NVFBC_CREATE_HANDLE_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_PTR \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_OUT_OF_MEMORY \n * ::NVFBC_ERR_MAX_CLIENTS \n * ::NVFBC_ERR_X \n * ::NVFBC_ERR_GLX \n * ::NVFBC_ERR_GL * */ NVFBCSTATUS NVFBCAPI NvFBCCreateHandle(NVFBC_SESSION_HANDLE *pSessionHandle, NVFBC_CREATE_HANDLE_PARAMS *pParams); /*! * \brief Destroys the handle of an NvFBC client. * * This function uninitializes an FBC client. * * This function implicitly calls NvFBCReleaseContext(). * * After this fucntion returns, it is not possible to use this session handle * for any further API call. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_DESTROY_HANDLE_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCDestroyHandle(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_DESTROY_HANDLE_PARAMS *pParams); /*! * \brief Gets the current status of the display driver. * * This function queries the display driver for various information. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_GET_STATUS_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCGetStatus(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_GET_STATUS_PARAMS *pParams); /*! * \brief Binds the FBC context to the calling thread. * * The NvFBC library internally relies on objects that must be bound to a * thread. Such objects are OpenGL contexts and CUDA contexts. * * This function binds these objects to the calling thread. * * The FBC context must be bound to the calling thread for most NvFBC entry * points, otherwise ::NVFBC_ERR_CONTEXT is returned. * * If the FBC context is already bound to a different thread, * ::NVFBC_ERR_CONTEXT is returned. The other thread must release the context * first by calling the ReleaseContext() entry point. * * If the FBC context is already bound to the current thread, this function has * no effects. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_DESTROY_CAPTURE_SESSION_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCBindContext(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_BIND_CONTEXT_PARAMS *pParams); /*! * \brief Releases the FBC context from the calling thread. * * If the FBC context is bound to a different thread, ::NVFBC_ERR_CONTEXT is * returned. * * If the FBC context is already released, this functino has no effects. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCReleaseContext(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_RELEASE_CONTEXT_PARAMS *pParams); /*! * \brief Creates a capture session for an FBC client. * * This function starts a capture session of the desired type (system memory, * video memory with CUDA interop, or H.264 compressed frames in system memory). * * Not all types are supported on all systems. Also, it is possible to use * NvFBC without having the CUDA library. In this case, requesting a capture * session of the concerned type will return an error. * * After this function returns, the display driver will start generating frames * that can be captured using the corresponding API call. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_CREATE_CAPTURE_SESSION_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_INVALID_PARAM \n * ::NVFBC_ERR_OUT_OF_MEMORY \n * ::NVFBC_ERR_X \n * ::NVFBC_ERR_GLX \n * ::NVFBC_ERR_GL \n * ::NVFBC_ERR_CUDA \n * ::NVFBC_ERR_MUST_RECREATE \n * ::NVFBC_ERR_INTERNAL */ NVFBCSTATUS NVFBCAPI NvFBCCreateCaptureSession(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_CREATE_CAPTURE_SESSION_PARAMS *pParams); /*! * \brief Destroys a capture session for an FBC client. * * This function stops a capture session and frees allocated objects. * * After this function returns, it is possible to create another capture * session using the corresponding API call. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_DESTROY_CAPTURE_SESSION_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCDestroyCaptureSession(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_DESTROY_CAPTURE_SESSION_PARAMS *pParams); /*! * \brief Sets up a capture to system memory session. * * This function configures how the capture to system memory should behave. It * can be called anytime and several times after the capture session has been * created. However, it must be called at least once prior to start capturing * frames. * * This function allocates the buffer that will contain the captured frame. * The application does not need to free this buffer. The size of this buffer * is returned in the ::NVFBC_FRAME_GRAB_INFO structure. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_TOSYS_SETUP_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_UNSUPPORTED \n * ::NVFBC_ERR_INVALID_PTR \n * ::NVFBC_ERR_INVALID_PARAM \n * ::NVFBC_ERR_OUT_OF_MEMORY \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCToSysSetUp(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOSYS_SETUP_PARAMS *pParams); /*! * \brief Captures a frame to a buffer in system memory. * * This function triggers a frame capture to a buffer in system memory that was * registered with the ToSysSetUp() API call. * * Note that it is possible that the resolution of the desktop changes while * capturing frames. This should be transparent for the application. * * When the resolution changes, the capture session is recreated using the same * parameters, and necessary buffers are re-allocated. The frame counter is not * reset. * * An application can detect that the resolution changed by comparing the * dwByteSize member of the ::NVFBC_FRAME_GRAB_INFO against a previous * frame and/or dwWidth and dwHeight. * * During a change of resolution the capture is paused even in asynchronous * mode. * * \param [in] sessionHandle * FBC session handle. * \param [in] pParams * ::NVFBC_TOSYS_GRAB_FRAME_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_INVALID_PTR \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_X \n * ::NVFBC_ERR_MUST_RECREATE \n * \see NvFBCCreateCaptureSession \n * \see NvFBCToSysSetUp */ NVFBCSTATUS NVFBCAPI NvFBCToSysGrabFrame(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOSYS_GRAB_FRAME_PARAMS *pParams); /*! * \brief Sets up a capture to video memory session. * * This function configures how the capture to video memory with CUDA interop * should behave. It can be called anytime and several times after the capture * session has been created. However, it must be called at least once prior * to start capturing frames. * * \param [in] sessionHandle * FBC session handle. * * \param [in] pParams * ::NVFBC_TOCUDA_SETUP_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_UNSUPPORTED \n * ::NVFBC_ERR_GL \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCToCudaSetUp(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOCUDA_SETUP_PARAMS *pParams); /*! * \brief Captures a frame to a CUDA device in video memory. * * This function triggers a frame capture to a CUDA device in video memory. * * Note about changes of resolution: \see NvFBCToSysGrabFrame * * \param [in] sessionHandle * FBC session handle. * * \param [in] pParams * ::NVFBC_TOCUDA_GRAB_FRAME_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_INVALID_PTR \n * ::NVFBC_ERR_CUDA \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_X \n * ::NVFBC_ERR_MUST_RECREATE \n * \see NvFBCCreateCaptureSession \n * \see NvFBCToCudaSetUp */ NVFBCSTATUS NVFBCAPI NvFBCToCudaGrabFrame(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOCUDA_GRAB_FRAME_PARAMS *pParams); /*! * \brief Sets up a capture to OpenGL buffer in video memory session. * * This function configures how the capture to video memory should behave. * It can be called anytime and several times after the capture session has been * created. However, it must be called at least once prior to start capturing * frames. * * \param [in] sessionHandle * FBC session handle. * * \param [in] pParams * ::NVFBC_TOGL_SETUP_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_UNSUPPORTED \n * ::NVFBC_ERR_GL \n * ::NVFBC_ERR_X */ NVFBCSTATUS NVFBCAPI NvFBCToGLSetUp(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOGL_SETUP_PARAMS *pParams); /*! * \brief Captures a frame to an OpenGL buffer in video memory. * * This function triggers a frame capture to a selected resource in video memory. * * Note about changes of resolution: \see NvFBCToSysGrabFrame * * \param [in] sessionHandle * FBC session handle. * * \param [in] pParams * ::NVFBC_TOGL_GRAB_FRAME_PARAMS * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_HANDLE \n * ::NVFBC_ERR_API_VERSION \n * ::NVFBC_ERR_BAD_REQUEST \n * ::NVFBC_ERR_CONTEXT \n * ::NVFBC_ERR_INVALID_PTR \n * ::NVFBC_ERR_INTERNAL \n * ::NVFBC_ERR_X \n * ::NVFBC_ERR_MUST_RECREATE \n * \see NvFBCCreateCaptureSession \n * \see NvFBCToCudaSetUp */ NVFBCSTATUS NVFBCAPI NvFBCToGLGrabFrame(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOGL_GRAB_FRAME_PARAMS *pParams); /*! * \cond FBC_PFN * * Defines API function pointers */ typedef const char* (NVFBCAPI* PNVFBCGETLASTERRORSTR)(const NVFBC_SESSION_HANDLE sessionHandle); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCCREATEHANDLE)(NVFBC_SESSION_HANDLE *pSessionHandle, NVFBC_CREATE_HANDLE_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCDESTROYHANDLE)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_DESTROY_HANDLE_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCBINDCONTEXT)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_BIND_CONTEXT_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCRELEASECONTEXT)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_RELEASE_CONTEXT_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCGETSTATUS)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_GET_STATUS_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCCREATECAPTURESESSION)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_CREATE_CAPTURE_SESSION_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCDESTROYCAPTURESESSION)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_DESTROY_CAPTURE_SESSION_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCTOSYSSETUP)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOSYS_SETUP_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCTOSYSGRABFRAME)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOSYS_GRAB_FRAME_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCTOCUDASETUP)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOCUDA_SETUP_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCTOCUDAGRABFRAME)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOCUDA_GRAB_FRAME_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCTOGLSETUP)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOGL_SETUP_PARAMS *pParams); typedef NVFBCSTATUS (NVFBCAPI* PNVFBCTOGLGRABFRAME)(const NVFBC_SESSION_HANDLE sessionHandle, NVFBC_TOGL_GRAB_FRAME_PARAMS *pParams); /// \endcond /*! @} FBC_FUNC */ /*! * \ingroup FBC_STRUCT * * Structure populated with API function pointers. */ typedef struct { uint32_t dwVersion; //!< [in] Must be set to NVFBC_VERSION. PNVFBCGETLASTERRORSTR nvFBCGetLastErrorStr; //!< [out] Pointer to ::NvFBCGetLastErrorStr(). PNVFBCCREATEHANDLE nvFBCCreateHandle; //!< [out] Pointer to ::NvFBCCreateHandle(). PNVFBCDESTROYHANDLE nvFBCDestroyHandle; //!< [out] Pointer to ::NvFBCDestroyHandle(). PNVFBCGETSTATUS nvFBCGetStatus; //!< [out] Pointer to ::NvFBCGetStatus(). PNVFBCCREATECAPTURESESSION nvFBCCreateCaptureSession; //!< [out] Pointer to ::NvFBCCreateCaptureSession(). PNVFBCDESTROYCAPTURESESSION nvFBCDestroyCaptureSession; //!< [out] Pointer to ::NvFBCDestroyCaptureSession(). PNVFBCTOSYSSETUP nvFBCToSysSetUp; //!< [out] Pointer to ::NvFBCToSysSetUp(). PNVFBCTOSYSGRABFRAME nvFBCToSysGrabFrame; //!< [out] Pointer to ::NvFBCToSysGrabFrame(). PNVFBCTOCUDASETUP nvFBCToCudaSetUp; //!< [out] Pointer to ::NvFBCToCudaSetUp(). PNVFBCTOCUDAGRABFRAME nvFBCToCudaGrabFrame; //!< [out] Pointer to ::NvFBCToCudaGrabFrame(). void* pad1; //!< [out] Retired. Do not use. void* pad2; //!< [out] Retired. Do not use. void* pad3; //!< [out] Retired. Do not use. PNVFBCBINDCONTEXT nvFBCBindContext; //!< [out] Pointer to ::NvFBCBindContext(). PNVFBCRELEASECONTEXT nvFBCReleaseContext; //!< [out] Pointer to ::NvFBCReleaseContext(). void* pad4; //!< [out] Retired. Do not use. void* pad5; //!< [out] Retired. Do not use. void* pad6; //!< [out] Retired. Do not use. void* pad7; //!< [out] Retired. Do not use. PNVFBCTOGLSETUP nvFBCToGLSetUp; //!< [out] Pointer to ::nvFBCToGLSetup(). PNVFBCTOGLGRABFRAME nvFBCToGLGrabFrame; //!< [out] Pointer to ::nvFBCToGLGrabFrame(). } NVFBC_API_FUNCTION_LIST; /*! * \ingroup FBC_FUNC * * \brief Entry Points to the NvFBC interface. * * Creates an instance of the NvFBC interface, and populates the * pFunctionList with function pointers to the API routines implemented by * the NvFBC interface. * * \param [out] pFunctionList * * \return * ::NVFBC_SUCCESS \n * ::NVFBC_ERR_INVALID_PTR \n * ::NVFBC_ERR_API_VERSION */ NVFBCSTATUS NVFBCAPI NvFBCCreateInstance(NVFBC_API_FUNCTION_LIST *pFunctionList); /*! * \ingroup FBC_FUNC * * Defines function pointer for the ::NvFBCCreateInstance() API call. */ typedef NVFBCSTATUS (NVFBCAPI* PNVFBCCREATEINSTANCE)(NVFBC_API_FUNCTION_LIST *pFunctionList); #ifdef __cplusplus } #endif #endif // _NVFBC_H_ fsdsfdsfdsfdsf-5.13.8/external/nvEncodeAPI.h000066400000000000000000010374151520215207700207060ustar00rootroot00000000000000/* * This copyright notice applies to this header file only: * * Copyright (c) 2010-2022 NVIDIA Corporation * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the software, and to permit persons to whom the * software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ /** * \file nvEncodeAPI.h * NVIDIA GPUs - beginning with the Kepler generation - contain a hardware-based encoder * (referred to as NVENC) which provides fully-accelerated hardware-based video encoding. * NvEncodeAPI provides the interface for NVIDIA video encoder (NVENC). * \date 2011-2022 * This file contains the interface constants, structure definitions and function prototypes. */ #ifndef _NV_ENCODEAPI_H_ #define _NV_ENCODEAPI_H_ #include #ifdef _WIN32 #include #endif #ifdef _MSC_VER #ifndef _STDINT typedef __int32 int32_t; typedef unsigned __int32 uint32_t; typedef __int64 int64_t; typedef unsigned __int64 uint64_t; typedef signed char int8_t; typedef unsigned char uint8_t; typedef short int16_t; typedef unsigned short uint16_t; #endif #else #include #endif #ifdef __cplusplus extern "C" { #endif /** * \addtogroup ENCODER_STRUCTURE NvEncodeAPI Data structures * @{ */ #if defined(_WIN32) || defined(__CYGWIN__) #define NVENCAPI __stdcall #else #define NVENCAPI #endif #ifdef _WIN32 typedef RECT NVENC_RECT; #else #define NVENCAPI // ========================================================================================= #if !defined(GUID) && !defined(GUID_DEFINED) #define GUID_DEFINED /*! * \struct GUID * Abstracts the GUID structure for non-windows platforms. */ // ========================================================================================= typedef struct _GUID { uint32_t Data1; /**< [in]: Specifies the first 8 hexadecimal digits of the GUID. */ uint16_t Data2; /**< [in]: Specifies the first group of 4 hexadecimal digits. */ uint16_t Data3; /**< [in]: Specifies the second group of 4 hexadecimal digits. */ uint8_t Data4[8]; /**< [in]: Array of 8 bytes. The first 2 bytes contain the third group of 4 hexadecimal digits. The remaining 6 bytes contain the final 12 hexadecimal digits. */ } GUID, *LPGUID; #endif // GUID /** * \struct _NVENC_RECT * Defines a Rectangle. Used in ::NV_ENC_PREPROCESS_FRAME. */ typedef struct _NVENC_RECT { uint32_t left; /**< [in]: X coordinate of the upper left corner of rectangular area to be specified. */ uint32_t top; /**< [in]: Y coordinate of the upper left corner of the rectangular area to be specified. */ uint32_t right; /**< [in]: X coordinate of the bottom right corner of the rectangular area to be specified. */ uint32_t bottom; /**< [in]: Y coordinate of the bottom right corner of the rectangular area to be specified. */ } NVENC_RECT; #endif // _WIN32 /** @} */ /* End of GUID and NVENC_RECT structure grouping*/ typedef void* NV_ENC_INPUT_PTR; /**< NVENCODE API input buffer */ typedef void* NV_ENC_OUTPUT_PTR; /**< NVENCODE API output buffer*/ typedef void* NV_ENC_REGISTERED_PTR; /**< A Resource that has been registered with NVENCODE API*/ typedef void* NV_ENC_CUSTREAM_PTR; /**< Pointer to CUstream*/ #define NVENCAPI_MAJOR_VERSION 12 #define NVENCAPI_MINOR_VERSION 0 #define NVENCAPI_VERSION (NVENCAPI_MAJOR_VERSION | (NVENCAPI_MINOR_VERSION << 24)) /** * Macro to generate per-structure version for use with API. */ #define NVENCAPI_STRUCT_VERSION(ver) ((uint32_t)NVENCAPI_VERSION | ((ver)<<16) | (0x7 << 28)) #define NVENC_INFINITE_GOPLENGTH 0xffffffff #define NV_MAX_SEQ_HDR_LEN (512) #ifdef __GNUC__ #define NV_ENC_DEPRECATED __attribute__ ((deprecated("WILL BE REMOVED IN A FUTURE VIDEO CODEC SDK VERSION"))) #elif defined(_MSC_VER) #define NV_ENC_DEPRECATED __declspec(deprecated("WILL BE REMOVED IN A FUTURE VIDEO CODEC SDK VERSION")) #endif // ========================================================================================= // Encode Codec GUIDS supported by the NvEncodeAPI interface. // ========================================================================================= // {6BC82762-4E63-4ca4-AA85-1E50F321F6BF} static const GUID NV_ENC_CODEC_H264_GUID = { 0x6bc82762, 0x4e63, 0x4ca4, { 0xaa, 0x85, 0x1e, 0x50, 0xf3, 0x21, 0xf6, 0xbf } }; // {790CDC88-4522-4d7b-9425-BDA9975F7603} static const GUID NV_ENC_CODEC_HEVC_GUID = { 0x790cdc88, 0x4522, 0x4d7b, { 0x94, 0x25, 0xbd, 0xa9, 0x97, 0x5f, 0x76, 0x3 } }; // {0A352289-0AA7-4759-862D-5D15CD16D254} static const GUID NV_ENC_CODEC_AV1_GUID = { 0x0a352289, 0x0aa7, 0x4759, { 0x86, 0x2d, 0x5d, 0x15, 0xcd, 0x16, 0xd2, 0x54 } }; // ========================================================================================= // * Encode Profile GUIDS supported by the NvEncodeAPI interface. // ========================================================================================= // {BFD6F8E7-233C-4341-8B3E-4818523803F4} static const GUID NV_ENC_CODEC_PROFILE_AUTOSELECT_GUID = { 0xbfd6f8e7, 0x233c, 0x4341, { 0x8b, 0x3e, 0x48, 0x18, 0x52, 0x38, 0x3, 0xf4 } }; // {0727BCAA-78C4-4c83-8C2F-EF3DFF267C6A} static const GUID NV_ENC_H264_PROFILE_BASELINE_GUID = { 0x727bcaa, 0x78c4, 0x4c83, { 0x8c, 0x2f, 0xef, 0x3d, 0xff, 0x26, 0x7c, 0x6a } }; // {60B5C1D4-67FE-4790-94D5-C4726D7B6E6D} static const GUID NV_ENC_H264_PROFILE_MAIN_GUID = { 0x60b5c1d4, 0x67fe, 0x4790, { 0x94, 0xd5, 0xc4, 0x72, 0x6d, 0x7b, 0x6e, 0x6d } }; // {E7CBC309-4F7A-4b89-AF2A-D537C92BE310} static const GUID NV_ENC_H264_PROFILE_HIGH_GUID = { 0xe7cbc309, 0x4f7a, 0x4b89, { 0xaf, 0x2a, 0xd5, 0x37, 0xc9, 0x2b, 0xe3, 0x10 } }; // {7AC663CB-A598-4960-B844-339B261A7D52} static const GUID NV_ENC_H264_PROFILE_HIGH_444_GUID = { 0x7ac663cb, 0xa598, 0x4960, { 0xb8, 0x44, 0x33, 0x9b, 0x26, 0x1a, 0x7d, 0x52 } }; // {40847BF5-33F7-4601-9084-E8FE3C1DB8B7} static const GUID NV_ENC_H264_PROFILE_STEREO_GUID = { 0x40847bf5, 0x33f7, 0x4601, { 0x90, 0x84, 0xe8, 0xfe, 0x3c, 0x1d, 0xb8, 0xb7 } }; // {B405AFAC-F32B-417B-89C4-9ABEED3E5978} static const GUID NV_ENC_H264_PROFILE_PROGRESSIVE_HIGH_GUID = { 0xb405afac, 0xf32b, 0x417b, { 0x89, 0xc4, 0x9a, 0xbe, 0xed, 0x3e, 0x59, 0x78 } }; // {AEC1BD87-E85B-48f2-84C3-98BCA6285072} static const GUID NV_ENC_H264_PROFILE_CONSTRAINED_HIGH_GUID = { 0xaec1bd87, 0xe85b, 0x48f2, { 0x84, 0xc3, 0x98, 0xbc, 0xa6, 0x28, 0x50, 0x72 } }; // {B514C39A-B55B-40fa-878F-F1253B4DFDEC} static const GUID NV_ENC_HEVC_PROFILE_MAIN_GUID = { 0xb514c39a, 0xb55b, 0x40fa, { 0x87, 0x8f, 0xf1, 0x25, 0x3b, 0x4d, 0xfd, 0xec } }; // {fa4d2b6c-3a5b-411a-8018-0a3f5e3c9be5} static const GUID NV_ENC_HEVC_PROFILE_MAIN10_GUID = { 0xfa4d2b6c, 0x3a5b, 0x411a, { 0x80, 0x18, 0x0a, 0x3f, 0x5e, 0x3c, 0x9b, 0xe5 } }; // For HEVC Main 444 8 bit and HEVC Main 444 10 bit profiles only // {51ec32b5-1b4c-453c-9cbd-b616bd621341} static const GUID NV_ENC_HEVC_PROFILE_FREXT_GUID = { 0x51ec32b5, 0x1b4c, 0x453c, { 0x9c, 0xbd, 0xb6, 0x16, 0xbd, 0x62, 0x13, 0x41 } }; // {5f2a39f5-f14e-4f95-9a9e-b76d568fcf97} static const GUID NV_ENC_AV1_PROFILE_MAIN_GUID = { 0x5f2a39f5, 0xf14e, 0x4f95, { 0x9a, 0x9e, 0xb7, 0x6d, 0x56, 0x8f, 0xcf, 0x97 } }; // ========================================================================================= // * Preset GUIDS supported by the NvEncodeAPI interface. // ========================================================================================= // {B2DFB705-4EBD-4C49-9B5F-24A777D3E587} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_DEFAULT_GUID = { 0xb2dfb705, 0x4ebd, 0x4c49, { 0x9b, 0x5f, 0x24, 0xa7, 0x77, 0xd3, 0xe5, 0x87 } }; // {60E4C59F-E846-4484-A56D-CD45BE9FDDF6} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_HP_GUID = { 0x60e4c59f, 0xe846, 0x4484, { 0xa5, 0x6d, 0xcd, 0x45, 0xbe, 0x9f, 0xdd, 0xf6 } }; // {34DBA71D-A77B-4B8F-9C3E-B6D5DA24C012} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_HQ_GUID = { 0x34dba71d, 0xa77b, 0x4b8f, { 0x9c, 0x3e, 0xb6, 0xd5, 0xda, 0x24, 0xc0, 0x12 } }; // {82E3E450-BDBB-4e40-989C-82A90DF9EF32} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_BD_GUID = { 0x82e3e450, 0xbdbb, 0x4e40, { 0x98, 0x9c, 0x82, 0xa9, 0xd, 0xf9, 0xef, 0x32 } }; // {49DF21C5-6DFA-4feb-9787-6ACC9EFFB726} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_LOW_LATENCY_DEFAULT_GUID = { 0x49df21c5, 0x6dfa, 0x4feb, { 0x97, 0x87, 0x6a, 0xcc, 0x9e, 0xff, 0xb7, 0x26 } }; // {C5F733B9-EA97-4cf9-BEC2-BF78A74FD105} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_LOW_LATENCY_HQ_GUID = { 0xc5f733b9, 0xea97, 0x4cf9, { 0xbe, 0xc2, 0xbf, 0x78, 0xa7, 0x4f, 0xd1, 0x5 } }; // {67082A44-4BAD-48FA-98EA-93056D150A58} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_LOW_LATENCY_HP_GUID = { 0x67082a44, 0x4bad, 0x48fa, { 0x98, 0xea, 0x93, 0x5, 0x6d, 0x15, 0xa, 0x58 } }; // {D5BFB716-C604-44e7-9BB8-DEA5510FC3AC} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_LOSSLESS_DEFAULT_GUID = { 0xd5bfb716, 0xc604, 0x44e7, { 0x9b, 0xb8, 0xde, 0xa5, 0x51, 0xf, 0xc3, 0xac } }; // {149998E7-2364-411d-82EF-179888093409} NV_ENC_DEPRECATED static const GUID NV_ENC_PRESET_LOSSLESS_HP_GUID = { 0x149998e7, 0x2364, 0x411d, { 0x82, 0xef, 0x17, 0x98, 0x88, 0x9, 0x34, 0x9 } }; // Performance degrades and quality improves as we move from P1 to P7. Presets P3 to P7 for H264 and Presets P2 to P7 for HEVC have B frames enabled by default // for HIGH_QUALITY and LOSSLESS tuning info, and will not work with Weighted Prediction enabled. In case Weighted Prediction is required, disable B frames by // setting frameIntervalP = 1 // {FC0A8D3E-45F8-4CF8-80C7-298871590EBF} static const GUID NV_ENC_PRESET_P1_GUID = { 0xfc0a8d3e, 0x45f8, 0x4cf8, { 0x80, 0xc7, 0x29, 0x88, 0x71, 0x59, 0xe, 0xbf } }; // {F581CFB8-88D6-4381-93F0-DF13F9C27DAB} static const GUID NV_ENC_PRESET_P2_GUID = { 0xf581cfb8, 0x88d6, 0x4381, { 0x93, 0xf0, 0xdf, 0x13, 0xf9, 0xc2, 0x7d, 0xab } }; // {36850110-3A07-441F-94D5-3670631F91F6} static const GUID NV_ENC_PRESET_P3_GUID = { 0x36850110, 0x3a07, 0x441f, { 0x94, 0xd5, 0x36, 0x70, 0x63, 0x1f, 0x91, 0xf6 } }; // {90A7B826-DF06-4862-B9D2-CD6D73A08681} static const GUID NV_ENC_PRESET_P4_GUID = { 0x90a7b826, 0xdf06, 0x4862, { 0xb9, 0xd2, 0xcd, 0x6d, 0x73, 0xa0, 0x86, 0x81 } }; // {21C6E6B4-297A-4CBA-998F-B6CBDE72ADE3} static const GUID NV_ENC_PRESET_P5_GUID = { 0x21c6e6b4, 0x297a, 0x4cba, { 0x99, 0x8f, 0xb6, 0xcb, 0xde, 0x72, 0xad, 0xe3 } }; // {8E75C279-6299-4AB6-8302-0B215A335CF5} static const GUID NV_ENC_PRESET_P6_GUID = { 0x8e75c279, 0x6299, 0x4ab6, { 0x83, 0x2, 0xb, 0x21, 0x5a, 0x33, 0x5c, 0xf5 } }; // {84848C12-6F71-4C13-931B-53E283F57974} static const GUID NV_ENC_PRESET_P7_GUID = { 0x84848c12, 0x6f71, 0x4c13, { 0x93, 0x1b, 0x53, 0xe2, 0x83, 0xf5, 0x79, 0x74 } }; /** * \addtogroup ENCODER_STRUCTURE NvEncodeAPI Data structures * @{ */ /** * Input frame encode modes */ typedef enum _NV_ENC_PARAMS_FRAME_FIELD_MODE { NV_ENC_PARAMS_FRAME_FIELD_MODE_FRAME = 0x01, /**< Frame mode */ NV_ENC_PARAMS_FRAME_FIELD_MODE_FIELD = 0x02, /**< Field mode */ NV_ENC_PARAMS_FRAME_FIELD_MODE_MBAFF = 0x03 /**< MB adaptive frame/field */ } NV_ENC_PARAMS_FRAME_FIELD_MODE; /** * Rate Control Modes */ typedef enum _NV_ENC_PARAMS_RC_MODE { NV_ENC_PARAMS_RC_CONSTQP = 0x0, /**< Constant QP mode */ NV_ENC_PARAMS_RC_VBR = 0x1, /**< Variable bitrate mode */ NV_ENC_PARAMS_RC_CBR = 0x2, /**< Constant bitrate mode */ NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ = 0x8, /**< Deprecated, use NV_ENC_PARAMS_RC_CBR + NV_ENC_TWO_PASS_QUARTER_RESOLUTION / NV_ENC_TWO_PASS_FULL_RESOLUTION + lowDelayKeyFrameScale=1 */ NV_ENC_PARAMS_RC_CBR_HQ = 0x10, /**< Deprecated, use NV_ENC_PARAMS_RC_CBR + NV_ENC_TWO_PASS_QUARTER_RESOLUTION / NV_ENC_TWO_PASS_FULL_RESOLUTION */ NV_ENC_PARAMS_RC_VBR_HQ = 0x20 /**< Deprecated, use NV_ENC_PARAMS_RC_VBR + NV_ENC_TWO_PASS_QUARTER_RESOLUTION / NV_ENC_TWO_PASS_FULL_RESOLUTION */ } NV_ENC_PARAMS_RC_MODE; /** * Multi Pass encoding */ typedef enum _NV_ENC_MULTI_PASS { NV_ENC_MULTI_PASS_DISABLED = 0x0, /**< Single Pass */ NV_ENC_TWO_PASS_QUARTER_RESOLUTION = 0x1, /**< Two Pass encoding is enabled where first Pass is quarter resolution */ NV_ENC_TWO_PASS_FULL_RESOLUTION = 0x2, /**< Two Pass encoding is enabled where first Pass is full resolution */ } NV_ENC_MULTI_PASS; /** * Emphasis Levels */ typedef enum _NV_ENC_EMPHASIS_MAP_LEVEL { NV_ENC_EMPHASIS_MAP_LEVEL_0 = 0x0, /**< Emphasis Map Level 0, for zero Delta QP value */ NV_ENC_EMPHASIS_MAP_LEVEL_1 = 0x1, /**< Emphasis Map Level 1, for very low Delta QP value */ NV_ENC_EMPHASIS_MAP_LEVEL_2 = 0x2, /**< Emphasis Map Level 2, for low Delta QP value */ NV_ENC_EMPHASIS_MAP_LEVEL_3 = 0x3, /**< Emphasis Map Level 3, for medium Delta QP value */ NV_ENC_EMPHASIS_MAP_LEVEL_4 = 0x4, /**< Emphasis Map Level 4, for high Delta QP value */ NV_ENC_EMPHASIS_MAP_LEVEL_5 = 0x5 /**< Emphasis Map Level 5, for very high Delta QP value */ } NV_ENC_EMPHASIS_MAP_LEVEL; /** * QP MAP MODE */ typedef enum _NV_ENC_QP_MAP_MODE { NV_ENC_QP_MAP_DISABLED = 0x0, /**< Value in NV_ENC_PIC_PARAMS::qpDeltaMap have no effect. */ NV_ENC_QP_MAP_EMPHASIS = 0x1, /**< Value in NV_ENC_PIC_PARAMS::qpDeltaMap will be treated as Emphasis level. Currently this is only supported for H264 */ NV_ENC_QP_MAP_DELTA = 0x2, /**< Value in NV_ENC_PIC_PARAMS::qpDeltaMap will be treated as QP delta map. */ NV_ENC_QP_MAP = 0x3, /**< Currently This is not supported. Value in NV_ENC_PIC_PARAMS::qpDeltaMap will be treated as QP value. */ } NV_ENC_QP_MAP_MODE; #define NV_ENC_PARAMS_RC_VBR_MINQP (NV_ENC_PARAMS_RC_MODE)0x4 /**< Deprecated */ #define NV_ENC_PARAMS_RC_2_PASS_QUALITY NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ /**< Deprecated */ #define NV_ENC_PARAMS_RC_2_PASS_FRAMESIZE_CAP NV_ENC_PARAMS_RC_CBR_HQ /**< Deprecated */ #define NV_ENC_PARAMS_RC_2_PASS_VBR NV_ENC_PARAMS_RC_VBR_HQ /**< Deprecated */ #define NV_ENC_PARAMS_RC_CBR2 NV_ENC_PARAMS_RC_CBR /**< Deprecated */ /** * Input picture structure */ typedef enum _NV_ENC_PIC_STRUCT { NV_ENC_PIC_STRUCT_FRAME = 0x01, /**< Progressive frame */ NV_ENC_PIC_STRUCT_FIELD_TOP_BOTTOM = 0x02, /**< Field encoding top field first */ NV_ENC_PIC_STRUCT_FIELD_BOTTOM_TOP = 0x03 /**< Field encoding bottom field first */ } NV_ENC_PIC_STRUCT; /** * Display picture structure * Currently, this enum is only used for deciding the number of clock timestamp sets in Picture Timing SEI / Time Code SEI * Otherwise, this has no impact on encoder behavior */ typedef enum _NV_ENC_DISPLAY_PIC_STRUCT { NV_ENC_PIC_STRUCT_DISPLAY_FRAME = 0x00, /**< Field encoding top field first */ NV_ENC_PIC_STRUCT_DISPLAY_FIELD_TOP_BOTTOM = 0x01, /**< Field encoding top field first */ NV_ENC_PIC_STRUCT_DISPLAY_FIELD_BOTTOM_TOP = 0x02, /**< Field encoding bottom field first */ NV_ENC_PIC_STRUCT_DISPLAY_FRAME_DOUBLING = 0x03, /**< Frame doubling */ NV_ENC_PIC_STRUCT_DISPLAY_FRAME_TRIPLING = 0x04 /**< Field tripling */ } NV_ENC_DISPLAY_PIC_STRUCT; /** * Input picture type */ typedef enum _NV_ENC_PIC_TYPE { NV_ENC_PIC_TYPE_P = 0x0, /**< Forward predicted */ NV_ENC_PIC_TYPE_B = 0x01, /**< Bi-directionally predicted picture */ NV_ENC_PIC_TYPE_I = 0x02, /**< Intra predicted picture */ NV_ENC_PIC_TYPE_IDR = 0x03, /**< IDR picture */ NV_ENC_PIC_TYPE_BI = 0x04, /**< Bi-directionally predicted with only Intra MBs */ NV_ENC_PIC_TYPE_SKIPPED = 0x05, /**< Picture is skipped */ NV_ENC_PIC_TYPE_INTRA_REFRESH = 0x06, /**< First picture in intra refresh cycle */ NV_ENC_PIC_TYPE_NONREF_P = 0x07, /**< Non reference P picture */ NV_ENC_PIC_TYPE_UNKNOWN = 0xFF /**< Picture type unknown */ } NV_ENC_PIC_TYPE; /** * Motion vector precisions */ typedef enum _NV_ENC_MV_PRECISION { NV_ENC_MV_PRECISION_DEFAULT = 0x0, /**< Driver selects Quarter-Pel motion vector precision by default */ NV_ENC_MV_PRECISION_FULL_PEL = 0x01, /**< Full-Pel motion vector precision */ NV_ENC_MV_PRECISION_HALF_PEL = 0x02, /**< Half-Pel motion vector precision */ NV_ENC_MV_PRECISION_QUARTER_PEL = 0x03 /**< Quarter-Pel motion vector precision */ } NV_ENC_MV_PRECISION; /** * Input buffer formats */ typedef enum _NV_ENC_BUFFER_FORMAT { NV_ENC_BUFFER_FORMAT_UNDEFINED = 0x00000000, /**< Undefined buffer format */ NV_ENC_BUFFER_FORMAT_NV12 = 0x00000001, /**< Semi-Planar YUV [Y plane followed by interleaved UV plane] */ NV_ENC_BUFFER_FORMAT_YV12 = 0x00000010, /**< Planar YUV [Y plane followed by V and U planes] */ NV_ENC_BUFFER_FORMAT_IYUV = 0x00000100, /**< Planar YUV [Y plane followed by U and V planes] */ NV_ENC_BUFFER_FORMAT_YUV444 = 0x00001000, /**< Planar YUV [Y plane followed by U and V planes] */ NV_ENC_BUFFER_FORMAT_YUV420_10BIT = 0x00010000, /**< 10 bit Semi-Planar YUV [Y plane followed by interleaved UV plane]. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data. */ NV_ENC_BUFFER_FORMAT_YUV444_10BIT = 0x00100000, /**< 10 bit Planar YUV444 [Y plane followed by U and V planes]. Each pixel of size 2 bytes. Most Significant 10 bits contain pixel data. */ NV_ENC_BUFFER_FORMAT_ARGB = 0x01000000, /**< 8 bit Packed A8R8G8B8. This is a word-ordered format where a pixel is represented by a 32-bit word with B in the lowest 8 bits, G in the next 8 bits, R in the 8 bits after that and A in the highest 8 bits. */ NV_ENC_BUFFER_FORMAT_ARGB10 = 0x02000000, /**< 10 bit Packed A2R10G10B10. This is a word-ordered format where a pixel is represented by a 32-bit word with B in the lowest 10 bits, G in the next 10 bits, R in the 10 bits after that and A in the highest 2 bits. */ NV_ENC_BUFFER_FORMAT_AYUV = 0x04000000, /**< 8 bit Packed A8Y8U8V8. This is a word-ordered format where a pixel is represented by a 32-bit word with V in the lowest 8 bits, U in the next 8 bits, Y in the 8 bits after that and A in the highest 8 bits. */ NV_ENC_BUFFER_FORMAT_ABGR = 0x10000000, /**< 8 bit Packed A8B8G8R8. This is a word-ordered format where a pixel is represented by a 32-bit word with R in the lowest 8 bits, G in the next 8 bits, B in the 8 bits after that and A in the highest 8 bits. */ NV_ENC_BUFFER_FORMAT_ABGR10 = 0x20000000, /**< 10 bit Packed A2B10G10R10. This is a word-ordered format where a pixel is represented by a 32-bit word with R in the lowest 10 bits, G in the next 10 bits, B in the 10 bits after that and A in the highest 2 bits. */ NV_ENC_BUFFER_FORMAT_U8 = 0x40000000, /**< Buffer format representing one-dimensional buffer. This format should be used only when registering the resource as output buffer, which will be used to write the encoded bit stream or H.264 ME only mode output. */ } NV_ENC_BUFFER_FORMAT; #define NV_ENC_BUFFER_FORMAT_NV12_PL NV_ENC_BUFFER_FORMAT_NV12 #define NV_ENC_BUFFER_FORMAT_YV12_PL NV_ENC_BUFFER_FORMAT_YV12 #define NV_ENC_BUFFER_FORMAT_IYUV_PL NV_ENC_BUFFER_FORMAT_IYUV #define NV_ENC_BUFFER_FORMAT_YUV444_PL NV_ENC_BUFFER_FORMAT_YUV444 /** * Encoding levels */ typedef enum _NV_ENC_LEVEL { NV_ENC_LEVEL_AUTOSELECT = 0, NV_ENC_LEVEL_H264_1 = 10, NV_ENC_LEVEL_H264_1b = 9, NV_ENC_LEVEL_H264_11 = 11, NV_ENC_LEVEL_H264_12 = 12, NV_ENC_LEVEL_H264_13 = 13, NV_ENC_LEVEL_H264_2 = 20, NV_ENC_LEVEL_H264_21 = 21, NV_ENC_LEVEL_H264_22 = 22, NV_ENC_LEVEL_H264_3 = 30, NV_ENC_LEVEL_H264_31 = 31, NV_ENC_LEVEL_H264_32 = 32, NV_ENC_LEVEL_H264_4 = 40, NV_ENC_LEVEL_H264_41 = 41, NV_ENC_LEVEL_H264_42 = 42, NV_ENC_LEVEL_H264_5 = 50, NV_ENC_LEVEL_H264_51 = 51, NV_ENC_LEVEL_H264_52 = 52, NV_ENC_LEVEL_H264_60 = 60, NV_ENC_LEVEL_H264_61 = 61, NV_ENC_LEVEL_H264_62 = 62, NV_ENC_LEVEL_HEVC_1 = 30, NV_ENC_LEVEL_HEVC_2 = 60, NV_ENC_LEVEL_HEVC_21 = 63, NV_ENC_LEVEL_HEVC_3 = 90, NV_ENC_LEVEL_HEVC_31 = 93, NV_ENC_LEVEL_HEVC_4 = 120, NV_ENC_LEVEL_HEVC_41 = 123, NV_ENC_LEVEL_HEVC_5 = 150, NV_ENC_LEVEL_HEVC_51 = 153, NV_ENC_LEVEL_HEVC_52 = 156, NV_ENC_LEVEL_HEVC_6 = 180, NV_ENC_LEVEL_HEVC_61 = 183, NV_ENC_LEVEL_HEVC_62 = 186, NV_ENC_TIER_HEVC_MAIN = 0, NV_ENC_TIER_HEVC_HIGH = 1, NV_ENC_LEVEL_AV1_2 = 0, NV_ENC_LEVEL_AV1_21 = 1, NV_ENC_LEVEL_AV1_22 = 2, NV_ENC_LEVEL_AV1_23 = 3, NV_ENC_LEVEL_AV1_3 = 4, NV_ENC_LEVEL_AV1_31 = 5, NV_ENC_LEVEL_AV1_32 = 6, NV_ENC_LEVEL_AV1_33 = 7, NV_ENC_LEVEL_AV1_4 = 8, NV_ENC_LEVEL_AV1_41 = 9, NV_ENC_LEVEL_AV1_42 = 10, NV_ENC_LEVEL_AV1_43 = 11, NV_ENC_LEVEL_AV1_5 = 12, NV_ENC_LEVEL_AV1_51 = 13, NV_ENC_LEVEL_AV1_52 = 14, NV_ENC_LEVEL_AV1_53 = 15, NV_ENC_LEVEL_AV1_6 = 16, NV_ENC_LEVEL_AV1_61 = 17, NV_ENC_LEVEL_AV1_62 = 18, NV_ENC_LEVEL_AV1_63 = 19, NV_ENC_LEVEL_AV1_7 = 20, NV_ENC_LEVEL_AV1_71 = 21, NV_ENC_LEVEL_AV1_72 = 22, NV_ENC_LEVEL_AV1_73 = 23, NV_ENC_LEVEL_AV1_AUTOSELECT , NV_ENC_TIER_AV1_0 = 0, NV_ENC_TIER_AV1_1 = 1 } NV_ENC_LEVEL; /** * Error Codes */ typedef enum _NVENCSTATUS { /** * This indicates that API call returned with no errors. */ NV_ENC_SUCCESS, /** * This indicates that no encode capable devices were detected. */ NV_ENC_ERR_NO_ENCODE_DEVICE, /** * This indicates that devices pass by the client is not supported. */ NV_ENC_ERR_UNSUPPORTED_DEVICE, /** * This indicates that the encoder device supplied by the client is not * valid. */ NV_ENC_ERR_INVALID_ENCODERDEVICE, /** * This indicates that device passed to the API call is invalid. */ NV_ENC_ERR_INVALID_DEVICE, /** * This indicates that device passed to the API call is no longer available and * needs to be reinitialized. The clients need to destroy the current encoder * session by freeing the allocated input output buffers and destroying the device * and create a new encoding session. */ NV_ENC_ERR_DEVICE_NOT_EXIST, /** * This indicates that one or more of the pointers passed to the API call * is invalid. */ NV_ENC_ERR_INVALID_PTR, /** * This indicates that completion event passed in ::NvEncEncodePicture() call * is invalid. */ NV_ENC_ERR_INVALID_EVENT, /** * This indicates that one or more of the parameter passed to the API call * is invalid. */ NV_ENC_ERR_INVALID_PARAM, /** * This indicates that an API call was made in wrong sequence/order. */ NV_ENC_ERR_INVALID_CALL, /** * This indicates that the API call failed because it was unable to allocate * enough memory to perform the requested operation. */ NV_ENC_ERR_OUT_OF_MEMORY, /** * This indicates that the encoder has not been initialized with * ::NvEncInitializeEncoder() or that initialization has failed. * The client cannot allocate input or output buffers or do any encoding * related operation before successfully initializing the encoder. */ NV_ENC_ERR_ENCODER_NOT_INITIALIZED, /** * This indicates that an unsupported parameter was passed by the client. */ NV_ENC_ERR_UNSUPPORTED_PARAM, /** * This indicates that the ::NvEncLockBitstream() failed to lock the output * buffer. This happens when the client makes a non blocking lock call to * access the output bitstream by passing NV_ENC_LOCK_BITSTREAM::doNotWait flag. * This is not a fatal error and client should retry the same operation after * few milliseconds. */ NV_ENC_ERR_LOCK_BUSY, /** * This indicates that the size of the user buffer passed by the client is * insufficient for the requested operation. */ NV_ENC_ERR_NOT_ENOUGH_BUFFER, /** * This indicates that an invalid struct version was used by the client. */ NV_ENC_ERR_INVALID_VERSION, /** * This indicates that ::NvEncMapInputResource() API failed to map the client * provided input resource. */ NV_ENC_ERR_MAP_FAILED, /** * This indicates encode driver requires more input buffers to produce an output * bitstream. If this error is returned from ::NvEncEncodePicture() API, this * is not a fatal error. If the client is encoding with B frames then, * ::NvEncEncodePicture() API might be buffering the input frame for re-ordering. * * A client operating in synchronous mode cannot call ::NvEncLockBitstream() * API on the output bitstream buffer if ::NvEncEncodePicture() returned the * ::NV_ENC_ERR_NEED_MORE_INPUT error code. * The client must continue providing input frames until encode driver returns * ::NV_ENC_SUCCESS. After receiving ::NV_ENC_SUCCESS status the client can call * ::NvEncLockBitstream() API on the output buffers in the same order in which * it has called ::NvEncEncodePicture(). */ NV_ENC_ERR_NEED_MORE_INPUT, /** * This indicates that the HW encoder is busy encoding and is unable to encode * the input. The client should call ::NvEncEncodePicture() again after few * milliseconds. */ NV_ENC_ERR_ENCODER_BUSY, /** * This indicates that the completion event passed in ::NvEncEncodePicture() * API has not been registered with encoder driver using ::NvEncRegisterAsyncEvent(). */ NV_ENC_ERR_EVENT_NOT_REGISTERD, /** * This indicates that an unknown internal error has occurred. */ NV_ENC_ERR_GENERIC, /** * This indicates that the client is attempting to use a feature * that is not available for the license type for the current system. */ NV_ENC_ERR_INCOMPATIBLE_CLIENT_KEY, /** * This indicates that the client is attempting to use a feature * that is not implemented for the current version. */ NV_ENC_ERR_UNIMPLEMENTED, /** * This indicates that the ::NvEncRegisterResource API failed to register the resource. */ NV_ENC_ERR_RESOURCE_REGISTER_FAILED, /** * This indicates that the client is attempting to unregister a resource * that has not been successfully registered. */ NV_ENC_ERR_RESOURCE_NOT_REGISTERED, /** * This indicates that the client is attempting to unmap a resource * that has not been successfully mapped. */ NV_ENC_ERR_RESOURCE_NOT_MAPPED, } NVENCSTATUS; /** * Encode Picture encode flags. */ typedef enum _NV_ENC_PIC_FLAGS { NV_ENC_PIC_FLAG_FORCEINTRA = 0x1, /**< Encode the current picture as an Intra picture */ NV_ENC_PIC_FLAG_FORCEIDR = 0x2, /**< Encode the current picture as an IDR picture. This flag is only valid when Picture type decision is taken by the Encoder [_NV_ENC_INITIALIZE_PARAMS::enablePTD == 1]. */ NV_ENC_PIC_FLAG_OUTPUT_SPSPPS = 0x4, /**< Write the sequence and picture header in encoded bitstream of the current picture */ NV_ENC_PIC_FLAG_EOS = 0x8, /**< Indicates end of the input stream */ } NV_ENC_PIC_FLAGS; /** * Memory heap to allocate input and output buffers. */ typedef enum _NV_ENC_MEMORY_HEAP { NV_ENC_MEMORY_HEAP_AUTOSELECT = 0, /**< Memory heap to be decided by the encoder driver based on the usage */ NV_ENC_MEMORY_HEAP_VID = 1, /**< Memory heap is in local video memory */ NV_ENC_MEMORY_HEAP_SYSMEM_CACHED = 2, /**< Memory heap is in cached system memory */ NV_ENC_MEMORY_HEAP_SYSMEM_UNCACHED = 3 /**< Memory heap is in uncached system memory */ } NV_ENC_MEMORY_HEAP; /** * B-frame used as reference modes */ typedef enum _NV_ENC_BFRAME_REF_MODE { NV_ENC_BFRAME_REF_MODE_DISABLED = 0x0, /**< B frame is not used for reference */ NV_ENC_BFRAME_REF_MODE_EACH = 0x1, /**< Each B-frame will be used for reference */ NV_ENC_BFRAME_REF_MODE_MIDDLE = 0x2, /**< Only(Number of B-frame)/2 th B-frame will be used for reference */ } NV_ENC_BFRAME_REF_MODE; /** * H.264 entropy coding modes. */ typedef enum _NV_ENC_H264_ENTROPY_CODING_MODE { NV_ENC_H264_ENTROPY_CODING_MODE_AUTOSELECT = 0x0, /**< Entropy coding mode is auto selected by the encoder driver */ NV_ENC_H264_ENTROPY_CODING_MODE_CABAC = 0x1, /**< Entropy coding mode is CABAC */ NV_ENC_H264_ENTROPY_CODING_MODE_CAVLC = 0x2 /**< Entropy coding mode is CAVLC */ } NV_ENC_H264_ENTROPY_CODING_MODE; /** * H.264 specific BDirect modes */ typedef enum _NV_ENC_H264_BDIRECT_MODE { NV_ENC_H264_BDIRECT_MODE_AUTOSELECT = 0x0, /**< BDirect mode is auto selected by the encoder driver */ NV_ENC_H264_BDIRECT_MODE_DISABLE = 0x1, /**< Disable BDirect mode */ NV_ENC_H264_BDIRECT_MODE_TEMPORAL = 0x2, /**< Temporal BDirect mode */ NV_ENC_H264_BDIRECT_MODE_SPATIAL = 0x3 /**< Spatial BDirect mode */ } NV_ENC_H264_BDIRECT_MODE; /** * H.264 specific FMO usage */ typedef enum _NV_ENC_H264_FMO_MODE { NV_ENC_H264_FMO_AUTOSELECT = 0x0, /**< FMO usage is auto selected by the encoder driver */ NV_ENC_H264_FMO_ENABLE = 0x1, /**< Enable FMO */ NV_ENC_H264_FMO_DISABLE = 0x2, /**< Disable FMO */ } NV_ENC_H264_FMO_MODE; /** * H.264 specific Adaptive Transform modes */ typedef enum _NV_ENC_H264_ADAPTIVE_TRANSFORM_MODE { NV_ENC_H264_ADAPTIVE_TRANSFORM_AUTOSELECT = 0x0, /**< Adaptive Transform 8x8 mode is auto selected by the encoder driver*/ NV_ENC_H264_ADAPTIVE_TRANSFORM_DISABLE = 0x1, /**< Adaptive Transform 8x8 mode disabled */ NV_ENC_H264_ADAPTIVE_TRANSFORM_ENABLE = 0x2, /**< Adaptive Transform 8x8 mode should be used */ } NV_ENC_H264_ADAPTIVE_TRANSFORM_MODE; /** * Stereo frame packing modes. */ typedef enum _NV_ENC_STEREO_PACKING_MODE { NV_ENC_STEREO_PACKING_MODE_NONE = 0x0, /**< No Stereo packing required */ NV_ENC_STEREO_PACKING_MODE_CHECKERBOARD = 0x1, /**< Checkerboard mode for packing stereo frames */ NV_ENC_STEREO_PACKING_MODE_COLINTERLEAVE = 0x2, /**< Column Interleave mode for packing stereo frames */ NV_ENC_STEREO_PACKING_MODE_ROWINTERLEAVE = 0x3, /**< Row Interleave mode for packing stereo frames */ NV_ENC_STEREO_PACKING_MODE_SIDEBYSIDE = 0x4, /**< Side-by-side mode for packing stereo frames */ NV_ENC_STEREO_PACKING_MODE_TOPBOTTOM = 0x5, /**< Top-Bottom mode for packing stereo frames */ NV_ENC_STEREO_PACKING_MODE_FRAMESEQ = 0x6 /**< Frame Sequential mode for packing stereo frames */ } NV_ENC_STEREO_PACKING_MODE; /** * Input Resource type */ typedef enum _NV_ENC_INPUT_RESOURCE_TYPE { NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX = 0x0, /**< input resource type is a directx9 surface*/ NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR = 0x1, /**< input resource type is a cuda device pointer surface*/ NV_ENC_INPUT_RESOURCE_TYPE_CUDAARRAY = 0x2, /**< input resource type is a cuda array surface. This array must be a 2D array and the CUDA_ARRAY3D_SURFACE_LDST flag must have been specified when creating it. */ NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX = 0x3 /**< input resource type is an OpenGL texture */ } NV_ENC_INPUT_RESOURCE_TYPE; /** * Buffer usage */ typedef enum _NV_ENC_BUFFER_USAGE { NV_ENC_INPUT_IMAGE = 0x0, /**< Registered surface will be used for input image */ NV_ENC_OUTPUT_MOTION_VECTOR = 0x1, /**< Registered surface will be used for output of H.264 ME only mode. This buffer usage type is not supported for HEVC ME only mode. */ NV_ENC_OUTPUT_BITSTREAM = 0x2, /**< Registered surface will be used for output bitstream in encoding */ } NV_ENC_BUFFER_USAGE; /** * Encoder Device type */ typedef enum _NV_ENC_DEVICE_TYPE { NV_ENC_DEVICE_TYPE_DIRECTX = 0x0, /**< encode device type is a directx9 device */ NV_ENC_DEVICE_TYPE_CUDA = 0x1, /**< encode device type is a cuda device */ NV_ENC_DEVICE_TYPE_OPENGL = 0x2 /**< encode device type is an OpenGL device. Use of this device type is supported only on Linux */ } NV_ENC_DEVICE_TYPE; /** * Number of reference frames */ typedef enum _NV_ENC_NUM_REF_FRAMES { NV_ENC_NUM_REF_FRAMES_AUTOSELECT = 0x0, /**< Number of reference frames is auto selected by the encoder driver */ NV_ENC_NUM_REF_FRAMES_1 = 0x1, /**< Number of reference frames equal to 1 */ NV_ENC_NUM_REF_FRAMES_2 = 0x2, /**< Number of reference frames equal to 2 */ NV_ENC_NUM_REF_FRAMES_3 = 0x3, /**< Number of reference frames equal to 3 */ NV_ENC_NUM_REF_FRAMES_4 = 0x4, /**< Number of reference frames equal to 4 */ NV_ENC_NUM_REF_FRAMES_5 = 0x5, /**< Number of reference frames equal to 5 */ NV_ENC_NUM_REF_FRAMES_6 = 0x6, /**< Number of reference frames equal to 6 */ NV_ENC_NUM_REF_FRAMES_7 = 0x7 /**< Number of reference frames equal to 7 */ } NV_ENC_NUM_REF_FRAMES; /** * Encoder capabilities enumeration. */ typedef enum _NV_ENC_CAPS { /** * Maximum number of B-Frames supported. */ NV_ENC_CAPS_NUM_MAX_BFRAMES, /** * Rate control modes supported. * \n The API return value is a bitmask of the values in NV_ENC_PARAMS_RC_MODE. */ NV_ENC_CAPS_SUPPORTED_RATECONTROL_MODES, /** * Indicates HW support for field mode encoding. * \n 0 : Interlaced mode encoding is not supported. * \n 1 : Interlaced field mode encoding is supported. * \n 2 : Interlaced frame encoding and field mode encoding are both supported. */ NV_ENC_CAPS_SUPPORT_FIELD_ENCODING, /** * Indicates HW support for monochrome mode encoding. * \n 0 : Monochrome mode not supported. * \n 1 : Monochrome mode supported. */ NV_ENC_CAPS_SUPPORT_MONOCHROME, /** * Indicates HW support for FMO. * \n 0 : FMO not supported. * \n 1 : FMO supported. */ NV_ENC_CAPS_SUPPORT_FMO, /** * Indicates HW capability for Quarter pel motion estimation. * \n 0 : Quarter-Pel Motion Estimation not supported. * \n 1 : Quarter-Pel Motion Estimation supported. */ NV_ENC_CAPS_SUPPORT_QPELMV, /** * H.264 specific. Indicates HW support for BDirect modes. * \n 0 : BDirect mode encoding not supported. * \n 1 : BDirect mode encoding supported. */ NV_ENC_CAPS_SUPPORT_BDIRECT_MODE, /** * H264 specific. Indicates HW support for CABAC entropy coding mode. * \n 0 : CABAC entropy coding not supported. * \n 1 : CABAC entropy coding supported. */ NV_ENC_CAPS_SUPPORT_CABAC, /** * Indicates HW support for Adaptive Transform. * \n 0 : Adaptive Transform not supported. * \n 1 : Adaptive Transform supported. */ NV_ENC_CAPS_SUPPORT_ADAPTIVE_TRANSFORM, /** * Indicates HW support for Multi View Coding. * \n 0 : Multi View Coding not supported. * \n 1 : Multi View Coding supported. */ NV_ENC_CAPS_SUPPORT_STEREO_MVC, /** * Indicates HW support for encoding Temporal layers. * \n 0 : Encoding Temporal layers not supported. * \n 1 : Encoding Temporal layers supported. */ NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS, /** * Indicates HW support for Hierarchical P frames. * \n 0 : Hierarchical P frames not supported. * \n 1 : Hierarchical P frames supported. */ NV_ENC_CAPS_SUPPORT_HIERARCHICAL_PFRAMES, /** * Indicates HW support for Hierarchical B frames. * \n 0 : Hierarchical B frames not supported. * \n 1 : Hierarchical B frames supported. */ NV_ENC_CAPS_SUPPORT_HIERARCHICAL_BFRAMES, /** * Maximum Encoding level supported (See ::NV_ENC_LEVEL for details). */ NV_ENC_CAPS_LEVEL_MAX, /** * Minimum Encoding level supported (See ::NV_ENC_LEVEL for details). */ NV_ENC_CAPS_LEVEL_MIN, /** * Indicates HW support for separate colour plane encoding. * \n 0 : Separate colour plane encoding not supported. * \n 1 : Separate colour plane encoding supported. */ NV_ENC_CAPS_SEPARATE_COLOUR_PLANE, /** * Maximum output width supported. */ NV_ENC_CAPS_WIDTH_MAX, /** * Maximum output height supported. */ NV_ENC_CAPS_HEIGHT_MAX, /** * Indicates Temporal Scalability Support. * \n 0 : Temporal SVC encoding not supported. * \n 1 : Temporal SVC encoding supported. */ NV_ENC_CAPS_SUPPORT_TEMPORAL_SVC, /** * Indicates Dynamic Encode Resolution Change Support. * Support added from NvEncodeAPI version 2.0. * \n 0 : Dynamic Encode Resolution Change not supported. * \n 1 : Dynamic Encode Resolution Change supported. */ NV_ENC_CAPS_SUPPORT_DYN_RES_CHANGE, /** * Indicates Dynamic Encode Bitrate Change Support. * Support added from NvEncodeAPI version 2.0. * \n 0 : Dynamic Encode bitrate change not supported. * \n 1 : Dynamic Encode bitrate change supported. */ NV_ENC_CAPS_SUPPORT_DYN_BITRATE_CHANGE, /** * Indicates Forcing Constant QP On The Fly Support. * Support added from NvEncodeAPI version 2.0. * \n 0 : Forcing constant QP on the fly not supported. * \n 1 : Forcing constant QP on the fly supported. */ NV_ENC_CAPS_SUPPORT_DYN_FORCE_CONSTQP, /** * Indicates Dynamic rate control mode Change Support. * \n 0 : Dynamic rate control mode change not supported. * \n 1 : Dynamic rate control mode change supported. */ NV_ENC_CAPS_SUPPORT_DYN_RCMODE_CHANGE, /** * Indicates Subframe readback support for slice-based encoding. If this feature is supported, it can be enabled by setting enableSubFrameWrite = 1. * \n 0 : Subframe readback not supported. * \n 1 : Subframe readback supported. */ NV_ENC_CAPS_SUPPORT_SUBFRAME_READBACK, /** * Indicates Constrained Encoding mode support. * Support added from NvEncodeAPI version 2.0. * \n 0 : Constrained encoding mode not supported. * \n 1 : Constrained encoding mode supported. * If this mode is supported client can enable this during initialization. * Client can then force a picture to be coded as constrained picture where * in-loop filtering is disabled across slice boundaries and prediction vectors for inter * macroblocks in each slice will be restricted to the slice region. */ NV_ENC_CAPS_SUPPORT_CONSTRAINED_ENCODING, /** * Indicates Intra Refresh Mode Support. * Support added from NvEncodeAPI version 2.0. * \n 0 : Intra Refresh Mode not supported. * \n 1 : Intra Refresh Mode supported. */ NV_ENC_CAPS_SUPPORT_INTRA_REFRESH, /** * Indicates Custom VBV Buffer Size support. It can be used for capping frame size. * Support added from NvEncodeAPI version 2.0. * \n 0 : Custom VBV buffer size specification from client, not supported. * \n 1 : Custom VBV buffer size specification from client, supported. */ NV_ENC_CAPS_SUPPORT_CUSTOM_VBV_BUF_SIZE, /** * Indicates Dynamic Slice Mode Support. * Support added from NvEncodeAPI version 2.0. * \n 0 : Dynamic Slice Mode not supported. * \n 1 : Dynamic Slice Mode supported. */ NV_ENC_CAPS_SUPPORT_DYNAMIC_SLICE_MODE, /** * Indicates Reference Picture Invalidation Support. * Support added from NvEncodeAPI version 2.0. * \n 0 : Reference Picture Invalidation not supported. * \n 1 : Reference Picture Invalidation supported. */ NV_ENC_CAPS_SUPPORT_REF_PIC_INVALIDATION, /** * Indicates support for Pre-Processing. * The API return value is a bitmask of the values defined in ::NV_ENC_PREPROC_FLAGS */ NV_ENC_CAPS_PREPROC_SUPPORT, /** * Indicates support Async mode. * \n 0 : Async Encode mode not supported. * \n 1 : Async Encode mode supported. */ NV_ENC_CAPS_ASYNC_ENCODE_SUPPORT, /** * Maximum MBs per frame supported. */ NV_ENC_CAPS_MB_NUM_MAX, /** * Maximum aggregate throughput in MBs per sec. */ NV_ENC_CAPS_MB_PER_SEC_MAX, /** * Indicates HW support for YUV444 mode encoding. * \n 0 : YUV444 mode encoding not supported. * \n 1 : YUV444 mode encoding supported. */ NV_ENC_CAPS_SUPPORT_YUV444_ENCODE, /** * Indicates HW support for lossless encoding. * \n 0 : lossless encoding not supported. * \n 1 : lossless encoding supported. */ NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE, /** * Indicates HW support for Sample Adaptive Offset. * \n 0 : SAO not supported. * \n 1 : SAO encoding supported. */ NV_ENC_CAPS_SUPPORT_SAO, /** * Indicates HW support for Motion Estimation Only Mode. * \n 0 : MEOnly Mode not supported. * \n 1 : MEOnly Mode supported for I and P frames. * \n 2 : MEOnly Mode supported for I, P and B frames. */ NV_ENC_CAPS_SUPPORT_MEONLY_MODE, /** * Indicates HW support for lookahead encoding (enableLookahead=1). * \n 0 : Lookahead not supported. * \n 1 : Lookahead supported. */ NV_ENC_CAPS_SUPPORT_LOOKAHEAD, /** * Indicates HW support for temporal AQ encoding (enableTemporalAQ=1). * \n 0 : Temporal AQ not supported. * \n 1 : Temporal AQ supported. */ NV_ENC_CAPS_SUPPORT_TEMPORAL_AQ, /** * Indicates HW support for 10 bit encoding. * \n 0 : 10 bit encoding not supported. * \n 1 : 10 bit encoding supported. */ NV_ENC_CAPS_SUPPORT_10BIT_ENCODE, /** * Maximum number of Long Term Reference frames supported */ NV_ENC_CAPS_NUM_MAX_LTR_FRAMES, /** * Indicates HW support for Weighted Prediction. * \n 0 : Weighted Prediction not supported. * \n 1 : Weighted Prediction supported. */ NV_ENC_CAPS_SUPPORT_WEIGHTED_PREDICTION, /** * On managed (vGPU) platforms (Windows only), this API, in conjunction with other GRID Management APIs, can be used * to estimate the residual capacity of the hardware encoder on the GPU as a percentage of the total available encoder capacity. * This API can be called at any time; i.e. during the encode session or before opening the encode session. * If the available encoder capacity is returned as zero, applications may choose to switch to software encoding * and continue to call this API (e.g. polling once per second) until capacity becomes available. * * On bare metal (non-virtualized GPU) and linux platforms, this API always returns 100. */ NV_ENC_CAPS_DYNAMIC_QUERY_ENCODER_CAPACITY, /** * Indicates B as reference support. * \n 0 : B as reference is not supported. * \n 1 : each B-Frame as reference is supported. * \n 2 : only Middle B-frame as reference is supported. */ NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE, /** * Indicates HW support for Emphasis Level Map based delta QP computation. * \n 0 : Emphasis Level Map based delta QP not supported. * \n 1 : Emphasis Level Map based delta QP is supported. */ NV_ENC_CAPS_SUPPORT_EMPHASIS_LEVEL_MAP, /** * Minimum input width supported. */ NV_ENC_CAPS_WIDTH_MIN, /** * Minimum input height supported. */ NV_ENC_CAPS_HEIGHT_MIN, /** * Indicates HW support for multiple reference frames. */ NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES, /** * Indicates HW support for HEVC with alpha encoding. * \n 0 : HEVC with alpha encoding not supported. * \n 1 : HEVC with alpha encoding is supported. */ NV_ENC_CAPS_SUPPORT_ALPHA_LAYER_ENCODING, /** * Indicates number of Encoding engines present on GPU. */ NV_ENC_CAPS_NUM_ENCODER_ENGINES, /** * Indicates single slice intra refresh support. */ NV_ENC_CAPS_SINGLE_SLICE_INTRA_REFRESH, /** * Reserved - Not to be used by clients. */ NV_ENC_CAPS_EXPOSED_COUNT } NV_ENC_CAPS; /** * HEVC CU SIZE */ typedef enum _NV_ENC_HEVC_CUSIZE { NV_ENC_HEVC_CUSIZE_AUTOSELECT = 0, NV_ENC_HEVC_CUSIZE_8x8 = 1, NV_ENC_HEVC_CUSIZE_16x16 = 2, NV_ENC_HEVC_CUSIZE_32x32 = 3, NV_ENC_HEVC_CUSIZE_64x64 = 4, }NV_ENC_HEVC_CUSIZE; /** * AV1 PART SIZE */ typedef enum _NV_ENC_AV1_PART_SIZE { NV_ENC_AV1_PART_SIZE_AUTOSELECT = 0, NV_ENC_AV1_PART_SIZE_4x4 = 1, NV_ENC_AV1_PART_SIZE_8x8 = 2, NV_ENC_AV1_PART_SIZE_16x16 = 3, NV_ENC_AV1_PART_SIZE_32x32 = 4, NV_ENC_AV1_PART_SIZE_64x64 = 5, }NV_ENC_AV1_PART_SIZE; /** * Enums related to fields in VUI parameters. */ typedef enum _NV_ENC_VUI_VIDEO_FORMAT { NV_ENC_VUI_VIDEO_FORMAT_COMPONENT = 0, NV_ENC_VUI_VIDEO_FORMAT_PAL = 1, NV_ENC_VUI_VIDEO_FORMAT_NTSC = 2, NV_ENC_VUI_VIDEO_FORMAT_SECAM = 3, NV_ENC_VUI_VIDEO_FORMAT_MAC = 4, NV_ENC_VUI_VIDEO_FORMAT_UNSPECIFIED = 5, }NV_ENC_VUI_VIDEO_FORMAT; typedef enum _NV_ENC_VUI_COLOR_PRIMARIES { NV_ENC_VUI_COLOR_PRIMARIES_UNDEFINED = 0, NV_ENC_VUI_COLOR_PRIMARIES_BT709 = 1, NV_ENC_VUI_COLOR_PRIMARIES_UNSPECIFIED = 2, NV_ENC_VUI_COLOR_PRIMARIES_RESERVED = 3, NV_ENC_VUI_COLOR_PRIMARIES_BT470M = 4, NV_ENC_VUI_COLOR_PRIMARIES_BT470BG = 5, NV_ENC_VUI_COLOR_PRIMARIES_SMPTE170M = 6, NV_ENC_VUI_COLOR_PRIMARIES_SMPTE240M = 7, NV_ENC_VUI_COLOR_PRIMARIES_FILM = 8, NV_ENC_VUI_COLOR_PRIMARIES_BT2020 = 9, NV_ENC_VUI_COLOR_PRIMARIES_SMPTE428 = 10, NV_ENC_VUI_COLOR_PRIMARIES_SMPTE431 = 11, NV_ENC_VUI_COLOR_PRIMARIES_SMPTE432 = 12, NV_ENC_VUI_COLOR_PRIMARIES_JEDEC_P22 = 22, }NV_ENC_VUI_COLOR_PRIMARIES; typedef enum _NV_ENC_VUI_TRANSFER_CHARACTERISTIC { NV_ENC_VUI_TRANSFER_CHARACTERISTIC_UNDEFINED = 0, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_BT709 = 1, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_UNSPECIFIED = 2, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_RESERVED = 3, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_BT470M = 4, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_BT470BG = 5, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_SMPTE170M = 6, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_SMPTE240M = 7, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_LINEAR = 8, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_LOG = 9, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_LOG_SQRT = 10, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_IEC61966_2_4 = 11, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_BT1361_ECG = 12, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_SRGB = 13, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_BT2020_10 = 14, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_BT2020_12 = 15, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_SMPTE2084 = 16, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_SMPTE428 = 17, NV_ENC_VUI_TRANSFER_CHARACTERISTIC_ARIB_STD_B67 = 18, }NV_ENC_VUI_TRANSFER_CHARACTERISTIC; typedef enum _NV_ENC_VUI_MATRIX_COEFFS { NV_ENC_VUI_MATRIX_COEFFS_RGB = 0, NV_ENC_VUI_MATRIX_COEFFS_BT709 = 1, NV_ENC_VUI_MATRIX_COEFFS_UNSPECIFIED = 2, NV_ENC_VUI_MATRIX_COEFFS_RESERVED = 3, NV_ENC_VUI_MATRIX_COEFFS_FCC = 4, NV_ENC_VUI_MATRIX_COEFFS_BT470BG = 5, NV_ENC_VUI_MATRIX_COEFFS_SMPTE170M = 6, NV_ENC_VUI_MATRIX_COEFFS_SMPTE240M = 7, NV_ENC_VUI_MATRIX_COEFFS_YCGCO = 8, NV_ENC_VUI_MATRIX_COEFFS_BT2020_NCL = 9, NV_ENC_VUI_MATRIX_COEFFS_BT2020_CL = 10, NV_ENC_VUI_MATRIX_COEFFS_SMPTE2085 = 11, }NV_ENC_VUI_MATRIX_COEFFS; /** * Input struct for querying Encoding capabilities. */ typedef struct _NV_ENC_CAPS_PARAM { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CAPS_PARAM_VER */ NV_ENC_CAPS capsToQuery; /**< [in]: Specifies the encode capability to be queried. Client should pass a member for ::NV_ENC_CAPS enum. */ uint32_t reserved[62]; /**< [in]: Reserved and must be set to 0 */ } NV_ENC_CAPS_PARAM; /** NV_ENC_CAPS_PARAM struct version. */ #define NV_ENC_CAPS_PARAM_VER NVENCAPI_STRUCT_VERSION(1) /** * Encoder Output parameters */ typedef struct _NV_ENC_ENCODE_OUT_PARAMS { uint32_t version; /**< [out]: Struct version. */ uint32_t bitstreamSizeInBytes; /**< [out]: Encoded bitstream size in bytes */ uint32_t reserved[62]; /**< [out]: Reserved and must be set to 0 */ } NV_ENC_ENCODE_OUT_PARAMS; /** NV_ENC_ENCODE_OUT_PARAMS struct version. */ #define NV_ENC_ENCODE_OUT_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) /** * Creation parameters for input buffer. */ typedef struct _NV_ENC_CREATE_INPUT_BUFFER { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CREATE_INPUT_BUFFER_VER */ uint32_t width; /**< [in]: Input frame width */ uint32_t height; /**< [in]: Input frame height */ NV_ENC_MEMORY_HEAP memoryHeap; /**< [in]: Deprecated. Do not use */ NV_ENC_BUFFER_FORMAT bufferFmt; /**< [in]: Input buffer format */ uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ NV_ENC_INPUT_PTR inputBuffer; /**< [out]: Pointer to input buffer */ void* pSysMemBuffer; /**< [in]: Pointer to existing system memory buffer */ uint32_t reserved1[57]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[63]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_CREATE_INPUT_BUFFER; /** NV_ENC_CREATE_INPUT_BUFFER struct version. */ #define NV_ENC_CREATE_INPUT_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) /** * Creation parameters for output bitstream buffer. */ typedef struct _NV_ENC_CREATE_BITSTREAM_BUFFER { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CREATE_BITSTREAM_BUFFER_VER */ uint32_t size; /**< [in]: Deprecated. Do not use */ NV_ENC_MEMORY_HEAP memoryHeap; /**< [in]: Deprecated. Do not use */ uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ NV_ENC_OUTPUT_PTR bitstreamBuffer; /**< [out]: Pointer to the output bitstream buffer */ void* bitstreamBufferPtr; /**< [out]: Reserved and should not be used */ uint32_t reserved1[58]; /**< [in]: Reserved and should be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and should be set to NULL */ } NV_ENC_CREATE_BITSTREAM_BUFFER; /** NV_ENC_CREATE_BITSTREAM_BUFFER struct version. */ #define NV_ENC_CREATE_BITSTREAM_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) /** * Structs needed for ME only mode. */ typedef struct _NV_ENC_MVECTOR { int16_t mvx; /**< the x component of MV in quarter-pel units */ int16_t mvy; /**< the y component of MV in quarter-pel units */ } NV_ENC_MVECTOR; /** * Motion vector structure per macroblock for H264 motion estimation. */ typedef struct _NV_ENC_H264_MV_DATA { NV_ENC_MVECTOR mv[4]; /**< up to 4 vectors for 8x8 partition */ uint8_t mbType; /**< 0 (I), 1 (P), 2 (IPCM), 3 (B) */ uint8_t partitionType; /**< Specifies the block partition type. 0:16x16, 1:8x8, 2:16x8, 3:8x16 */ uint16_t reserved; /**< reserved padding for alignment */ uint32_t mbCost; } NV_ENC_H264_MV_DATA; /** * Motion vector structure per CU for HEVC motion estimation. */ typedef struct _NV_ENC_HEVC_MV_DATA { NV_ENC_MVECTOR mv[4]; /**< up to 4 vectors within a CU */ uint8_t cuType; /**< 0 (I), 1(P) */ uint8_t cuSize; /**< 0: 8x8, 1: 16x16, 2: 32x32, 3: 64x64 */ uint8_t partitionMode; /**< The CU partition mode 0 (2Nx2N), 1 (2NxN), 2(Nx2N), 3 (NxN), 4 (2NxnU), 5 (2NxnD), 6(nLx2N), 7 (nRx2N) */ uint8_t lastCUInCTB; /**< Marker to separate CUs in the current CTB from CUs in the next CTB */ } NV_ENC_HEVC_MV_DATA; /** * Creation parameters for output motion vector buffer for ME only mode. */ typedef struct _NV_ENC_CREATE_MV_BUFFER { uint32_t version; /**< [in]: Struct version. Must be set to NV_ENC_CREATE_MV_BUFFER_VER */ NV_ENC_OUTPUT_PTR mvBuffer; /**< [out]: Pointer to the output motion vector buffer */ uint32_t reserved1[255]; /**< [in]: Reserved and should be set to 0 */ void* reserved2[63]; /**< [in]: Reserved and should be set to NULL */ } NV_ENC_CREATE_MV_BUFFER; /** NV_ENC_CREATE_MV_BUFFER struct version*/ #define NV_ENC_CREATE_MV_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) /** * QP value for frames */ typedef struct _NV_ENC_QP { uint32_t qpInterP; /**< [in]: Specifies QP value for P-frame. Even though this field is uint32_t for legacy reasons, the client should treat this as a signed parameter(int32_t) for cases in which negative QP values are to be specified. */ uint32_t qpInterB; /**< [in]: Specifies QP value for B-frame. Even though this field is uint32_t for legacy reasons, the client should treat this as a signed parameter(int32_t) for cases in which negative QP values are to be specified. */ uint32_t qpIntra; /**< [in]: Specifies QP value for Intra Frame. Even though this field is uint32_t for legacy reasons, the client should treat this as a signed parameter(int32_t) for cases in which negative QP values are to be specified. */ } NV_ENC_QP; /** * Rate Control Configuration Parameters */ typedef struct _NV_ENC_RC_PARAMS { uint32_t version; NV_ENC_PARAMS_RC_MODE rateControlMode; /**< [in]: Specifies the rate control mode. Check support for various rate control modes using ::NV_ENC_CAPS_SUPPORTED_RATECONTROL_MODES caps. */ NV_ENC_QP constQP; /**< [in]: Specifies the initial QP to be used for encoding, these values would be used for all frames if in Constant QP mode. */ uint32_t averageBitRate; /**< [in]: Specifies the average bitrate(in bits/sec) used for encoding. */ uint32_t maxBitRate; /**< [in]: Specifies the maximum bitrate for the encoded output. This is used for VBR and ignored for CBR mode. */ uint32_t vbvBufferSize; /**< [in]: Specifies the VBV(HRD) buffer size. in bits. Set 0 to use the default VBV buffer size. */ uint32_t vbvInitialDelay; /**< [in]: Specifies the VBV(HRD) initial delay in bits. Set 0 to use the default VBV initial delay .*/ uint32_t enableMinQP :1; /**< [in]: Set this to 1 if minimum QP used for rate control. */ uint32_t enableMaxQP :1; /**< [in]: Set this to 1 if maximum QP used for rate control. */ uint32_t enableInitialRCQP :1; /**< [in]: Set this to 1 if user supplied initial QP is used for rate control. */ uint32_t enableAQ :1; /**< [in]: Set this to 1 to enable adaptive quantization (Spatial). */ uint32_t reservedBitField1 :1; /**< [in]: Reserved bitfields and must be set to 0. */ uint32_t enableLookahead :1; /**< [in]: Set this to 1 to enable lookahead with depth (if lookahead is enabled, input frames must remain available to the encoder until encode completion) */ uint32_t disableIadapt :1; /**< [in]: Set this to 1 to disable adaptive I-frame insertion at scene cuts (only has an effect when lookahead is enabled) */ uint32_t disableBadapt :1; /**< [in]: Set this to 1 to disable adaptive B-frame decision (only has an effect when lookahead is enabled) */ uint32_t enableTemporalAQ :1; /**< [in]: Set this to 1 to enable temporal AQ */ uint32_t zeroReorderDelay :1; /**< [in]: Set this to 1 to indicate zero latency operation (no reordering delay, num_reorder_frames=0) */ uint32_t enableNonRefP :1; /**< [in]: Set this to 1 to enable automatic insertion of non-reference P-frames (no effect if enablePTD=0) */ uint32_t strictGOPTarget :1; /**< [in]: Set this to 1 to minimize GOP-to-GOP rate fluctuations */ uint32_t aqStrength :4; /**< [in]: When AQ (Spatial) is enabled (i.e. NV_ENC_RC_PARAMS::enableAQ is set), this field is used to specify AQ strength. AQ strength scale is from 1 (low) - 15 (aggressive). If not set, strength is auto selected by driver. */ uint32_t reservedBitFields :16; /**< [in]: Reserved bitfields and must be set to 0 */ NV_ENC_QP minQP; /**< [in]: Specifies the minimum QP used for rate control. Client must set NV_ENC_CONFIG::enableMinQP to 1. */ NV_ENC_QP maxQP; /**< [in]: Specifies the maximum QP used for rate control. Client must set NV_ENC_CONFIG::enableMaxQP to 1. */ NV_ENC_QP initialRCQP; /**< [in]: Specifies the initial QP used for rate control. Client must set NV_ENC_CONFIG::enableInitialRCQP to 1. */ uint32_t temporallayerIdxMask; /**< [in]: Specifies the temporal layers (as a bitmask) whose QPs have changed. Valid max bitmask is [2^NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS - 1]. Applicable only for constant QP mode (NV_ENC_RC_PARAMS::rateControlMode = NV_ENC_PARAMS_RC_CONSTQP). */ uint8_t temporalLayerQP[8]; /**< [in]: Specifies the temporal layer QPs used for rate control. Temporal layer index is used as the array index. Applicable only for constant QP mode (NV_ENC_RC_PARAMS::rateControlMode = NV_ENC_PARAMS_RC_CONSTQP). */ uint8_t targetQuality; /**< [in]: Target CQ (Constant Quality) level for VBR mode (range 0-51 with 0-automatic) */ uint8_t targetQualityLSB; /**< [in]: Fractional part of target quality (as 8.8 fixed point format) */ uint16_t lookaheadDepth; /**< [in]: Maximum depth of lookahead with range 0-(31 - number of B frames). lookaheadDepth is only used if enableLookahead=1.*/ uint8_t lowDelayKeyFrameScale; /**< [in]: Specifies the ratio of I frame bits to P frame bits in case of single frame VBV and CBR rate control mode, is set to 2 by default for low latency tuning info and 1 by default for ultra low latency tuning info */ int8_t yDcQPIndexOffset; /**< [in]: Specifies the value of 'deltaQ_y_dc' in AV1.*/ int8_t uDcQPIndexOffset; /**< [in]: Specifies the value of 'deltaQ_u_dc' in AV1.*/ int8_t vDcQPIndexOffset; /**< [in]: Specifies the value of 'deltaQ_v_dc' in AV1 (for future use only - deltaQ_v_dc is currently always internally set to same value as deltaQ_u_dc). */ NV_ENC_QP_MAP_MODE qpMapMode; /**< [in]: This flag is used to interpret values in array specified by NV_ENC_PIC_PARAMS::qpDeltaMap. Set this to NV_ENC_QP_MAP_EMPHASIS to treat values specified by NV_ENC_PIC_PARAMS::qpDeltaMap as Emphasis Level Map. Emphasis Level can be assigned any value specified in enum NV_ENC_EMPHASIS_MAP_LEVEL. Emphasis Level Map is used to specify regions to be encoded at varying levels of quality. The hardware encoder adjusts the quantization within the image as per the provided emphasis map, by adjusting the quantization parameter (QP) assigned to each macroblock. This adjustment is commonly called "Delta QP". The adjustment depends on the absolute QP decided by the rate control algorithm, and is applied after the rate control has decided each macroblock's QP. Since the Delta QP overrides rate control, enabling Emphasis Level Map may violate bitrate and VBV buffer size constraints. Emphasis Level Map is useful in situations where client has a priori knowledge of the image complexity (e.g. via use of NVFBC's Classification feature) and encoding those high-complexity areas at higher quality (lower QP) is important, even at the possible cost of violating bitrate/VBV buffer size constraints This feature is not supported when AQ( Spatial/Temporal) is enabled. This feature is only supported for H264 codec currently. Set this to NV_ENC_QP_MAP_DELTA to treat values specified by NV_ENC_PIC_PARAMS::qpDeltaMap as QP Delta. This specifies QP modifier to be applied on top of the QP chosen by rate control Set this to NV_ENC_QP_MAP_DISABLED to ignore NV_ENC_PIC_PARAMS::qpDeltaMap values. In this case, qpDeltaMap should be set to NULL. Other values are reserved for future use.*/ NV_ENC_MULTI_PASS multiPass; /**< [in]: This flag is used to enable multi-pass encoding for a given ::NV_ENC_PARAMS_RC_MODE. This flag is not valid for H264 and HEVC MEOnly mode */ uint32_t alphaLayerBitrateRatio; /**< [in]: Specifies the ratio in which bitrate should be split between base and alpha layer. A value 'x' for this field will split the target bitrate in a ratio of x : 1 between base and alpha layer. The default split ratio is 15.*/ int8_t cbQPIndexOffset; /**< [in]: Specifies the value of 'chroma_qp_index_offset' in H264 / 'pps_cb_qp_offset' in HEVC / 'deltaQ_u_ac' in AV1.*/ int8_t crQPIndexOffset; /**< [in]: Specifies the value of 'second_chroma_qp_index_offset' in H264 / 'pps_cr_qp_offset' in HEVC / 'deltaQ_v_ac' in AV1 (for future use only - deltaQ_v_ac is currently always internally set to same value as deltaQ_u_ac). */ uint16_t reserved2; uint32_t reserved[4]; } NV_ENC_RC_PARAMS; /** macro for constructing the version field of ::_NV_ENC_RC_PARAMS */ #define NV_ENC_RC_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) #define MAX_NUM_CLOCK_TS 3 /** * Clock Timestamp set parameters * For H264, this structure is used to populate Picture Timing SEI when NV_ENC_CONFIG_H264::enableTimeCode is set to 1. * For HEVC, this structure is used to populate Time Code SEI when NV_ENC_CONFIG_HEVC::enableTimeCodeSEI is set to 1. * For more details, refer to Annex D of ITU-T Specification. */ typedef struct _NV_ENC_CLOCK_TIMESTAMP_SET { uint32_t countingType : 1; /**< [in] Specifies the 'counting_type' */ uint32_t discontinuityFlag : 1; /**< [in] Specifies the 'discontinuity_flag' */ uint32_t cntDroppedFrames : 1; /**< [in] Specifies the 'cnt_dropped_flag' */ uint32_t nFrames : 8; /**< [in] Specifies the value of 'n_frames' */ uint32_t secondsValue : 6; /**< [in] Specifies the 'seconds_value' */ uint32_t minutesValue : 6; /**< [in] Specifies the 'minutes_value' */ uint32_t hoursValue : 5; /**< [in] Specifies the 'hours_value' */ uint32_t reserved2 : 4; /**< [in] Reserved and must be set to 0 */ uint32_t timeOffset; /**< [in] Specifies the 'time_offset_value' */ } NV_ENC_CLOCK_TIMESTAMP_SET; typedef struct _NV_ENC_TIME_CODE { NV_ENC_DISPLAY_PIC_STRUCT displayPicStruct; /**< [in] Display picStruct */ NV_ENC_CLOCK_TIMESTAMP_SET clockTimestamp[MAX_NUM_CLOCK_TS]; /**< [in] Clock Timestamp set */ } NV_ENC_TIME_CODE; /** * \struct _NV_ENC_CONFIG_H264_VUI_PARAMETERS * H264 Video Usability Info parameters */ typedef struct _NV_ENC_CONFIG_H264_VUI_PARAMETERS { uint32_t overscanInfoPresentFlag; /**< [in]: If set to 1 , it specifies that the overscanInfo is present */ uint32_t overscanInfo; /**< [in]: Specifies the overscan info(as defined in Annex E of the ITU-T Specification). */ uint32_t videoSignalTypePresentFlag; /**< [in]: If set to 1, it specifies that the videoFormat, videoFullRangeFlag and colourDescriptionPresentFlag are present. */ NV_ENC_VUI_VIDEO_FORMAT videoFormat; /**< [in]: Specifies the source video format(as defined in Annex E of the ITU-T Specification).*/ uint32_t videoFullRangeFlag; /**< [in]: Specifies the output range of the luma and chroma samples(as defined in Annex E of the ITU-T Specification). */ uint32_t colourDescriptionPresentFlag; /**< [in]: If set to 1, it specifies that the colourPrimaries, transferCharacteristics and colourMatrix are present. */ NV_ENC_VUI_COLOR_PRIMARIES colourPrimaries; /**< [in]: Specifies color primaries for converting to RGB(as defined in Annex E of the ITU-T Specification) */ NV_ENC_VUI_TRANSFER_CHARACTERISTIC transferCharacteristics; /**< [in]: Specifies the opto-electronic transfer characteristics to use (as defined in Annex E of the ITU-T Specification) */ NV_ENC_VUI_MATRIX_COEFFS colourMatrix; /**< [in]: Specifies the matrix coefficients used in deriving the luma and chroma from the RGB primaries (as defined in Annex E of the ITU-T Specification). */ uint32_t chromaSampleLocationFlag; /**< [in]: If set to 1 , it specifies that the chromaSampleLocationTop and chromaSampleLocationBot are present.*/ uint32_t chromaSampleLocationTop; /**< [in]: Specifies the chroma sample location for top field(as defined in Annex E of the ITU-T Specification) */ uint32_t chromaSampleLocationBot; /**< [in]: Specifies the chroma sample location for bottom field(as defined in Annex E of the ITU-T Specification) */ uint32_t bitstreamRestrictionFlag; /**< [in]: If set to 1, it specifies the bitstream restriction parameters are present in the bitstream.*/ uint32_t timingInfoPresentFlag; /**< [in]: If set to 1, it specifies that the timingInfo is present and the 'numUnitInTicks' and 'timeScale' fields are specified by the application. */ /**< [in]: If not set, the timingInfo may still be present with timing related fields calculated internally basedon the frame rate specified by the application. */ uint32_t numUnitInTicks; /**< [in]: Specifies the number of time units of the clock(as defined in Annex E of the ITU-T Specification). */ uint32_t timeScale; /**< [in]: Specifies the frquency of the clock(as defined in Annex E of the ITU-T Specification). */ uint32_t reserved[12]; /**< [in]: Reserved and must be set to 0 */ }NV_ENC_CONFIG_H264_VUI_PARAMETERS; typedef NV_ENC_CONFIG_H264_VUI_PARAMETERS NV_ENC_CONFIG_HEVC_VUI_PARAMETERS; /** * \struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE * External motion vector hint counts per block type. * H264 and AV1 support multiple hint while HEVC supports one hint for each valid candidate. */ typedef struct _NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE { uint32_t numCandsPerBlk16x16 : 4; /**< [in]: Supported for H264, HEVC. It Specifies the number of candidates per 16x16 block. */ uint32_t numCandsPerBlk16x8 : 4; /**< [in]: Supported for H264 only. Specifies the number of candidates per 16x8 block. */ uint32_t numCandsPerBlk8x16 : 4; /**< [in]: Supported for H264 only. Specifies the number of candidates per 8x16 block. */ uint32_t numCandsPerBlk8x8 : 4; /**< [in]: Supported for H264, HEVC. Specifies the number of candidates per 8x8 block. */ uint32_t numCandsPerSb : 8; /**< [in]: Supported for AV1 only. Specifies the number of candidates per SB. */ uint32_t reserved : 8; /**< [in]: Reserved for padding. */ uint32_t reserved1[3]; /**< [in]: Reserved for future use. */ } NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE; /** * \struct _NVENC_EXTERNAL_ME_HINT * External Motion Vector hint structure for H264 and HEVC. */ typedef struct _NVENC_EXTERNAL_ME_HINT { int32_t mvx : 12; /**< [in]: Specifies the x component of integer pixel MV (relative to current MB) S12.0. */ int32_t mvy : 10; /**< [in]: Specifies the y component of integer pixel MV (relative to current MB) S10.0 .*/ int32_t refidx : 5; /**< [in]: Specifies the reference index (31=invalid). Current we support only 1 reference frame per direction for external hints, so \p refidx must be 0. */ int32_t dir : 1; /**< [in]: Specifies the direction of motion estimation . 0=L0 1=L1.*/ int32_t partType : 2; /**< [in]: Specifies the block partition type.0=16x16 1=16x8 2=8x16 3=8x8 (blocks in partition must be consecutive).*/ int32_t lastofPart : 1; /**< [in]: Set to 1 for the last MV of (sub) partition */ int32_t lastOfMB : 1; /**< [in]: Set to 1 for the last MV of macroblock. */ } NVENC_EXTERNAL_ME_HINT; /** * \struct _NVENC_EXTERNAL_ME_SB_HINT * External Motion Vector SB hint structure for AV1 */ typedef struct _NVENC_EXTERNAL_ME_SB_HINT { int16_t refidx : 5; /**< [in]: Specifies the reference index (31=invalid) */ int16_t direction : 1; /**< [in]: Specifies the direction of motion estimation . 0=L0 1=L1.*/ int16_t bi : 1; /**< [in]: Specifies reference mode 0=single mv, 1=compound mv */ int16_t partition_type : 3; /**< [in]: Specifies the partition type: 0: 2NX2N, 1:2NxN, 2:Nx2N. reserved 3bits for future modes */ int16_t x8 : 3; /**< [in]: Specifies the current partition's top left x position in 8 pixel unit */ int16_t last_of_cu : 1; /**< [in]: Set to 1 for the last MV current CU */ int16_t last_of_sb : 1; /**< [in]: Set to 1 for the last MV of current SB */ int16_t reserved0 : 1; /**< [in]: Reserved and must be set to 0 */ int16_t mvx : 14; /**< [in]: Specifies the x component of integer pixel MV (relative to current MB) S12.2. */ int16_t cu_size : 2; /**< [in]: Specifies the CU size: 0: 8x8, 1: 16x16, 2:32x32, 3:64x64 */ int16_t mvy : 12; /**< [in]: Specifies the y component of integer pixel MV (relative to current MB) S10.2 .*/ int16_t y8 : 3; /**< [in]: Specifies the current partition's top left y position in 8 pixel unit */ int16_t reserved1 : 1; /**< [in]: Reserved and must be set to 0 */ } NVENC_EXTERNAL_ME_SB_HINT; /** * \struct _NV_ENC_CONFIG_H264 * H264 encoder configuration parameters */ typedef struct _NV_ENC_CONFIG_H264 { uint32_t enableTemporalSVC :1; /**< [in]: Set to 1 to enable SVC temporal*/ uint32_t enableStereoMVC :1; /**< [in]: Set to 1 to enable stereo MVC*/ uint32_t hierarchicalPFrames :1; /**< [in]: Set to 1 to enable hierarchical P Frames */ uint32_t hierarchicalBFrames :1; /**< [in]: Set to 1 to enable hierarchical B Frames */ uint32_t outputBufferingPeriodSEI :1; /**< [in]: Set to 1 to write SEI buffering period syntax in the bitstream */ uint32_t outputPictureTimingSEI :1; /**< [in]: Set to 1 to write SEI picture timing syntax in the bitstream. */ uint32_t outputAUD :1; /**< [in]: Set to 1 to write access unit delimiter syntax in bitstream */ uint32_t disableSPSPPS :1; /**< [in]: Set to 1 to disable writing of Sequence and Picture parameter info in bitstream */ uint32_t outputFramePackingSEI :1; /**< [in]: Set to 1 to enable writing of frame packing arrangement SEI messages to bitstream */ uint32_t outputRecoveryPointSEI :1; /**< [in]: Set to 1 to enable writing of recovery point SEI message */ uint32_t enableIntraRefresh :1; /**< [in]: Set to 1 to enable gradual decoder refresh or intra refresh. If the GOP structure uses B frames this will be ignored */ uint32_t enableConstrainedEncoding :1; /**< [in]: Set this to 1 to enable constrainedFrame encoding where each slice in the constrained picture is independent of other slices. Constrained encoding works only with rectangular slices. Check support for constrained encoding using ::NV_ENC_CAPS_SUPPORT_CONSTRAINED_ENCODING caps. */ uint32_t repeatSPSPPS :1; /**< [in]: Set to 1 to enable writing of Sequence and Picture parameter for every IDR frame */ uint32_t enableVFR :1; /**< [in]: Setting enableVFR=1 currently only sets the fixed_frame_rate_flag=0 in the VUI but otherwise has no impact on the encoder behavior. For more details please refer to E.1 VUI syntax of H.264 standard. Note, however, that NVENC does not support VFR encoding and rate control. */ uint32_t enableLTR :1; /**< [in]: Set to 1 to enable LTR (Long Term Reference) frame support. LTR can be used in two modes: "LTR Trust" mode and "LTR Per Picture" mode. LTR Trust mode: In this mode, ltrNumFrames pictures after IDR are automatically marked as LTR. This mode is enabled by setting ltrTrustMode = 1. Use of LTR Trust mode is strongly discouraged as this mode may be deprecated in future. LTR Per Picture mode: In this mode, client can control whether the current picture should be marked as LTR. Enable this mode by setting ltrTrustMode = 0 and ltrMarkFrame = 1 for the picture to be marked as LTR. This is the preferred mode for using LTR. Note that LTRs are not supported if encoding session is configured with B-frames */ uint32_t qpPrimeYZeroTransformBypassFlag :1; /**< [in]: To enable lossless encode set this to 1, set QP to 0 and RC_mode to NV_ENC_PARAMS_RC_CONSTQP and profile to HIGH_444_PREDICTIVE_PROFILE. Check support for lossless encoding using ::NV_ENC_CAPS_SUPPORT_LOSSLESS_ENCODE caps. */ uint32_t useConstrainedIntraPred :1; /**< [in]: Set 1 to enable constrained intra prediction. */ uint32_t enableFillerDataInsertion :1; /**< [in]: Set to 1 to enable insertion of filler data in the bitstream. This flag will take effect only when one of the CBR rate control modes (NV_ENC_PARAMS_RC_CBR, NV_ENC_PARAMS_RC_CBR_HQ, NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ) is in use and both NV_ENC_INITIALIZE_PARAMS::frameRateNum and NV_ENC_INITIALIZE_PARAMS::frameRateDen are set to non-zero values. Setting this field when NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is also set is currently not supported and will make ::NvEncInitializeEncoder() return an error. */ uint32_t disableSVCPrefixNalu :1; /**< [in]: Set to 1 to disable writing of SVC Prefix NALU preceding each slice in bitstream. Applicable only when temporal SVC is enabled (NV_ENC_CONFIG_H264::enableTemporalSVC = 1). */ uint32_t enableScalabilityInfoSEI :1; /**< [in]: Set to 1 to enable writing of Scalability Information SEI message preceding each IDR picture in bitstream Applicable only when temporal SVC is enabled (NV_ENC_CONFIG_H264::enableTemporalSVC = 1). */ uint32_t singleSliceIntraRefresh :1; /**< [in]: Set to 1 to maintain single slice in frames during intra refresh. Check support for single slice intra refresh using ::NV_ENC_CAPS_SINGLE_SLICE_INTRA_REFRESH caps. This flag will be ignored if the value returned for ::NV_ENC_CAPS_SINGLE_SLICE_INTRA_REFRESH caps is false. */ uint32_t enableTimeCode :1; /**< [in]: Set to 1 to enable writing of clock timestamp sets in picture timing SEI. Note that this flag will be ignored for D3D12 interface. */ uint32_t reservedBitFields :10; /**< [in]: Reserved bitfields and must be set to 0 */ uint32_t level; /**< [in]: Specifies the encoding level. Client is recommended to set this to NV_ENC_LEVEL_AUTOSELECT in order to enable the NvEncodeAPI interface to select the correct level. */ uint32_t idrPeriod; /**< [in]: Specifies the IDR interval. If not set, this is made equal to gopLength in NV_ENC_CONFIG.Low latency application client can set IDR interval to NVENC_INFINITE_GOPLENGTH so that IDR frames are not inserted automatically. */ uint32_t separateColourPlaneFlag; /**< [in]: Set to 1 to enable 4:4:4 separate colour planes */ uint32_t disableDeblockingFilterIDC; /**< [in]: Specifies the deblocking filter mode. Permissible value range: [0,2]. This flag corresponds to the flag disable_deblocking_filter_idc specified in section 7.4.3 of H.264 specification, which specifies whether the operation of the deblocking filter shall be disabled across some block edges of the slice and specifies for which edges the filtering is disabled. See section 7.4.3 of H.264 specification for more details.*/ uint32_t numTemporalLayers; /**< [in]: Specifies number of temporal layers to be used for hierarchical coding / temporal SVC. Valid value range is [1,::NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS] */ uint32_t spsId; /**< [in]: Specifies the SPS id of the sequence header */ uint32_t ppsId; /**< [in]: Specifies the PPS id of the picture header */ NV_ENC_H264_ADAPTIVE_TRANSFORM_MODE adaptiveTransformMode; /**< [in]: Specifies the AdaptiveTransform Mode. Check support for AdaptiveTransform mode using ::NV_ENC_CAPS_SUPPORT_ADAPTIVE_TRANSFORM caps. */ NV_ENC_H264_FMO_MODE fmoMode; /**< [in]: Specified the FMO Mode. Check support for FMO using ::NV_ENC_CAPS_SUPPORT_FMO caps. */ NV_ENC_H264_BDIRECT_MODE bdirectMode; /**< [in]: Specifies the BDirect mode. Check support for BDirect mode using ::NV_ENC_CAPS_SUPPORT_BDIRECT_MODE caps.*/ NV_ENC_H264_ENTROPY_CODING_MODE entropyCodingMode; /**< [in]: Specifies the entropy coding mode. Check support for CABAC mode using ::NV_ENC_CAPS_SUPPORT_CABAC caps. */ NV_ENC_STEREO_PACKING_MODE stereoMode; /**< [in]: Specifies the stereo frame packing mode which is to be signaled in frame packing arrangement SEI */ uint32_t intraRefreshPeriod; /**< [in]: Specifies the interval between successive intra refresh if enableIntrarefresh is set. Requires enableIntraRefresh to be set. Will be disabled if NV_ENC_CONFIG::gopLength is not set to NVENC_INFINITE_GOPLENGTH. */ uint32_t intraRefreshCnt; /**< [in]: Specifies the length of intra refresh in number of frames for periodic intra refresh. This value should be smaller than intraRefreshPeriod */ uint32_t maxNumRefFrames; /**< [in]: Specifies the DPB size used for encoding. Setting it to 0 will let driver use the default DPB size. The low latency application which wants to invalidate reference frame as an error resilience tool is recommended to use a large DPB size so that the encoder can keep old reference frames which can be used if recent frames are invalidated. */ uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices sliceMode = 0 MB based slices, sliceMode = 1 Byte based slices, sliceMode = 2 MB row based slices, sliceMode = 3 numSlices in Picture. When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: sliceMode = 0, sliceModeData specifies # of MBs in each slice (except last slice) sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) sliceMode = 2, sliceModeData specifies # of MB rows in each slice (except last slice) sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ NV_ENC_CONFIG_H264_VUI_PARAMETERS h264VUIParameters; /**< [in]: Specifies the H264 video usability info parameters */ uint32_t ltrNumFrames; /**< [in]: Specifies the number of LTR frames. This parameter has different meaning in two LTR modes. In "LTR Trust" mode (ltrTrustMode = 1), encoder will mark the first ltrNumFrames base layer reference frames within each IDR interval as LTR. In "LTR Per Picture" mode (ltrTrustMode = 0 and ltrMarkFrame = 1), ltrNumFrames specifies maximum number of LTR frames in DPB. */ uint32_t ltrTrustMode; /**< [in]: Specifies the LTR operating mode. See comments near NV_ENC_CONFIG_H264::enableLTR for description of the two modes. Set to 1 to use "LTR Trust" mode of LTR operation. Clients are discouraged to use "LTR Trust" mode as this mode may be deprecated in future releases. Set to 0 when using "LTR Per Picture" mode of LTR operation. */ uint32_t chromaFormatIDC; /**< [in]: Specifies the chroma format. Should be set to 1 for yuv420 input, 3 for yuv444 input. Check support for YUV444 encoding using ::NV_ENC_CAPS_SUPPORT_YUV444_ENCODE caps.*/ uint32_t maxTemporalLayers; /**< [in]: Specifies the max temporal layer used for temporal SVC / hierarchical coding. Defaut value of this field is NV_ENC_CAPS::NV_ENC_CAPS_NUM_MAX_TEMPORAL_LAYERS. Note that the value NV_ENC_CONFIG_H264::maxNumRefFrames should be greater than or equal to (NV_ENC_CONFIG_H264::maxTemporalLayers - 2) * 2, for NV_ENC_CONFIG_H264::maxTemporalLayers >= 2.*/ NV_ENC_BFRAME_REF_MODE useBFramesAsRef; /**< [in]: Specifies the B-Frame as reference mode. Check support for useBFramesAsRef mode using ::NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE caps.*/ NV_ENC_NUM_REF_FRAMES numRefL0; /**< [in]: Specifies max number of reference frames in reference picture list L0, that can be used by hardware for prediction of a frame. Check support for numRefL0 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ NV_ENC_NUM_REF_FRAMES numRefL1; /**< [in]: Specifies max number of reference frames in reference picture list L1, that can be used by hardware for prediction of a frame. Check support for numRefL1 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ uint32_t reserved1[267]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_CONFIG_H264; /** * \struct _NV_ENC_CONFIG_HEVC * HEVC encoder configuration parameters to be set during initialization. */ typedef struct _NV_ENC_CONFIG_HEVC { uint32_t level; /**< [in]: Specifies the level of the encoded bitstream.*/ uint32_t tier; /**< [in]: Specifies the level tier of the encoded bitstream.*/ NV_ENC_HEVC_CUSIZE minCUSize; /**< [in]: Specifies the minimum size of luma coding unit.*/ NV_ENC_HEVC_CUSIZE maxCUSize; /**< [in]: Specifies the maximum size of luma coding unit. Currently NVENC SDK only supports maxCUSize equal to NV_ENC_HEVC_CUSIZE_32x32.*/ uint32_t useConstrainedIntraPred :1; /**< [in]: Set 1 to enable constrained intra prediction. */ uint32_t disableDeblockAcrossSliceBoundary :1; /**< [in]: Set 1 to disable in loop filtering across slice boundary.*/ uint32_t outputBufferingPeriodSEI :1; /**< [in]: Set 1 to write SEI buffering period syntax in the bitstream */ uint32_t outputPictureTimingSEI :1; /**< [in]: Set 1 to write SEI picture timing syntax in the bitstream */ uint32_t outputAUD :1; /**< [in]: Set 1 to write Access Unit Delimiter syntax. */ uint32_t enableLTR :1; /**< [in]: Set to 1 to enable LTR (Long Term Reference) frame support. LTR can be used in two modes: "LTR Trust" mode and "LTR Per Picture" mode. LTR Trust mode: In this mode, ltrNumFrames pictures after IDR are automatically marked as LTR. This mode is enabled by setting ltrTrustMode = 1. Use of LTR Trust mode is strongly discouraged as this mode may be deprecated in future releases. LTR Per Picture mode: In this mode, client can control whether the current picture should be marked as LTR. Enable this mode by setting ltrTrustMode = 0 and ltrMarkFrame = 1 for the picture to be marked as LTR. This is the preferred mode for using LTR. Note that LTRs are not supported if encoding session is configured with B-frames */ uint32_t disableSPSPPS :1; /**< [in]: Set 1 to disable VPS, SPS and PPS signaling in the bitstream. */ uint32_t repeatSPSPPS :1; /**< [in]: Set 1 to output VPS,SPS and PPS for every IDR frame.*/ uint32_t enableIntraRefresh :1; /**< [in]: Set 1 to enable gradual decoder refresh or intra refresh. If the GOP structure uses B frames this will be ignored */ uint32_t chromaFormatIDC :2; /**< [in]: Specifies the chroma format. Should be set to 1 for yuv420 input, 3 for yuv444 input.*/ uint32_t pixelBitDepthMinus8 :3; /**< [in]: Specifies pixel bit depth minus 8. Should be set to 0 for 8 bit input, 2 for 10 bit input.*/ uint32_t enableFillerDataInsertion :1; /**< [in]: Set to 1 to enable insertion of filler data in the bitstream. This flag will take effect only when one of the CBR rate control modes (NV_ENC_PARAMS_RC_CBR, NV_ENC_PARAMS_RC_CBR_HQ, NV_ENC_PARAMS_RC_CBR_LOWDELAY_HQ) is in use and both NV_ENC_INITIALIZE_PARAMS::frameRateNum and NV_ENC_INITIALIZE_PARAMS::frameRateDen are set to non-zero values. Setting this field when NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is also set is currently not supported and will make ::NvEncInitializeEncoder() return an error. */ uint32_t enableConstrainedEncoding :1; /**< [in]: Set this to 1 to enable constrainedFrame encoding where each slice in the constrained picture is independent of other slices. Constrained encoding works only with rectangular slices. Check support for constrained encoding using ::NV_ENC_CAPS_SUPPORT_CONSTRAINED_ENCODING caps. */ uint32_t enableAlphaLayerEncoding :1; /**< [in]: Set this to 1 to enable HEVC encode with alpha layer. */ uint32_t singleSliceIntraRefresh :1; /**< [in]: Set this to 1 to maintain single slice frames during intra refresh. Check support for single slice intra refresh using ::NV_ENC_CAPS_SINGLE_SLICE_INTRA_REFRESH caps. This flag will be ignored if the value returned for ::NV_ENC_CAPS_SINGLE_SLICE_INTRA_REFRESH caps is false. */ uint32_t outputRecoveryPointSEI :1; /**< [in]: Set to 1 to enable writing of recovery point SEI message */ uint32_t outputTimeCodeSEI :1; /**< [in]: Set 1 to write SEI time code syntax in the bitstream. Note that this flag will be ignored for D3D12 interface.*/ uint32_t reserved :12; /**< [in]: Reserved bitfields.*/ uint32_t idrPeriod; /**< [in]: Specifies the IDR interval. If not set, this is made equal to gopLength in NV_ENC_CONFIG. Low latency application client can set IDR interval to NVENC_INFINITE_GOPLENGTH so that IDR frames are not inserted automatically. */ uint32_t intraRefreshPeriod; /**< [in]: Specifies the interval between successive intra refresh if enableIntrarefresh is set. Requires enableIntraRefresh to be set. Will be disabled if NV_ENC_CONFIG::gopLength is not set to NVENC_INFINITE_GOPLENGTH. */ uint32_t intraRefreshCnt; /**< [in]: Specifies the length of intra refresh in number of frames for periodic intra refresh. This value should be smaller than intraRefreshPeriod */ uint32_t maxNumRefFramesInDPB; /**< [in]: Specifies the maximum number of references frames in the DPB.*/ uint32_t ltrNumFrames; /**< [in]: This parameter has different meaning in two LTR modes. In "LTR Trust" mode (ltrTrustMode = 1), encoder will mark the first ltrNumFrames base layer reference frames within each IDR interval as LTR. In "LTR Per Picture" mode (ltrTrustMode = 0 and ltrMarkFrame = 1), ltrNumFrames specifies maximum number of LTR frames in DPB. These ltrNumFrames acts as a guidance to the encoder and are not necessarily honored. To achieve a right balance between the encoding quality and keeping LTR frames in the DPB queue, the encoder can internally limit the number of LTR frames. The number of LTR frames actually used depends upon the encoding preset being used; Faster encoding presets will use fewer LTR frames.*/ uint32_t vpsId; /**< [in]: Specifies the VPS id of the video parameter set */ uint32_t spsId; /**< [in]: Specifies the SPS id of the sequence header */ uint32_t ppsId; /**< [in]: Specifies the PPS id of the picture header */ uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices sliceMode = 0 CTU based slices, sliceMode = 1 Byte based slices, sliceMode = 2 CTU row based slices, sliceMode = 3, numSlices in Picture When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: sliceMode = 0, sliceModeData specifies # of CTUs in each slice (except last slice) sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) sliceMode = 2, sliceModeData specifies # of CTU rows in each slice (except last slice) sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ uint32_t maxTemporalLayersMinus1; /**< [in]: Specifies the max temporal layer used for hierarchical coding. */ NV_ENC_CONFIG_HEVC_VUI_PARAMETERS hevcVUIParameters; /**< [in]: Specifies the HEVC video usability info parameters */ uint32_t ltrTrustMode; /**< [in]: Specifies the LTR operating mode. See comments near NV_ENC_CONFIG_HEVC::enableLTR for description of the two modes. Set to 1 to use "LTR Trust" mode of LTR operation. Clients are discouraged to use "LTR Trust" mode as this mode may be deprecated in future releases. Set to 0 when using "LTR Per Picture" mode of LTR operation. */ NV_ENC_BFRAME_REF_MODE useBFramesAsRef; /**< [in]: Specifies the B-Frame as reference mode. Check support for useBFramesAsRef mode using ::NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE caps.*/ NV_ENC_NUM_REF_FRAMES numRefL0; /**< [in]: Specifies max number of reference frames in reference picture list L0, that can be used by hardware for prediction of a frame. Check support for numRefL0 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ NV_ENC_NUM_REF_FRAMES numRefL1; /**< [in]: Specifies max number of reference frames in reference picture list L1, that can be used by hardware for prediction of a frame. Check support for numRefL1 using ::NV_ENC_CAPS_SUPPORT_MULTIPLE_REF_FRAMES caps. */ uint32_t reserved1[214]; /**< [in]: Reserved and must be set to 0.*/ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_CONFIG_HEVC; #define NV_MAX_TILE_COLS_AV1 64 #define NV_MAX_TILE_ROWS_AV1 64 /** * \struct _NV_ENC_FILM_GRAIN_PARAMS_AV1 * AV1 Film Grain Parameters structure */ typedef struct _NV_ENC_FILM_GRAIN_PARAMS_AV1 { uint32_t applyGrain :1; /**< [in]: Set to 1 to specify film grain should be added to frame */ uint32_t chromaScalingFromLuma :1; /**< [in]: Set to 1 to specify the chroma scaling is inferred from luma scaling */ uint32_t overlapFlag :1; /**< [in]: Set to 1 to indicate that overlap between film grain blocks should be applied*/ uint32_t clipToRestrictedRange :1; /**< [in]: Set to 1 to clip values to restricted (studio) range after adding film grain */ uint32_t grainScalingMinus8 :2; /**< [in]: Represents the shift - 8 applied to the values of the chroma component */ uint32_t arCoeffLag :2; /**< [in]: Specifies the number of auto-regressive coefficients for luma and chroma */ uint32_t numYPoints :4; /**< [in]: Specifies the number of points for the piecewise linear scaling function of the luma component */ uint32_t numCbPoints :4; /**< [in]: Specifies the number of points for the piecewise linear scaling function of the cb component */ uint32_t numCrPoints :4; /**< [in]: Specifies the number of points for the piecewise linear scaling function of the cr component */ uint32_t arCoeffShiftMinus6 :2; /**< [in]: specifies the range of the auto-regressive coefficients */ uint32_t grainScaleShift :2; /**< [in]: Specifies how much the Gaussian random numbers should be scaled down during the grain synthesi process */ uint32_t reserved1 :8; /**< [in]: Reserved bits field - should be set to 0 */ uint8_t pointYValue[14]; /**< [in]: pointYValue[i]: x coordinate for i-th point of luma piecewise linear scaling function. Values on a scale of 0...255 */ uint8_t pointYScaling[14]; /**< [in]: pointYScaling[i]: i-th point output value of luma piecewise linear scaling function */ uint8_t pointCbValue[10]; /**< [in]: pointCbValue[i]: x coordinate for i-th point of cb piecewise linear scaling function. Values on a scale of 0...255 */ uint8_t pointCbScaling[10]; /**< [in]: pointCbScaling[i]: i-th point output value of cb piecewise linear scaling function */ uint8_t pointCrValue[10]; /**< [in]: pointCrValue[i]: x coordinate for i-th point of cr piecewise linear scaling function. Values on a scale of 0...255 */ uint8_t pointCrScaling[10]; /**< [in]: pointCrScaling[i]: i-th point output value of cr piecewise linear scaling function */ uint8_t arCoeffsYPlus128[24]; /**< [in]: Specifies auto-regressive coefficients used for the Y plane */ uint8_t arCoeffsCbPlus128[25]; /**< [in]: Specifies auto-regressive coefficients used for the U plane */ uint8_t arCoeffsCrPlus128[25]; /**< [in]: Specifies auto-regressive coefficients used for the V plane */ uint8_t reserved2[2]; /**< [in]: Reserved bytes - should be set to 0 */ uint8_t cbMult; /**< [in]: Represents a multiplier for the cb component used in derivation of the input index to the cb component scaling function */ uint8_t cbLumaMult; /**< [in]: represents a multiplier for the average luma component used in derivation of the input index to the cb component scaling function. */ uint16_t cbOffset; /**< [in]: Represents an offset used in derivation of the input index to the cb component scaling function */ uint8_t crMult; /**< [in]: Represents a multiplier for the cr component used in derivation of the input index to the cr component scaling function */ uint8_t crLumaMult; /**< [in]: represents a multiplier for the average luma component used in derivation of the input index to the cr component scaling function. */ uint16_t crOffset; /**< [in]: Represents an offset used in derivation of the input index to the cr component scaling function */ } NV_ENC_FILM_GRAIN_PARAMS_AV1; /** * \struct _NV_ENC_CONFIG_AV1 * AV1 encoder configuration parameters to be set during initialization. */ typedef struct _NV_ENC_CONFIG_AV1 { uint32_t level; /**< [in]: Specifies the level of the encoded bitstream.*/ uint32_t tier; /**< [in]: Specifies the level tier of the encoded bitstream.*/ NV_ENC_AV1_PART_SIZE minPartSize; /**< [in]: Specifies the minimum size of luma coding block partition.*/ NV_ENC_AV1_PART_SIZE maxPartSize; /**< [in]: Specifies the maximum size of luma coding block partition.*/ uint32_t outputAnnexBFormat : 1; /**< [in]: Set 1 to use Annex B format for bitstream output.*/ uint32_t enableTimingInfo : 1; /**< [in]: Set 1 to write Timing Info into sequence/frame headers */ uint32_t enableDecoderModelInfo : 1; /**< [in]: Set 1 to write Decoder Model Info into sequence/frame headers */ uint32_t enableFrameIdNumbers : 1; /**< [in]: Set 1 to write Frame id numbers in bitstream */ uint32_t disableSeqHdr : 1; /**< [in]: Set 1 to disable Sequence Header signaling in the bitstream. */ uint32_t repeatSeqHdr : 1; /**< [in]: Set 1 to output Sequence Header for every Key frame.*/ uint32_t enableIntraRefresh : 1; /**< [in]: Set 1 to enable gradual decoder refresh or intra refresh. If the GOP structure uses B frames this will be ignored */ uint32_t chromaFormatIDC : 2; /**< [in]: Specifies the chroma format. Should be set to 1 for yuv420 input (yuv444 input currently not supported).*/ uint32_t enableBitstreamPadding : 1; /**< [in]: Set 1 to enable bitstream padding. */ uint32_t enableCustomTileConfig : 1; /**< [in]: Set 1 to enable custom tile configuration: numTileColumns and numTileRows must have non zero values and tileWidths and tileHeights must point to a valid address */ uint32_t enableFilmGrainParams : 1; /**< [in]: Set 1 to enable custom film grain parameters: filmGrainParams must point to a valid address */ uint32_t inputPixelBitDepthMinus8 : 3; /**< [in]: Specifies pixel bit depth minus 8 of video input. Should be set to 0 for 8 bit input, 2 for 10 bit input.*/ uint32_t pixelBitDepthMinus8 : 3; /**< [in]: Specifies pixel bit depth minus 8 of encoded video. Should be set to 0 for 8 bit, 2 for 10 bit. HW will do the bitdepth conversion internally from inputPixelBitDepthMinus8 -> pixelBitDepthMinus8 if bit dpeths differ Support for 8 bit input to 10 bit encode conversion only */ uint32_t reserved : 14; /**< [in]: Reserved bitfields.*/ uint32_t idrPeriod; /**< [in]: Specifies the IDR/Key frame interval. If not set, this is made equal to gopLength in NV_ENC_CONFIG.Low latency application client can set IDR interval to NVENC_INFINITE_GOPLENGTH so that IDR frames are not inserted automatically. */ uint32_t intraRefreshPeriod; /**< [in]: Specifies the interval between successive intra refresh if enableIntrarefresh is set. Requires enableIntraRefresh to be set. Will be disabled if NV_ENC_CONFIG::gopLength is not set to NVENC_INFINITE_GOPLENGTH. */ uint32_t intraRefreshCnt; /**< [in]: Specifies the length of intra refresh in number of frames for periodic intra refresh. This value should be smaller than intraRefreshPeriod */ uint32_t maxNumRefFramesInDPB; /**< [in]: Specifies the maximum number of references frames in the DPB.*/ uint32_t numTileColumns; /**< [in]: This parameter in conjunction with the flag enableCustomTileConfig and the array tileWidths[] specifies the way in which the picture is divided into tile columns. When enableCustomTileConfig == 0, the picture will be uniformly divided into numTileColumns tile columns. If numTileColumns is not a power of 2, it will be rounded down to the next power of 2 value. If numTileColumns == 0, the picture will be coded with the smallest number of vertical tiles as allowed by standard. When enableCustomTileConfig == 1, numTileColumns must be > 0 and <= NV_MAX_TILE_COLS_AV1 and tileWidths must point to a valid array of numTileColumns entries. Entry i specifies the width in 64x64 CTU unit of tile colum i. The sum of all the entries should be equal to the picture width in 64x64 CTU units. */ uint32_t numTileRows; /**< [in]: This parameter in conjunction with the flag enableCustomTileConfig and the array tileHeights[] specifies the way in which the picture is divided into tiles rows When enableCustomTileConfig == 0, the picture will be uniformly divided into numTileRows tile rows. If numTileRows is not a power of 2, it will be rounded down to the next power of 2 value. If numTileRows == 0, the picture will be coded with the smallest number of horizontal tiles as allowed by standard. When enableCustomTileConfig == 1, numTileRows must be > 0 and <= NV_MAX_TILE_ROWS_AV1 and tileHeights must point to a valid array of numTileRows entries. Entry i specifies the height in 64x64 CTU unit of tile row i. The sum of all the entries should be equal to the picture hieght in 64x64 CTU units. */ uint32_t *tileWidths; /**< [in]: If enableCustomTileConfig == 1, tileWidths[i] specifies the width of tile column i in 64x64 CTU unit, with 0 <= i <= numTileColumns -1. */ uint32_t *tileHeights; /**< [in]: If enableCustomTileConfig == 1, tileHeights[i] specifies the height of tile row i in 64x64 CTU unit, with 0 <= i <= numTileRows -1. */ uint32_t maxTemporalLayersMinus1; /**< [in]: Specifies the max temporal layer used for hierarchical coding. */ NV_ENC_VUI_COLOR_PRIMARIES colorPrimaries; /**< [in]: as defined in section of ISO/IEC 23091-4/ITU-T H.273 */ NV_ENC_VUI_TRANSFER_CHARACTERISTIC transferCharacteristics; /**< [in]: as defined in section of ISO/IEC 23091-4/ITU-T H.273 */ NV_ENC_VUI_MATRIX_COEFFS matrixCoefficients; /**< [in]: as defined in section of ISO/IEC 23091-4/ITU-T H.273 */ uint32_t colorRange; /**< [in]: 0: studio swing representation - 1: full swing representation */ uint32_t chromaSamplePosition; /**< [in]: 0: unknown 1: Horizontally collocated with luma (0,0) sample, between two vertical samples 2: Co-located with luma (0,0) sample */ NV_ENC_BFRAME_REF_MODE useBFramesAsRef; /**< [in]: Specifies the B-Frame as reference mode. Check support for useBFramesAsRef mode using ::NV_ENC_CAPS_SUPPORT_BFRAME_REF_MODE caps.*/ NV_ENC_FILM_GRAIN_PARAMS_AV1 *filmGrainParams; /**< [in]: If enableFilmGrainParams == 1, filmGrainParams must point to a valid NV_ENC_FILM_GRAIN_PARAMS_AV1 structure */ NV_ENC_NUM_REF_FRAMES numFwdRefs; /**< [in]: Specifies max number of forward reference frame used for prediction of a frame. It must be in range 1-4 (Last, Last2, last3 and Golden). It's a suggestive value not necessarily be honored always. */ NV_ENC_NUM_REF_FRAMES numBwdRefs; /**< [in]: Specifies max number of L1 list reference frame used for prediction of a frame. It must be in range 1-3 (Backward, Altref2, Altref). It's a suggestive value not necessarily be honored always. */ uint32_t reserved1[235]; /**< [in]: Reserved and must be set to 0.*/ void* reserved2[62]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_CONFIG_AV1; /** * \struct _NV_ENC_CONFIG_H264_MEONLY * H264 encoder configuration parameters for ME only Mode * */ typedef struct _NV_ENC_CONFIG_H264_MEONLY { uint32_t disablePartition16x16 :1; /**< [in]: Disable Motion Estimation on 16x16 blocks*/ uint32_t disablePartition8x16 :1; /**< [in]: Disable Motion Estimation on 8x16 blocks*/ uint32_t disablePartition16x8 :1; /**< [in]: Disable Motion Estimation on 16x8 blocks*/ uint32_t disablePartition8x8 :1; /**< [in]: Disable Motion Estimation on 8x8 blocks*/ uint32_t disableIntraSearch :1; /**< [in]: Disable Intra search during Motion Estimation*/ uint32_t bStereoEnable :1; /**< [in]: Enable Stereo Mode for Motion Estimation where each view is independently executed*/ uint32_t reserved :26; /**< [in]: Reserved and must be set to 0 */ uint32_t reserved1 [255]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_CONFIG_H264_MEONLY; /** * \struct _NV_ENC_CONFIG_HEVC_MEONLY * HEVC encoder configuration parameters for ME only Mode * */ typedef struct _NV_ENC_CONFIG_HEVC_MEONLY { uint32_t reserved [256]; /**< [in]: Reserved and must be set to 0 */ void* reserved1[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_CONFIG_HEVC_MEONLY; /** * \struct _NV_ENC_CODEC_CONFIG * Codec-specific encoder configuration parameters to be set during initialization. */ typedef union _NV_ENC_CODEC_CONFIG { NV_ENC_CONFIG_H264 h264Config; /**< [in]: Specifies the H.264-specific encoder configuration. */ NV_ENC_CONFIG_HEVC hevcConfig; /**< [in]: Specifies the HEVC-specific encoder configuration. */ NV_ENC_CONFIG_AV1 av1Config; /**< [in]: Specifies the AV1-specific encoder configuration. */ NV_ENC_CONFIG_H264_MEONLY h264MeOnlyConfig; /**< [in]: Specifies the H.264-specific ME only encoder configuration. */ NV_ENC_CONFIG_HEVC_MEONLY hevcMeOnlyConfig; /**< [in]: Specifies the HEVC-specific ME only encoder configuration. */ uint32_t reserved[320]; /**< [in]: Reserved and must be set to 0 */ } NV_ENC_CODEC_CONFIG; /** * \struct _NV_ENC_CONFIG * Encoder configuration parameters to be set during initialization. */ typedef struct _NV_ENC_CONFIG { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_CONFIG_VER. */ GUID profileGUID; /**< [in]: Specifies the codec profile GUID. If client specifies \p NV_ENC_CODEC_PROFILE_AUTOSELECT_GUID the NvEncodeAPI interface will select the appropriate codec profile. */ uint32_t gopLength; /**< [in]: Specifies the number of pictures in one GOP. Low latency application client can set goplength to NVENC_INFINITE_GOPLENGTH so that keyframes are not inserted automatically. */ int32_t frameIntervalP; /**< [in]: Specifies the GOP pattern as follows: \p frameIntervalP = 0: I, 1: IPP, 2: IBP, 3: IBBP If goplength is set to NVENC_INFINITE_GOPLENGTH \p frameIntervalP should be set to 1. */ uint32_t monoChromeEncoding; /**< [in]: Set this to 1 to enable monochrome encoding for this session. */ NV_ENC_PARAMS_FRAME_FIELD_MODE frameFieldMode; /**< [in]: Specifies the frame/field mode. Check support for field encoding using ::NV_ENC_CAPS_SUPPORT_FIELD_ENCODING caps. Using a frameFieldMode other than NV_ENC_PARAMS_FRAME_FIELD_MODE_FRAME for RGB input is not supported. */ NV_ENC_MV_PRECISION mvPrecision; /**< [in]: Specifies the desired motion vector prediction precision. */ NV_ENC_RC_PARAMS rcParams; /**< [in]: Specifies the rate control parameters for the current encoding session. */ NV_ENC_CODEC_CONFIG encodeCodecConfig; /**< [in]: Specifies the codec specific config parameters through this union. */ uint32_t reserved [278]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_CONFIG; /** macro for constructing the version field of ::_NV_ENC_CONFIG */ #define NV_ENC_CONFIG_VER (NVENCAPI_STRUCT_VERSION(8) | ( 1u<<31 )) /** * Tuning information of NVENC encoding (TuningInfo is not applicable to H264 and HEVC MEOnly mode). */ typedef enum NV_ENC_TUNING_INFO { NV_ENC_TUNING_INFO_UNDEFINED = 0, /**< Undefined tuningInfo. Invalid value for encoding. */ NV_ENC_TUNING_INFO_HIGH_QUALITY = 1, /**< Tune presets for latency tolerant encoding.*/ NV_ENC_TUNING_INFO_LOW_LATENCY = 2, /**< Tune presets for low latency streaming.*/ NV_ENC_TUNING_INFO_ULTRA_LOW_LATENCY = 3, /**< Tune presets for ultra low latency streaming.*/ NV_ENC_TUNING_INFO_LOSSLESS = 4, /**< Tune presets for lossless encoding.*/ NV_ENC_TUNING_INFO_COUNT /**< Count number of tuningInfos. Invalid value. */ }NV_ENC_TUNING_INFO; /** * \struct _NV_ENC_INITIALIZE_PARAMS * Encode Session Initialization parameters. */ typedef struct _NV_ENC_INITIALIZE_PARAMS { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_INITIALIZE_PARAMS_VER. */ GUID encodeGUID; /**< [in]: Specifies the Encode GUID for which the encoder is being created. ::NvEncInitializeEncoder() API will fail if this is not set, or set to unsupported value. */ GUID presetGUID; /**< [in]: Specifies the preset for encoding. If the preset GUID is set then , the preset configuration will be applied before any other parameter. */ uint32_t encodeWidth; /**< [in]: Specifies the encode width. If not set ::NvEncInitializeEncoder() API will fail. */ uint32_t encodeHeight; /**< [in]: Specifies the encode height. If not set ::NvEncInitializeEncoder() API will fail. */ uint32_t darWidth; /**< [in]: Specifies the display aspect ratio width (H264/HEVC) or the render width (AV1). */ uint32_t darHeight; /**< [in]: Specifies the display aspect ratio height (H264/HEVC) or the render height (AV1). */ uint32_t frameRateNum; /**< [in]: Specifies the numerator for frame rate used for encoding in frames per second ( Frame rate = frameRateNum / frameRateDen ). */ uint32_t frameRateDen; /**< [in]: Specifies the denominator for frame rate used for encoding in frames per second ( Frame rate = frameRateNum / frameRateDen ). */ uint32_t enableEncodeAsync; /**< [in]: Set this to 1 to enable asynchronous mode and is expected to use events to get picture completion notification. */ uint32_t enablePTD; /**< [in]: Set this to 1 to enable the Picture Type Decision is be taken by the NvEncodeAPI interface. */ uint32_t reportSliceOffsets :1; /**< [in]: Set this to 1 to enable reporting slice offsets in ::_NV_ENC_LOCK_BITSTREAM. NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync must be set to 0 to use this feature. Client must set this to 0 if NV_ENC_CONFIG_H264::sliceMode is 1 on Kepler GPUs */ uint32_t enableSubFrameWrite :1; /**< [in]: Set this to 1 to write out available bitstream to memory at subframe intervals. If enableSubFrameWrite = 1, then the hardware encoder returns data as soon as a slice (H264/HEVC) or tile (AV1) has completed encoding. This results in better encoding latency, but the downside is that the application has to keep polling via a call to nvEncLockBitstream API continuously to see if any encoded slice/tile data is available. Use this mode if you feel that the marginal reduction in latency from sub-frame encoding is worth the increase in complexity due to CPU-based polling. */ uint32_t enableExternalMEHints :1; /**< [in]: Set to 1 to enable external ME hints for the current frame. For NV_ENC_INITIALIZE_PARAMS::enablePTD=1 with B frames, programming L1 hints is optional for B frames since Client doesn't know internal GOP structure. NV_ENC_PIC_PARAMS::meHintRefPicDist should preferably be set with enablePTD=1. */ uint32_t enableMEOnlyMode :1; /**< [in]: Set to 1 to enable ME Only Mode .*/ uint32_t enableWeightedPrediction :1; /**< [in]: Set this to 1 to enable weighted prediction. Not supported if encode session is configured for B-Frames (i.e. NV_ENC_CONFIG::frameIntervalP > 1 or preset >=P3 when tuningInfo = ::NV_ENC_TUNING_INFO_HIGH_QUALITY or tuningInfo = ::NV_ENC_TUNING_INFO_LOSSLESS. This is because preset >=p3 internally enables B frames when tuningInfo = ::NV_ENC_TUNING_INFO_HIGH_QUALITY or ::NV_ENC_TUNING_INFO_LOSSLESS). */ uint32_t enableOutputInVidmem :1; /**< [in]: Set this to 1 to enable output of NVENC in video memory buffer created by application. This feature is not supported for HEVC ME only mode. */ uint32_t reservedBitFields :26; /**< [in]: Reserved bitfields and must be set to 0 */ uint32_t privDataSize; /**< [in]: Reserved private data buffer size and must be set to 0 */ void* privData; /**< [in]: Reserved private data buffer and must be set to NULL */ NV_ENC_CONFIG* encodeConfig; /**< [in]: Specifies the advanced codec specific structure. If client has sent a valid codec config structure, it will override parameters set by the NV_ENC_INITIALIZE_PARAMS::presetGUID parameter. If set to NULL the NvEncodeAPI interface will use the NV_ENC_INITIALIZE_PARAMS::presetGUID to set the codec specific parameters. Client can also optionally query the NvEncodeAPI interface to get codec specific parameters for a presetGUID using ::NvEncGetEncodePresetConfig() API. It can then modify (if required) some of the codec config parameters and send down a custom config structure as part of ::_NV_ENC_INITIALIZE_PARAMS. Even in this case client is recommended to pass the same preset guid it has used in ::NvEncGetEncodePresetConfig() API to query the config structure; as NV_ENC_INITIALIZE_PARAMS::presetGUID. This will not override the custom config structure but will be used to determine other Encoder HW specific parameters not exposed in the API. */ uint32_t maxEncodeWidth; /**< [in]: Maximum encode width to be used for current Encode session. Client should allocate output buffers according to this dimension for dynamic resolution change. If set to 0, Encoder will not allow dynamic resolution change. */ uint32_t maxEncodeHeight; /**< [in]: Maximum encode height to be allowed for current Encode session. Client should allocate output buffers according to this dimension for dynamic resolution change. If set to 0, Encode will not allow dynamic resolution change. */ NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE maxMEHintCountsPerBlock[2]; /**< [in]: If Client wants to pass external motion vectors in NV_ENC_PIC_PARAMS::meExternalHints buffer it must specify the maximum number of hint candidates per block per direction for the encode session. The NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[0] is for L0 predictors and NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[1] is for L1 predictors. This client must also set NV_ENC_INITIALIZE_PARAMS::enableExternalMEHints to 1. */ NV_ENC_TUNING_INFO tuningInfo; /**< [in]: Tuning Info of NVENC encoding(TuningInfo is not applicable to H264 and HEVC meonly mode). */ NV_ENC_BUFFER_FORMAT bufferFormat; /**< [in]: Input buffer format. Used only when DX12 interface type is used */ uint32_t reserved [287]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_INITIALIZE_PARAMS; /** macro for constructing the version field of ::_NV_ENC_INITIALIZE_PARAMS */ #define NV_ENC_INITIALIZE_PARAMS_VER (NVENCAPI_STRUCT_VERSION(5) | ( 1u<<31 )) /** * \struct _NV_ENC_RECONFIGURE_PARAMS * Encode Session Reconfigured parameters. */ typedef struct _NV_ENC_RECONFIGURE_PARAMS { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_RECONFIGURE_PARAMS_VER. */ NV_ENC_INITIALIZE_PARAMS reInitEncodeParams; /**< [in]: Encoder session re-initialization parameters. If reInitEncodeParams.encodeConfig is NULL and reInitEncodeParams.presetGUID is the same as the preset GUID specified on the call to NvEncInitializeEncoder(), EncodeAPI will continue to use the existing encode configuration. If reInitEncodeParams.encodeConfig is NULL and reInitEncodeParams.presetGUID is different from the preset GUID specified on the call to NvEncInitializeEncoder(), EncodeAPI will try to use the default configuration for the preset specified by reInitEncodeParams.presetGUID. In this case, reconfiguration may fail if the new configuration is incompatible with the existing configuration (e.g. the new configuration results in a change in the GOP structure). */ uint32_t resetEncoder :1; /**< [in]: This resets the rate control states and other internal encoder states. This should be used only with an IDR frame. If NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1, encoder will force the frame type to IDR */ uint32_t forceIDR :1; /**< [in]: Encode the current picture as an IDR picture. This flag is only valid when Picture type decision is taken by the Encoder [_NV_ENC_INITIALIZE_PARAMS::enablePTD == 1]. */ uint32_t reserved :30; }NV_ENC_RECONFIGURE_PARAMS; /** macro for constructing the version field of ::_NV_ENC_RECONFIGURE_PARAMS */ #define NV_ENC_RECONFIGURE_PARAMS_VER (NVENCAPI_STRUCT_VERSION(1) | ( 1u<<31 )) /** * \struct _NV_ENC_PRESET_CONFIG * Encoder preset config */ typedef struct _NV_ENC_PRESET_CONFIG { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_PRESET_CONFIG_VER. */ NV_ENC_CONFIG presetCfg; /**< [out]: preset config returned by the Nvidia Video Encoder interface. */ uint32_t reserved1[255]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ }NV_ENC_PRESET_CONFIG; /** macro for constructing the version field of ::_NV_ENC_PRESET_CONFIG */ #define NV_ENC_PRESET_CONFIG_VER (NVENCAPI_STRUCT_VERSION(4) | ( 1u<<31 )) /** * \struct _NV_ENC_PIC_PARAMS_MVC * MVC-specific parameters to be sent on a per-frame basis. */ typedef struct _NV_ENC_PIC_PARAMS_MVC { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_PIC_PARAMS_MVC_VER. */ uint32_t viewID; /**< [in]: Specifies the view ID associated with the current input view. */ uint32_t temporalID; /**< [in]: Specifies the temporal ID associated with the current input view. */ uint32_t priorityID; /**< [in]: Specifies the priority ID associated with the current input view. Reserved and ignored by the NvEncodeAPI interface. */ uint32_t reserved1[12]; /**< [in]: Reserved and must be set to 0. */ void* reserved2[8]; /**< [in]: Reserved and must be set to NULL. */ }NV_ENC_PIC_PARAMS_MVC; /** macro for constructing the version field of ::_NV_ENC_PIC_PARAMS_MVC */ #define NV_ENC_PIC_PARAMS_MVC_VER NVENCAPI_STRUCT_VERSION(1) /** * \union _NV_ENC_PIC_PARAMS_H264_EXT * H264 extension picture parameters */ typedef union _NV_ENC_PIC_PARAMS_H264_EXT { NV_ENC_PIC_PARAMS_MVC mvcPicParams; /**< [in]: Specifies the MVC picture parameters. */ uint32_t reserved1[32]; /**< [in]: Reserved and must be set to 0. */ }NV_ENC_PIC_PARAMS_H264_EXT; /** * \struct _NV_ENC_SEI_PAYLOAD * User SEI message */ typedef struct _NV_ENC_SEI_PAYLOAD { uint32_t payloadSize; /**< [in] SEI payload size in bytes. SEI payload must be byte aligned, as described in Annex D */ uint32_t payloadType; /**< [in] SEI payload types and syntax can be found in Annex D of the H.264 Specification. */ uint8_t *payload; /**< [in] pointer to user data */ } NV_ENC_SEI_PAYLOAD; #define NV_ENC_H264_SEI_PAYLOAD NV_ENC_SEI_PAYLOAD /** * \struct _NV_ENC_PIC_PARAMS_H264 * H264 specific enc pic params. sent on a per frame basis. */ typedef struct _NV_ENC_PIC_PARAMS_H264 { uint32_t displayPOCSyntax; /**< [in]: Specifies the display POC syntax This is required to be set if client is handling the picture type decision. */ uint32_t reserved3; /**< [in]: Reserved and must be set to 0 */ uint32_t refPicFlag; /**< [in]: Set to 1 for a reference picture. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t colourPlaneId; /**< [in]: Specifies the colour plane ID associated with the current input. */ uint32_t forceIntraRefreshWithFrameCnt; /**< [in]: Forces an intra refresh with duration equal to intraRefreshFrameCnt. When outputRecoveryPointSEI is set this is value is used for recovery_frame_cnt in recovery point SEI message forceIntraRefreshWithFrameCnt cannot be used if B frames are used in the GOP structure specified */ uint32_t constrainedFrame :1; /**< [in]: Set to 1 if client wants to encode this frame with each slice completely independent of other slices in the frame. NV_ENC_INITIALIZE_PARAMS::enableConstrainedEncoding should be set to 1 */ uint32_t sliceModeDataUpdate :1; /**< [in]: Set to 1 if client wants to change the sliceModeData field to specify new sliceSize Parameter When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting */ uint32_t ltrMarkFrame :1; /**< [in]: Set to 1 if client wants to mark this frame as LTR */ uint32_t ltrUseFrames :1; /**< [in]: Set to 1 if client allows encoding this frame using the LTR frames specified in ltrFrameBitmap */ uint32_t reservedBitFields :28; /**< [in]: Reserved bit fields and must be set to 0 */ uint8_t* sliceTypeData; /**< [in]: Deprecated. */ uint32_t sliceTypeArrayCnt; /**< [in]: Deprecated. */ uint32_t seiPayloadArrayCnt; /**< [in]: Specifies the number of elements allocated in seiPayloadArray array. */ NV_ENC_SEI_PAYLOAD* seiPayloadArray; /**< [in]: Array of SEI payloads which will be inserted for this frame. */ uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices sliceMode = 0 MB based slices, sliceMode = 1 Byte based slices, sliceMode = 2 MB row based slices, sliceMode = 3, numSlices in Picture When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: sliceMode = 0, sliceModeData specifies # of MBs in each slice (except last slice) sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) sliceMode = 2, sliceModeData specifies # of MB rows in each slice (except last slice) sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ uint32_t ltrMarkFrameIdx; /**< [in]: Specifies the long term referenceframe index to use for marking this frame as LTR.*/ uint32_t ltrUseFrameBitmap; /**< [in]: Specifies the associated bitmap of LTR frame indices to use when encoding this frame. */ uint32_t ltrUsageMode; /**< [in]: Not supported. Reserved for future use and must be set to 0. */ uint32_t forceIntraSliceCount; /**< [in]: Specifies the number of slices to be forced to Intra in the current picture. This option along with forceIntraSliceIdx[] array needs to be used with sliceMode = 3 only */ uint32_t *forceIntraSliceIdx; /**< [in]: Slice indices to be forced to intra in the current picture. Each slice index should be <= num_slices_in_picture -1. Index starts from 0 for first slice. The number of entries in this array should be equal to forceIntraSliceCount */ NV_ENC_PIC_PARAMS_H264_EXT h264ExtPicParams; /**< [in]: Specifies the H264 extension config parameters using this config. */ NV_ENC_TIME_CODE timeCode; /**< [in]: Specifies the clock timestamp sets used in picture timing SEI. Applicable only when NV_ENC_CONFIG_H264::enableTimeCode is set to 1. */ uint32_t reserved [203]; /**< [in]: Reserved and must be set to 0. */ void* reserved2[61]; /**< [in]: Reserved and must be set to NULL. */ } NV_ENC_PIC_PARAMS_H264; /** * \struct _NV_ENC_PIC_PARAMS_HEVC * HEVC specific enc pic params. sent on a per frame basis. */ typedef struct _NV_ENC_PIC_PARAMS_HEVC { uint32_t displayPOCSyntax; /**< [in]: Specifies the display POC syntax This is required to be set if client is handling the picture type decision. */ uint32_t refPicFlag; /**< [in]: Set to 1 for a reference picture. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t temporalId; /**< [in]: Specifies the temporal id of the picture */ uint32_t forceIntraRefreshWithFrameCnt; /**< [in]: Forces an intra refresh with duration equal to intraRefreshFrameCnt. When outputRecoveryPointSEI is set this is value is used for recovery_frame_cnt in recovery point SEI message forceIntraRefreshWithFrameCnt cannot be used if B frames are used in the GOP structure specified */ uint32_t constrainedFrame :1; /**< [in]: Set to 1 if client wants to encode this frame with each slice completely independent of other slices in the frame. NV_ENC_INITIALIZE_PARAMS::enableConstrainedEncoding should be set to 1 */ uint32_t sliceModeDataUpdate :1; /**< [in]: Set to 1 if client wants to change the sliceModeData field to specify new sliceSize Parameter When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting */ uint32_t ltrMarkFrame :1; /**< [in]: Set to 1 if client wants to mark this frame as LTR */ uint32_t ltrUseFrames :1; /**< [in]: Set to 1 if client allows encoding this frame using the LTR frames specified in ltrFrameBitmap */ uint32_t reservedBitFields :28; /**< [in]: Reserved bit fields and must be set to 0 */ uint8_t* sliceTypeData; /**< [in]: Array which specifies the slice type used to force intra slice for a particular slice. Currently supported only for NV_ENC_CONFIG_H264::sliceMode == 3. Client should allocate array of size sliceModeData where sliceModeData is specified in field of ::_NV_ENC_CONFIG_H264 Array element with index n corresponds to nth slice. To force a particular slice to intra client should set corresponding array element to NV_ENC_SLICE_TYPE_I all other array elements should be set to NV_ENC_SLICE_TYPE_DEFAULT */ uint32_t sliceTypeArrayCnt; /**< [in]: Client should set this to the number of elements allocated in sliceTypeData array. If sliceTypeData is NULL then this should be set to 0 */ uint32_t sliceMode; /**< [in]: This parameter in conjunction with sliceModeData specifies the way in which the picture is divided into slices sliceMode = 0 CTU based slices, sliceMode = 1 Byte based slices, sliceMode = 2 CTU row based slices, sliceMode = 3, numSlices in Picture When forceIntraRefreshWithFrameCnt is set it will have priority over sliceMode setting When sliceMode == 0 and sliceModeData == 0 whole picture will be coded with one slice */ uint32_t sliceModeData; /**< [in]: Specifies the parameter needed for sliceMode. For: sliceMode = 0, sliceModeData specifies # of CTUs in each slice (except last slice) sliceMode = 1, sliceModeData specifies maximum # of bytes in each slice (except last slice) sliceMode = 2, sliceModeData specifies # of CTU rows in each slice (except last slice) sliceMode = 3, sliceModeData specifies number of slices in the picture. Driver will divide picture into slices optimally */ uint32_t ltrMarkFrameIdx; /**< [in]: Specifies the long term reference frame index to use for marking this frame as LTR.*/ uint32_t ltrUseFrameBitmap; /**< [in]: Specifies the associated bitmap of LTR frame indices to use when encoding this frame. */ uint32_t ltrUsageMode; /**< [in]: Not supported. Reserved for future use and must be set to 0. */ uint32_t seiPayloadArrayCnt; /**< [in]: Specifies the number of elements allocated in seiPayloadArray array. */ uint32_t reserved; /**< [in]: Reserved and must be set to 0. */ NV_ENC_SEI_PAYLOAD* seiPayloadArray; /**< [in]: Array of SEI payloads which will be inserted for this frame. */ NV_ENC_TIME_CODE timeCode; /**< [in]: Specifies the clock timestamp sets used in time code SEI. Applicable only when NV_ENC_CONFIG_HEVC::enableTimeCodeSEI is set to 1. */ uint32_t reserved2 [237]; /**< [in]: Reserved and must be set to 0. */ void* reserved3[61]; /**< [in]: Reserved and must be set to NULL. */ } NV_ENC_PIC_PARAMS_HEVC; #define NV_ENC_AV1_OBU_PAYLOAD NV_ENC_SEI_PAYLOAD /** * \struct _NV_ENC_PIC_PARAMS_AV1 * AV1 specific enc pic params. sent on a per frame basis. */ typedef struct _NV_ENC_PIC_PARAMS_AV1 { uint32_t displayPOCSyntax; /**< [in]: Specifies the display POC syntax This is required to be set if client is handling the picture type decision. */ uint32_t refPicFlag; /**< [in]: Set to 1 for a reference picture. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t temporalId; /**< [in]: Specifies the temporal id of the picture */ uint32_t forceIntraRefreshWithFrameCnt; /**< [in]: Forces an intra refresh with duration equal to intraRefreshFrameCnt. forceIntraRefreshWithFrameCnt cannot be used if B frames are used in the GOP structure specified */ uint32_t goldenFrameFlag : 1; /**< [in]: Encode frame as Golden Frame. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t arfFrameFlag : 1; /**< [in]: Encode frame as Alternate Reference Frame. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t arf2FrameFlag : 1; /**< [in]: Encode frame as Alternate Reference 2 Frame. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t bwdFrameFlag : 1; /**< [in]: Encode frame as Backward Reference Frame. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t overlayFrameFlag : 1; /**< [in]: Encode frame as overlay frame. A previously encoded frame with the same displayPOCSyntax value should be present in reference frame buffer. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t showExistingFrameFlag : 1; /**< [in]: When ovelayFrameFlag is set to 1, this flag controls the value of the show_existing_frame syntax element associated with the overlay frame. This flag is added to the interface as a placeholder. Its value is ignored for now and always assumed to be set to 1. This is ignored if NV_ENC_INITIALIZE_PARAMS::enablePTD is set to 1. */ uint32_t errorResilientModeFlag : 1; /**< [in]: encode frame independently from previously encoded frames */ uint32_t tileConfigUpdate : 1; /**< [in]: Set to 1 if client wants to overwrite the default tile configuration with the tile parameters specified below When forceIntraRefreshWithFrameCnt is set it will have priority over tileConfigUpdate setting */ uint32_t enableCustomTileConfig : 1; /**< [in]: Set 1 to enable custom tile configuration: numTileColumns and numTileRows must have non zero values and tileWidths and tileHeights must point to a valid address */ uint32_t filmGrainParamsUpdate : 1; /**< [in]: Set to 1 if client wants to update previous film grain parameters: filmGrainParams must point to a valid address and encoder must have been configured with film grain enabled */ uint32_t reservedBitFields : 22; /**< [in]: Reserved bitfields and must be set to 0 */ uint32_t numTileColumns; /**< [in]: This parameter in conjunction with the flag enableCustomTileConfig and the array tileWidths[] specifies the way in which the picture is divided into tile columns. When enableCustomTileConfig == 0, the picture will be uniformly divided into numTileColumns tile columns. If numTileColumns is not a power of 2, it will be rounded down to the next power of 2 value. If numTileColumns == 0, the picture will be coded with the smallest number of vertical tiles as allowed by standard. When enableCustomTileConfig == 1, numTileColumns must be > 0 and <= NV_MAX_TILE_COLS_AV1 and tileWidths must point to a valid array of numTileColumns entries. Entry i specifies the width in 64x64 CTU unit of tile colum i. The sum of all the entries should be equal to the picture width in 64x64 CTU units. */ uint32_t numTileRows; /**< [in]: This parameter in conjunction with the flag enableCustomTileConfig and the array tileHeights[] specifies the way in which the picture is divided into tiles rows When enableCustomTileConfig == 0, the picture will be uniformly divided into numTileRows tile rows. If numTileRows is not a power of 2, it will be rounded down to the next power of 2 value. If numTileRows == 0, the picture will be coded with the smallest number of horizontal tiles as allowed by standard. When enableCustomTileConfig == 1, numTileRows must be > 0 and <= NV_MAX_TILE_ROWS_AV1 and tileHeights must point to a valid array of numTileRows entries. Entry i specifies the height in 64x64 CTU unit of tile row i. The sum of all the entries should be equal to the picture hieght in 64x64 CTU units. */ uint32_t *tileWidths; /**< [in]: If enableCustomTileConfig == 1, tileWidths[i] specifies the width of tile column i in 64x64 CTU unit, with 0 <= i <= numTileColumns -1. */ uint32_t *tileHeights; /**< [in]: If enableCustomTileConfig == 1, tileHeights[i] specifies the height of tile row i in 64x64 CTU unit, with 0 <= i <= numTileRows -1. */ uint32_t obuPayloadArrayCnt; /**< [in]: Specifies the number of elements allocated in obuPayloadArray array. */ uint32_t reserved; /**< [in]: Reserved and must be set to 0. */ NV_ENC_AV1_OBU_PAYLOAD* obuPayloadArray; /**< [in]: Array of OBU payloads which will be inserted for this frame. */ NV_ENC_FILM_GRAIN_PARAMS_AV1 *filmGrainParams; /**< [in]: If filmGrainParamsUpdate == 1, filmGrainParams must point to a valid NV_ENC_FILM_GRAIN_PARAMS_AV1 structure */ uint32_t reserved2[247]; /**< [in]: Reserved and must be set to 0. */ void* reserved3[61]; /**< [in]: Reserved and must be set to NULL. */ } NV_ENC_PIC_PARAMS_AV1; /** * Codec specific per-picture encoding parameters. */ typedef union _NV_ENC_CODEC_PIC_PARAMS { NV_ENC_PIC_PARAMS_H264 h264PicParams; /**< [in]: H264 encode picture params. */ NV_ENC_PIC_PARAMS_HEVC hevcPicParams; /**< [in]: HEVC encode picture params. */ NV_ENC_PIC_PARAMS_AV1 av1PicParams; /**< [in]: AV1 encode picture params. */ uint32_t reserved[256]; /**< [in]: Reserved and must be set to 0. */ } NV_ENC_CODEC_PIC_PARAMS; /** * \struct _NV_ENC_PIC_PARAMS * Encoding parameters that need to be sent on a per frame basis. */ typedef struct _NV_ENC_PIC_PARAMS { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_PIC_PARAMS_VER. */ uint32_t inputWidth; /**< [in]: Specifies the input frame width */ uint32_t inputHeight; /**< [in]: Specifies the input frame height */ uint32_t inputPitch; /**< [in]: Specifies the input buffer pitch. If pitch value is not known, set this to inputWidth. */ uint32_t encodePicFlags; /**< [in]: Specifies bit-wise OR of encode picture flags. See ::NV_ENC_PIC_FLAGS enum. */ uint32_t frameIdx; /**< [in]: Specifies the frame index associated with the input frame [optional]. */ uint64_t inputTimeStamp; /**< [in]: Specifies opaque data which is associated with the encoded frame, but not actually encoded in the output bitstream. This opaque data can be used later to uniquely refer to the corresponding encoded frame. For example, it can be used for identifying the frame to be invalidated in the reference picture buffer, if lost at the client. */ uint64_t inputDuration; /**< [in]: Specifies duration of the input picture */ NV_ENC_INPUT_PTR inputBuffer; /**< [in]: Specifies the input buffer pointer. Client must use a pointer obtained from ::NvEncCreateInputBuffer() or ::NvEncMapInputResource() APIs.*/ NV_ENC_OUTPUT_PTR outputBitstream; /**< [in]: Specifies the output buffer pointer. If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 0, specifies the pointer to output buffer. Client should use a pointer obtained from ::NvEncCreateBitstreamBuffer() API. If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 1, client should allocate buffer in video memory for NV_ENC_ENCODE_OUT_PARAMS struct and encoded bitstream data. Client should use a pointer obtained from ::NvEncMapInputResource() API, when mapping this output buffer and assign it to NV_ENC_PIC_PARAMS::outputBitstream. First 256 bytes of this buffer should be interpreted as NV_ENC_ENCODE_OUT_PARAMS struct followed by encoded bitstream data. Recommended size for output buffer is sum of size of NV_ENC_ENCODE_OUT_PARAMS struct and twice the input frame size for lower resolution eg. CIF and 1.5 times the input frame size for higher resolutions. If encoded bitstream size is greater than the allocated buffer size for encoded bitstream, then the output buffer will have encoded bitstream data equal to buffer size. All CUDA operations on this buffer must use the default stream. */ void* completionEvent; /**< [in]: Specifies an event to be signaled on completion of encoding of this Frame [only if operating in Asynchronous mode]. Each output buffer should be associated with a distinct event pointer. */ NV_ENC_BUFFER_FORMAT bufferFmt; /**< [in]: Specifies the input buffer format. */ NV_ENC_PIC_STRUCT pictureStruct; /**< [in]: Specifies structure of the input picture. */ NV_ENC_PIC_TYPE pictureType; /**< [in]: Specifies input picture type. Client required to be set explicitly by the client if the client has not set NV_ENC_INITALIZE_PARAMS::enablePTD to 1 while calling NvInitializeEncoder. */ NV_ENC_CODEC_PIC_PARAMS codecPicParams; /**< [in]: Specifies the codec specific per-picture encoding parameters. */ NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE meHintCountsPerBlock[2]; /**< [in]: For H264 and Hevc, specifies the number of hint candidates per block per direction for the current frame. meHintCountsPerBlock[0] is for L0 predictors and meHintCountsPerBlock[1] is for L1 predictors. The candidate count in NV_ENC_PIC_PARAMS::meHintCountsPerBlock[lx] must never exceed NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[lx] provided during encoder initialization. */ NVENC_EXTERNAL_ME_HINT *meExternalHints; /**< [in]: For H264 and Hevc, Specifies the pointer to ME external hints for the current frame. The size of ME hint buffer should be equal to number of macroblocks * the total number of candidates per macroblock. The total number of candidates per MB per direction = 1*meHintCountsPerBlock[Lx].numCandsPerBlk16x16 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk16x8 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk8x8 + 4*meHintCountsPerBlock[Lx].numCandsPerBlk8x8. For frames using bidirectional ME , the total number of candidates for single macroblock is sum of total number of candidates per MB for each direction (L0 and L1) */ uint32_t reserved1[6]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[2]; /**< [in]: Reserved and must be set to NULL */ int8_t *qpDeltaMap; /**< [in]: Specifies the pointer to signed byte array containing value per MB for H264, per CTB for HEVC and per SB for AV1 in raster scan order for the current picture, which will be interpreted depending on NV_ENC_RC_PARAMS::qpMapMode. If NV_ENC_RC_PARAMS::qpMapMode is NV_ENC_QP_MAP_DELTA, qpDeltaMap specifies QP modifier per MB for H264, per CTB for HEVC and per SB for AV1. This QP modifier will be applied on top of the QP chosen by rate control. If NV_ENC_RC_PARAMS::qpMapMode is NV_ENC_QP_MAP_EMPHASIS, qpDeltaMap specifies Emphasis Level Map per MB for H264. This level value along with QP chosen by rate control is used to compute the QP modifier, which in turn is applied on top of QP chosen by rate control. If NV_ENC_RC_PARAMS::qpMapMode is NV_ENC_QP_MAP_DISABLED, value in qpDeltaMap will be ignored.*/ uint32_t qpDeltaMapSize; /**< [in]: Specifies the size in bytes of qpDeltaMap surface allocated by client and pointed to by NV_ENC_PIC_PARAMS::qpDeltaMap. Surface (array) should be picWidthInMbs * picHeightInMbs for H264, picWidthInCtbs * picHeightInCtbs for HEVC and picWidthInSbs * picHeightInSbs for AV1 */ uint32_t reservedBitFields; /**< [in]: Reserved bitfields and must be set to 0 */ uint16_t meHintRefPicDist[2]; /**< [in]: Specifies temporal distance for reference picture (NVENC_EXTERNAL_ME_HINT::refidx = 0) used during external ME with NV_ENC_INITALIZE_PARAMS::enablePTD = 1 . meHintRefPicDist[0] is for L0 hints and meHintRefPicDist[1] is for L1 hints. If not set, will internally infer distance of 1. Ignored for NV_ENC_INITALIZE_PARAMS::enablePTD = 0 */ NV_ENC_INPUT_PTR alphaBuffer; /**< [in]: Specifies the input alpha buffer pointer. Client must use a pointer obtained from ::NvEncCreateInputBuffer() or ::NvEncMapInputResource() APIs. Applicable only when encoding hevc with alpha layer is enabled. */ NVENC_EXTERNAL_ME_SB_HINT *meExternalSbHints; /**< [in]: For AV1,Specifies the pointer to ME external SB hints for the current frame. The size of ME hint buffer should be equal to meSbHintsCount. */ uint32_t meSbHintsCount; /**< [in]: For AV1, specifies the total number of external ME SB hint candidates for the frame NV_ENC_PIC_PARAMS::meSbHintsCount must never exceed the total number of SBs in frame * the max number of candidates per SB provided during encoder initialization. The max number of candidates per SB is maxMeHintCountsPerBlock[0].numCandsPerSb + maxMeHintCountsPerBlock[1].numCandsPerSb */ uint32_t reserved3[285]; /**< [in]: Reserved and must be set to 0 */ void* reserved4[58]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_PIC_PARAMS; /** Macro for constructing the version field of ::_NV_ENC_PIC_PARAMS */ #define NV_ENC_PIC_PARAMS_VER (NVENCAPI_STRUCT_VERSION(6) | ( 1u<<31 )) /** * \struct _NV_ENC_MEONLY_PARAMS * MEOnly parameters that need to be sent on a per motion estimation basis. * NV_ENC_MEONLY_PARAMS::meExternalHints is supported for H264 only. */ typedef struct _NV_ENC_MEONLY_PARAMS { uint32_t version; /**< [in]: Struct version. Must be set to NV_ENC_MEONLY_PARAMS_VER.*/ uint32_t inputWidth; /**< [in]: Specifies the input frame width */ uint32_t inputHeight; /**< [in]: Specifies the input frame height */ NV_ENC_INPUT_PTR inputBuffer; /**< [in]: Specifies the input buffer pointer. Client must use a pointer obtained from NvEncCreateInputBuffer() or NvEncMapInputResource() APIs. */ NV_ENC_INPUT_PTR referenceFrame; /**< [in]: Specifies the reference frame pointer */ NV_ENC_OUTPUT_PTR mvBuffer; /**< [in]: Specifies the output buffer pointer. If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 0, specifies the pointer to motion vector data buffer allocated by NvEncCreateMVBuffer. Client must lock mvBuffer using ::NvEncLockBitstream() API to get the motion vector data. If NV_ENC_INITIALIZE_PARAMS::enableOutputInVidmem is set to 1, client should allocate buffer in video memory for storing the motion vector data. The size of this buffer must be equal to total number of macroblocks multiplied by size of NV_ENC_H264_MV_DATA struct. Client should use a pointer obtained from ::NvEncMapInputResource() API, when mapping this output buffer and assign it to NV_ENC_MEONLY_PARAMS::mvBuffer. All CUDA operations on this buffer must use the default stream. */ NV_ENC_BUFFER_FORMAT bufferFmt; /**< [in]: Specifies the input buffer format. */ void* completionEvent; /**< [in]: Specifies an event to be signaled on completion of motion estimation of this Frame [only if operating in Asynchronous mode]. Each output buffer should be associated with a distinct event pointer. */ uint32_t viewID; /**< [in]: Specifies left or right viewID if NV_ENC_CONFIG_H264_MEONLY::bStereoEnable is set. viewID can be 0,1 if bStereoEnable is set, 0 otherwise. */ NVENC_EXTERNAL_ME_HINT_COUNTS_PER_BLOCKTYPE meHintCountsPerBlock[2]; /**< [in]: Specifies the number of hint candidates per block for the current frame. meHintCountsPerBlock[0] is for L0 predictors. The candidate count in NV_ENC_PIC_PARAMS::meHintCountsPerBlock[lx] must never exceed NV_ENC_INITIALIZE_PARAMS::maxMEHintCountsPerBlock[lx] provided during encoder initialization. */ NVENC_EXTERNAL_ME_HINT *meExternalHints; /**< [in]: Specifies the pointer to ME external hints for the current frame. The size of ME hint buffer should be equal to number of macroblocks * the total number of candidates per macroblock. The total number of candidates per MB per direction = 1*meHintCountsPerBlock[Lx].numCandsPerBlk16x16 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk16x8 + 2*meHintCountsPerBlock[Lx].numCandsPerBlk8x8 + 4*meHintCountsPerBlock[Lx].numCandsPerBlk8x8. For frames using bidirectional ME , the total number of candidates for single macroblock is sum of total number of candidates per MB for each direction (L0 and L1) */ uint32_t reserved1[243]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[59]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_MEONLY_PARAMS; /** NV_ENC_MEONLY_PARAMS struct version*/ #define NV_ENC_MEONLY_PARAMS_VER NVENCAPI_STRUCT_VERSION(3) /** * \struct _NV_ENC_LOCK_BITSTREAM * Bitstream buffer lock parameters. */ typedef struct _NV_ENC_LOCK_BITSTREAM { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_LOCK_BITSTREAM_VER. */ uint32_t doNotWait :1; /**< [in]: If this flag is set, the NvEncodeAPI interface will return buffer pointer even if operation is not completed. If not set, the call will block until operation completes. */ uint32_t ltrFrame :1; /**< [out]: Flag indicating this frame is marked as LTR frame */ uint32_t getRCStats :1; /**< [in]: If this flag is set then lockBitstream call will add additional intra-inter MB count and average MVX, MVY */ uint32_t reservedBitFields :29; /**< [in]: Reserved bit fields and must be set to 0 */ void* outputBitstream; /**< [in]: Pointer to the bitstream buffer being locked. */ uint32_t* sliceOffsets; /**< [in, out]: Array which receives the slice (H264/HEVC) or tile (AV1) offsets. This is not supported if NV_ENC_CONFIG_H264::sliceMode is 1 on Kepler GPUs. Array size must be equal to size of frame in MBs. */ uint32_t frameIdx; /**< [out]: Frame no. for which the bitstream is being retrieved. */ uint32_t hwEncodeStatus; /**< [out]: The NvEncodeAPI interface status for the locked picture. */ uint32_t numSlices; /**< [out]: Number of slices (H264/HEVC) or tiles (AV1) in the encoded picture. Will be reported only if NV_ENC_INITIALIZE_PARAMS::reportSliceOffsets set to 1. */ uint32_t bitstreamSizeInBytes; /**< [out]: Actual number of bytes generated and copied to the memory pointed by bitstreamBufferPtr. When HEVC alpha layer encoding is enabled, this field reports the total encoded size in bytes i.e it is the encoded size of the base plus the alpha layer. For AV1 when enablePTD is set, this field reports the total encoded size in bytes of all the encoded frames packed into the current output surface i.e. show frame plus all preceding no-show frames */ uint64_t outputTimeStamp; /**< [out]: Presentation timestamp associated with the encoded output. */ uint64_t outputDuration; /**< [out]: Presentation duration associates with the encoded output. */ void* bitstreamBufferPtr; /**< [out]: Pointer to the generated output bitstream. For MEOnly mode _NV_ENC_LOCK_BITSTREAM::bitstreamBufferPtr should be typecast to NV_ENC_H264_MV_DATA/NV_ENC_HEVC_MV_DATA pointer respectively for H264/HEVC */ NV_ENC_PIC_TYPE pictureType; /**< [out]: Picture type of the encoded picture. */ NV_ENC_PIC_STRUCT pictureStruct; /**< [out]: Structure of the generated output picture. */ uint32_t frameAvgQP; /**< [out]: Average QP of the frame. */ uint32_t frameSatd; /**< [out]: Total SATD cost for whole frame. */ uint32_t ltrFrameIdx; /**< [out]: Frame index associated with this LTR frame. */ uint32_t ltrFrameBitmap; /**< [out]: Bitmap of LTR frames indices which were used for encoding this frame. Value of 0 if no LTR frames were used. */ uint32_t temporalId; /**< [out]: TemporalId value of the frame when using temporalSVC encoding */ uint32_t reserved[12]; /**< [in]: Reserved and must be set to 0 */ uint32_t intraMBCount; /**< [out]: For H264, Number of Intra MBs in the encoded frame. For HEVC, Number of Intra CTBs in the encoded frame. For AV1, Number of Intra SBs in the encoded show frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ uint32_t interMBCount; /**< [out]: For H264, Number of Inter MBs in the encoded frame, includes skip MBs. For HEVC, Number of Inter CTBs in the encoded frame. For AV1, Number of Inter SBs in the encoded show frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ int32_t averageMVX; /**< [out]: Average Motion Vector in X direction for the encoded frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ int32_t averageMVY; /**< [out]: Average Motion Vector in y direction for the encoded frame. Supported only if _NV_ENC_LOCK_BITSTREAM::getRCStats set to 1. */ uint32_t alphaLayerSizeInBytes; /**< [out]: Number of bytes generated for the alpha layer in the encoded output. Applicable only when HEVC with alpha encoding is enabled. */ uint32_t reserved1[218]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_LOCK_BITSTREAM; /** Macro for constructing the version field of ::_NV_ENC_LOCK_BITSTREAM */ #define NV_ENC_LOCK_BITSTREAM_VER NVENCAPI_STRUCT_VERSION(2) /** * \struct _NV_ENC_LOCK_INPUT_BUFFER * Uncompressed Input Buffer lock parameters. */ typedef struct _NV_ENC_LOCK_INPUT_BUFFER { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_LOCK_INPUT_BUFFER_VER. */ uint32_t doNotWait :1; /**< [in]: Set to 1 to make ::NvEncLockInputBuffer() a unblocking call. If the encoding is not completed, driver will return ::NV_ENC_ERR_ENCODER_BUSY error code. */ uint32_t reservedBitFields :31; /**< [in]: Reserved bitfields and must be set to 0 */ NV_ENC_INPUT_PTR inputBuffer; /**< [in]: Pointer to the input buffer to be locked, client should pass the pointer obtained from ::NvEncCreateInputBuffer() or ::NvEncMapInputResource API. */ void* bufferDataPtr; /**< [out]: Pointed to the locked input buffer data. Client can only access input buffer using the \p bufferDataPtr. */ uint32_t pitch; /**< [out]: Pitch of the locked input buffer. */ uint32_t reserved1[251]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_LOCK_INPUT_BUFFER; /** Macro for constructing the version field of ::_NV_ENC_LOCK_INPUT_BUFFER */ #define NV_ENC_LOCK_INPUT_BUFFER_VER NVENCAPI_STRUCT_VERSION(1) /** * \struct _NV_ENC_MAP_INPUT_RESOURCE * Map an input resource to a Nvidia Encoder Input Buffer */ typedef struct _NV_ENC_MAP_INPUT_RESOURCE { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_MAP_INPUT_RESOURCE_VER. */ uint32_t subResourceIndex; /**< [in]: Deprecated. Do not use. */ void* inputResource; /**< [in]: Deprecated. Do not use. */ NV_ENC_REGISTERED_PTR registeredResource; /**< [in]: The Registered resource handle obtained by calling NvEncRegisterInputResource. */ NV_ENC_INPUT_PTR mappedResource; /**< [out]: Mapped pointer corresponding to the registeredResource. This pointer must be used in NV_ENC_PIC_PARAMS::inputBuffer parameter in ::NvEncEncodePicture() API. */ NV_ENC_BUFFER_FORMAT mappedBufferFmt; /**< [out]: Buffer format of the outputResource. This buffer format must be used in NV_ENC_PIC_PARAMS::bufferFmt if client using the above mapped resource pointer. */ uint32_t reserved1[251]; /**< [in]: Reserved and must be set to 0. */ void* reserved2[63]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_MAP_INPUT_RESOURCE; /** Macro for constructing the version field of ::_NV_ENC_MAP_INPUT_RESOURCE */ #define NV_ENC_MAP_INPUT_RESOURCE_VER NVENCAPI_STRUCT_VERSION(4) /** * \struct _NV_ENC_INPUT_RESOURCE_OPENGL_TEX * NV_ENC_REGISTER_RESOURCE::resourceToRegister must be a pointer to a variable of this type, * when NV_ENC_REGISTER_RESOURCE::resourceType is NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX */ typedef struct _NV_ENC_INPUT_RESOURCE_OPENGL_TEX { uint32_t texture; /**< [in]: The name of the texture to be used. */ uint32_t target; /**< [in]: Accepted values are GL_TEXTURE_RECTANGLE and GL_TEXTURE_2D. */ } NV_ENC_INPUT_RESOURCE_OPENGL_TEX; /** \struct NV_ENC_FENCE_POINT_D3D12 * Fence and fence value for synchronization. */ typedef struct _NV_ENC_FENCE_POINT_D3D12 { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_FENCE_POINT_D3D12_VER. */ uint32_t reserved; /**< [in]: Reserved and must be set to 0. */ void* pFence; /**< [in]: Pointer to ID3D12Fence. This fence object is used for synchronization. */ uint64_t waitValue; /**< [in]: Fence value to reach or exceed before the GPU operation. */ uint64_t signalValue; /**< [in]: Fence value to set the fence to, after the GPU operation. */ uint32_t bWait:1; /**< [in]: Wait on 'waitValue' if bWait is set to 1, before starting GPU operation. */ uint32_t bSignal:1; /**< [in]: Signal on 'signalValue' if bSignal is set to 1, after GPU operation is complete. */ uint32_t reservedBitField:30; /**< [in]: Reserved and must be set to 0. */ uint32_t reserved1[7]; /**< [in]: Reserved and must be set to 0. */ } NV_ENC_FENCE_POINT_D3D12; #define NV_ENC_FENCE_POINT_D3D12_VER NVENCAPI_STRUCT_VERSION(1) /** * \struct _NV_ENC_INPUT_RESOURCE_D3D12 * NV_ENC_PIC_PARAMS::inputBuffer and NV_ENC_PIC_PARAMS::alphaBuffer must be a pointer to a struct of this type, * when D3D12 interface is used */ typedef struct _NV_ENC_INPUT_RESOURCE_D3D12 { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_INPUT_RESOURCE_D3D12_VER. */ uint32_t reserved; /**< [in]: Reserved and must be set to 0. */ NV_ENC_INPUT_PTR pInputBuffer; /**< [in]: Specifies the input surface pointer. Client must use a pointer obtained from NvEncMapInputResource() in NV_ENC_MAP_INPUT_RESOURCE::mappedResource when mapping the input surface. */ NV_ENC_FENCE_POINT_D3D12 inputFencePoint; /**< [in]: Specifies the fence and corresponding fence values to do GPU wait and signal. */ uint32_t reserved1[16]; /**< [in]: Reserved and must be set to 0. */ void* reserved2[16]; /**< [in]: Reserved and must be set to NULL. */ } NV_ENC_INPUT_RESOURCE_D3D12; #define NV_ENC_INPUT_RESOURCE_D3D12_VER NVENCAPI_STRUCT_VERSION(1) /** * \struct _NV_ENC_OUTPUT_RESOURCE_D3D12 * NV_ENC_PIC_PARAMS::outputBitstream and NV_ENC_LOCK_BITSTREAM::outputBitstream must be a pointer to a struct of this type, * when D3D12 interface is used */ typedef struct _NV_ENC_OUTPUT_RESOURCE_D3D12 { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_OUTPUT_RESOURCE_D3D12_VER. */ uint32_t reserved; /**< [in]: Reserved and must be set to 0. */ NV_ENC_INPUT_PTR pOutputBuffer; /**< [in]: Specifies the output buffer pointer. Client must use a pointer obtained from NvEncMapInputResource() in NV_ENC_MAP_INPUT_RESOURCE::mappedResource when mapping output bitstream buffer */ NV_ENC_FENCE_POINT_D3D12 outputFencePoint; /**< [in]: Specifies the fence and corresponding fence values to do GPU wait and signal.*/ uint32_t reserved1[16]; /**< [in]: Reserved and must be set to 0. */ void* reserved2[16]; /**< [in]: Reserved and must be set to NULL. */ } NV_ENC_OUTPUT_RESOURCE_D3D12; #define NV_ENC_OUTPUT_RESOURCE_D3D12_VER NVENCAPI_STRUCT_VERSION(1) /** * \struct _NV_ENC_REGISTER_RESOURCE * Register a resource for future use with the Nvidia Video Encoder Interface. */ typedef struct _NV_ENC_REGISTER_RESOURCE { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_REGISTER_RESOURCE_VER. */ NV_ENC_INPUT_RESOURCE_TYPE resourceType; /**< [in]: Specifies the type of resource to be registered. Supported values are ::NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX, ::NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR, ::NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX */ uint32_t width; /**< [in]: Input frame width. */ uint32_t height; /**< [in]: Input frame height. */ uint32_t pitch; /**< [in]: Input buffer pitch. For ::NV_ENC_INPUT_RESOURCE_TYPE_DIRECTX resources, set this to 0. For ::NV_ENC_INPUT_RESOURCE_TYPE_CUDADEVICEPTR resources, set this to the pitch as obtained from cuMemAllocPitch(), or to the width in bytes (if this resource was created by using cuMemAlloc()). This value must be a multiple of 4. For ::NV_ENC_INPUT_RESOURCE_TYPE_CUDAARRAY resources, set this to the width of the allocation in bytes (i.e. CUDA_ARRAY3D_DESCRIPTOR::Width * CUDA_ARRAY3D_DESCRIPTOR::NumChannels). For ::NV_ENC_INPUT_RESOURCE_TYPE_OPENGL_TEX resources, set this to the texture width multiplied by the number of components in the texture format. */ uint32_t subResourceIndex; /**< [in]: Subresource Index of the DirectX resource to be registered. Should be set to 0 for other interfaces. */ void* resourceToRegister; /**< [in]: Handle to the resource that is being registered. */ NV_ENC_REGISTERED_PTR registeredResource; /**< [out]: Registered resource handle. This should be used in future interactions with the Nvidia Video Encoder Interface. */ NV_ENC_BUFFER_FORMAT bufferFormat; /**< [in]: Buffer format of resource to be registered. */ NV_ENC_BUFFER_USAGE bufferUsage; /**< [in]: Usage of resource to be registered. */ NV_ENC_FENCE_POINT_D3D12* pInputFencePoint; /**< [in]: Specifies the input fence and corresponding fence values to do GPU wait and signal. To be used only when NV_ENC_REGISTER_RESOURCE::resourceToRegister represents D3D12 surface and NV_ENC_BUFFER_USAGE::bufferUsage is NV_ENC_INPUT_IMAGE. The fence NV_ENC_FENCE_POINT_D3D12::pFence and NV_ENC_FENCE_POINT_D3D12::waitValue will be used to do GPU wait before starting GPU operation, if NV_ENC_FENCE_POINT_D3D12::bWait is set. The fence NV_ENC_FENCE_POINT_D3D12::pFence and NV_ENC_FENCE_POINT_D3D12::signalValue will be used to do GPU signal when GPU operation finishes, if NV_ENC_FENCE_POINT_D3D12::bSignal is set. */ uint32_t reserved1[247]; /**< [in]: Reserved and must be set to 0. */ void* reserved2[61]; /**< [in]: Reserved and must be set to NULL. */ } NV_ENC_REGISTER_RESOURCE; /** Macro for constructing the version field of ::_NV_ENC_REGISTER_RESOURCE */ #define NV_ENC_REGISTER_RESOURCE_VER NVENCAPI_STRUCT_VERSION(4) /** * \struct _NV_ENC_STAT * Encode Stats structure. */ typedef struct _NV_ENC_STAT { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_STAT_VER. */ uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ NV_ENC_OUTPUT_PTR outputBitStream; /**< [out]: Specifies the pointer to output bitstream. */ uint32_t bitStreamSize; /**< [out]: Size of generated bitstream in bytes. */ uint32_t picType; /**< [out]: Picture type of encoded picture. See ::NV_ENC_PIC_TYPE. */ uint32_t lastValidByteOffset; /**< [out]: Offset of last valid bytes of completed bitstream */ uint32_t sliceOffsets[16]; /**< [out]: Offsets of each slice */ uint32_t picIdx; /**< [out]: Picture number */ uint32_t frameAvgQP; /**< [out]: Average QP of the frame. */ uint32_t ltrFrame :1; /**< [out]: Flag indicating this frame is marked as LTR frame */ uint32_t reservedBitFields :31; /**< [in]: Reserved bit fields and must be set to 0 */ uint32_t ltrFrameIdx; /**< [out]: Frame index associated with this LTR frame. */ uint32_t intraMBCount; /**< [out]: For H264, Number of Intra MBs in the encoded frame. For HEVC, Number of Intra CTBs in the encoded frame. */ uint32_t interMBCount; /**< [out]: For H264, Number of Inter MBs in the encoded frame, includes skip MBs. For HEVC, Number of Inter CTBs in the encoded frame. */ int32_t averageMVX; /**< [out]: Average Motion Vector in X direction for the encoded frame. */ int32_t averageMVY; /**< [out]: Average Motion Vector in y direction for the encoded frame. */ uint32_t reserved1[226]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_STAT; /** Macro for constructing the version field of ::_NV_ENC_STAT */ #define NV_ENC_STAT_VER NVENCAPI_STRUCT_VERSION(1) /** * \struct _NV_ENC_SEQUENCE_PARAM_PAYLOAD * Sequence and picture paramaters payload. */ typedef struct _NV_ENC_SEQUENCE_PARAM_PAYLOAD { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_INITIALIZE_PARAMS_VER. */ uint32_t inBufferSize; /**< [in]: Specifies the size of the spsppsBuffer provided by the client */ uint32_t spsId; /**< [in]: Specifies the SPS id to be used in sequence header. Default value is 0. */ uint32_t ppsId; /**< [in]: Specifies the PPS id to be used in picture header. Default value is 0. */ void* spsppsBuffer; /**< [in]: Specifies bitstream header pointer of size NV_ENC_SEQUENCE_PARAM_PAYLOAD::inBufferSize. It is the client's responsibility to manage this memory. */ uint32_t* outSPSPPSPayloadSize; /**< [out]: Size of the sequence and picture header in bytes. */ uint32_t reserved [250]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_SEQUENCE_PARAM_PAYLOAD; /** Macro for constructing the version field of ::_NV_ENC_SEQUENCE_PARAM_PAYLOAD */ #define NV_ENC_SEQUENCE_PARAM_PAYLOAD_VER NVENCAPI_STRUCT_VERSION(1) /** * Event registration/unregistration parameters. */ typedef struct _NV_ENC_EVENT_PARAMS { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_EVENT_PARAMS_VER. */ uint32_t reserved; /**< [in]: Reserved and must be set to 0 */ void* completionEvent; /**< [in]: Handle to event to be registered/unregistered with the NvEncodeAPI interface. */ uint32_t reserved1[253]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_EVENT_PARAMS; /** Macro for constructing the version field of ::_NV_ENC_EVENT_PARAMS */ #define NV_ENC_EVENT_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) /** * Encoder Session Creation parameters */ typedef struct _NV_ENC_OPEN_ENCODE_SESSIONEX_PARAMS { uint32_t version; /**< [in]: Struct version. Must be set to ::NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER. */ NV_ENC_DEVICE_TYPE deviceType; /**< [in]: Specified the device Type */ void* device; /**< [in]: Pointer to client device. */ void* reserved; /**< [in]: Reserved and must be set to 0. */ uint32_t apiVersion; /**< [in]: API version. Should be set to NVENCAPI_VERSION. */ uint32_t reserved1[253]; /**< [in]: Reserved and must be set to 0 */ void* reserved2[64]; /**< [in]: Reserved and must be set to NULL */ } NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS; /** Macro for constructing the version field of ::_NV_ENC_OPEN_ENCODE_SESSIONEX_PARAMS */ #define NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS_VER NVENCAPI_STRUCT_VERSION(1) /** @} */ /* END ENCODER_STRUCTURE */ /** * \addtogroup ENCODE_FUNC NvEncodeAPI Functions * @{ */ // NvEncOpenEncodeSession /** * \brief Opens an encoding session. * * Deprecated. * * \return * ::NV_ENC_ERR_INVALID_CALL\n * */ NVENCSTATUS NVENCAPI NvEncOpenEncodeSession (void* device, uint32_t deviceType, void** encoder); // NvEncGetEncodeGuidCount /** * \brief Retrieves the number of supported encode GUIDs. * * The function returns the number of codec GUIDs supported by the NvEncodeAPI * interface. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [out] encodeGUIDCount * Number of supported encode GUIDs. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodeGUIDCount (void* encoder, uint32_t* encodeGUIDCount); // NvEncGetEncodeGUIDs /** * \brief Retrieves an array of supported encoder codec GUIDs. * * The function returns an array of codec GUIDs supported by the NvEncodeAPI interface. * The client must allocate an array where the NvEncodeAPI interface can * fill the supported GUIDs and pass the pointer in \p *GUIDs parameter. * The size of the array can be determined by using ::NvEncGetEncodeGUIDCount() API. * The Nvidia Encoding interface returns the number of codec GUIDs it has actually * filled in the GUID array in the \p GUIDCount parameter. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] guidArraySize * Number of GUIDs to retrieved. Should be set to the number retrieved using * ::NvEncGetEncodeGUIDCount. * \param [out] GUIDs * Array of supported Encode GUIDs. * \param [out] GUIDCount * Number of supported Encode GUIDs. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodeGUIDs (void* encoder, GUID* GUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); // NvEncGetEncodeProfileGuidCount /** * \brief Retrieves the number of supported profile GUIDs. * * The function returns the number of profile GUIDs supported for a given codec. * The client must first enumerate the codec GUIDs supported by the NvEncodeAPI * interface. After determining the codec GUID, it can query the NvEncodeAPI * interface to determine the number of profile GUIDs supported for a particular * codec GUID. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * The codec GUID for which the profile GUIDs are being enumerated. * \param [out] encodeProfileGUIDCount * Number of encode profiles supported for the given encodeGUID. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodeProfileGUIDCount (void* encoder, GUID encodeGUID, uint32_t* encodeProfileGUIDCount); // NvEncGetEncodeProfileGUIDs /** * \brief Retrieves an array of supported encode profile GUIDs. * * The function returns an array of supported profile GUIDs for a particular * codec GUID. The client must allocate an array where the NvEncodeAPI interface * can populate the profile GUIDs. The client can determine the array size using * ::NvEncGetEncodeProfileGUIDCount() API. The client must also validiate that the * NvEncodeAPI interface supports the GUID the client wants to pass as \p encodeGUID * parameter. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * The encode GUID whose profile GUIDs are being enumerated. * \param [in] guidArraySize * Number of GUIDs to be retrieved. Should be set to the number retrieved using * ::NvEncGetEncodeProfileGUIDCount. * \param [out] profileGUIDs * Array of supported Encode Profile GUIDs * \param [out] GUIDCount * Number of valid encode profile GUIDs in \p profileGUIDs array. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodeProfileGUIDs (void* encoder, GUID encodeGUID, GUID* profileGUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); // NvEncGetInputFormatCount /** * \brief Retrieve the number of supported Input formats. * * The function returns the number of supported input formats. The client must * query the NvEncodeAPI interface to determine the supported input formats * before creating the input surfaces. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * Encode GUID, corresponding to which the number of supported input formats * is to be retrieved. * \param [out] inputFmtCount * Number of input formats supported for specified Encode GUID. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n */ NVENCSTATUS NVENCAPI NvEncGetInputFormatCount (void* encoder, GUID encodeGUID, uint32_t* inputFmtCount); // NvEncGetInputFormats /** * \brief Retrieves an array of supported Input formats * * Returns an array of supported input formats The client must use the input * format to create input surface using ::NvEncCreateInputBuffer() API. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * Encode GUID, corresponding to which the number of supported input formats * is to be retrieved. *\param [in] inputFmtArraySize * Size input format count array passed in \p inputFmts. *\param [out] inputFmts * Array of input formats supported for this Encode GUID. *\param [out] inputFmtCount * The number of valid input format types returned by the NvEncodeAPI * interface in \p inputFmts array. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetInputFormats (void* encoder, GUID encodeGUID, NV_ENC_BUFFER_FORMAT* inputFmts, uint32_t inputFmtArraySize, uint32_t* inputFmtCount); // NvEncGetEncodeCaps /** * \brief Retrieves the capability value for a specified encoder attribute. * * The function returns the capability value for a given encoder attribute. The * client must validate the encodeGUID using ::NvEncGetEncodeGUIDs() API before * calling this function. The encoder attribute being queried are enumerated in * ::NV_ENC_CAPS_PARAM enum. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * Encode GUID, corresponding to which the capability attribute is to be retrieved. * \param [in] capsParam * Used to specify attribute being queried. Refer ::NV_ENC_CAPS_PARAM for more * details. * \param [out] capsVal * The value corresponding to the capability attribute being queried. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n */ NVENCSTATUS NVENCAPI NvEncGetEncodeCaps (void* encoder, GUID encodeGUID, NV_ENC_CAPS_PARAM* capsParam, int* capsVal); // NvEncGetEncodePresetCount /** * \brief Retrieves the number of supported preset GUIDs. * * The function returns the number of preset GUIDs available for a given codec. * The client must validate the codec GUID using ::NvEncGetEncodeGUIDs() API * before calling this function. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * Encode GUID, corresponding to which the number of supported presets is to * be retrieved. * \param [out] encodePresetGUIDCount * Receives the number of supported preset GUIDs. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodePresetCount (void* encoder, GUID encodeGUID, uint32_t* encodePresetGUIDCount); // NvEncGetEncodePresetGUIDs /** * \brief Receives an array of supported encoder preset GUIDs. * * The function returns an array of encode preset GUIDs available for a given codec. * The client can directly use one of the preset GUIDs based upon the use case * or target device. The preset GUID chosen can be directly used in * NV_ENC_INITIALIZE_PARAMS::presetGUID parameter to ::NvEncEncodePicture() API. * Alternately client can also use the preset GUID to retrieve the encoding config * parameters being used by NvEncodeAPI interface for that given preset, using * ::NvEncGetEncodePresetConfig() API. It can then modify preset config parameters * as per its use case and send it to NvEncodeAPI interface as part of * NV_ENC_INITIALIZE_PARAMS::encodeConfig parameter for NvEncInitializeEncoder() * API. * * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * Encode GUID, corresponding to which the list of supported presets is to be * retrieved. * \param [in] guidArraySize * Size of array of preset GUIDs passed in \p preset GUIDs * \param [out] presetGUIDs * Array of supported Encode preset GUIDs from the NvEncodeAPI interface * to client. * \param [out] encodePresetGUIDCount * Receives the number of preset GUIDs returned by the NvEncodeAPI * interface. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodePresetGUIDs (void* encoder, GUID encodeGUID, GUID* presetGUIDs, uint32_t guidArraySize, uint32_t* encodePresetGUIDCount); // NvEncGetEncodePresetConfig /** * \brief Returns a preset config structure supported for given preset GUID. * * The function returns a preset config structure for a given preset GUID. * NvEncGetEncodePresetConfig() API is not applicable to AV1. * Before using this function the client must enumerate the preset GUIDs available for * a given codec. The preset config structure can be modified by the client depending * upon its use case and can be then used to initialize the encoder using * ::NvEncInitializeEncoder() API. The client can use this function only if it * wants to modify the NvEncodeAPI preset configuration, otherwise it can * directly use the preset GUID. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * Encode GUID, corresponding to which the list of supported presets is to be * retrieved. * \param [in] presetGUID * Preset GUID, corresponding to which the Encoding configurations is to be * retrieved. * \param [out] presetConfig * The requested Preset Encoder Attribute set. Refer ::_NV_ENC_CONFIG for * more details. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodePresetConfig (void* encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG* presetConfig); // NvEncGetEncodePresetConfigEx /** * \brief Returns a preset config structure supported for given preset GUID. * * The function returns a preset config structure for a given preset GUID and tuning info. * NvEncGetEncodePresetConfigEx() API is not applicable to H264 and HEVC meonly mode. * Before using this function the client must enumerate the preset GUIDs available for * a given codec. The preset config structure can be modified by the client depending * upon its use case and can be then used to initialize the encoder using * ::NvEncInitializeEncoder() API. The client can use this function only if it * wants to modify the NvEncodeAPI preset configuration, otherwise it can * directly use the preset GUID. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encodeGUID * Encode GUID, corresponding to which the list of supported presets is to be * retrieved. * \param [in] presetGUID * Preset GUID, corresponding to which the Encoding configurations is to be * retrieved. * \param [in] tuningInfo * tuning info, corresponding to which the Encoding configurations is to be * retrieved. * \param [out] presetConfig * The requested Preset Encoder Attribute set. Refer ::_NV_ENC_CONFIG for * more details. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodePresetConfigEx (void* encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_TUNING_INFO tuningInfo, NV_ENC_PRESET_CONFIG* presetConfig); // NvEncInitializeEncoder /** * \brief Initialize the encoder. * * This API must be used to initialize the encoder. The initialization parameter * is passed using \p *createEncodeParams The client must send the following * fields of the _NV_ENC_INITIALIZE_PARAMS structure with a valid value. * - NV_ENC_INITIALIZE_PARAMS::encodeGUID * - NV_ENC_INITIALIZE_PARAMS::encodeWidth * - NV_ENC_INITIALIZE_PARAMS::encodeHeight * * The client can pass a preset GUID directly to the NvEncodeAPI interface using * NV_ENC_INITIALIZE_PARAMS::presetGUID field. If the client doesn't pass * NV_ENC_INITIALIZE_PARAMS::encodeConfig structure, the codec specific parameters * will be selected based on the preset GUID. The preset GUID must have been * validated by the client using ::NvEncGetEncodePresetGUIDs() API. * If the client passes a custom ::_NV_ENC_CONFIG structure through * NV_ENC_INITIALIZE_PARAMS::encodeConfig , it will override the codec specific parameters * based on the preset GUID. It is recommended that even if the client passes a custom config, * it should also send a preset GUID. In this case, the preset GUID passed by the client * will not override any of the custom config parameters programmed by the client, * it is only used as a hint by the NvEncodeAPI interface to determine certain encoder parameters * which are not exposed to the client. * * There are two modes of operation for the encoder namely: * - Asynchronous mode * - Synchronous mode * * The client can select asynchronous or synchronous mode by setting the \p * enableEncodeAsync field in ::_NV_ENC_INITIALIZE_PARAMS to 1 or 0 respectively. *\par Asynchronous mode of operation: * The Asynchronous mode can be enabled by setting NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 1. * The client operating in asynchronous mode must allocate completion event object * for each output buffer and pass the completion event object in the * ::NvEncEncodePicture() API. The client can create another thread and wait on * the event object to be signaled by NvEncodeAPI interface on completion of the * encoding process for the output frame. This should unblock the main thread from * submitting work to the encoder. When the event is signaled the client can call * NvEncodeAPI interfaces to copy the bitstream data using ::NvEncLockBitstream() * API. This is the preferred mode of operation. * * NOTE: Asynchronous mode is not supported on Linux. * *\par Synchronous mode of operation: * The client can select synchronous mode by setting NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 0. * The client working in synchronous mode can work in a single threaded or multi * threaded mode. The client need not allocate any event objects. The client can * only lock the bitstream data after NvEncodeAPI interface has returned * ::NV_ENC_SUCCESS from encode picture. The NvEncodeAPI interface can return * ::NV_ENC_ERR_NEED_MORE_INPUT error code from ::NvEncEncodePicture() API. The * client must not lock the output buffer in such case but should send the next * frame for encoding. The client must keep on calling ::NvEncEncodePicture() API * until it returns ::NV_ENC_SUCCESS. \n * The client must always lock the bitstream data in order in which it has submitted. * This is true for both asynchronous and synchronous mode. * *\par Picture type decision: * If the client is taking the picture type decision and it must disable the picture * type decision module in NvEncodeAPI by setting NV_ENC_INITIALIZE_PARAMS::enablePTD * to 0. In this case the client is required to send the picture in encoding * order to NvEncodeAPI by doing the re-ordering for B frames. \n * If the client doesn't want to take the picture type decision it can enable * picture type decision module in the NvEncodeAPI interface by setting * NV_ENC_INITIALIZE_PARAMS::enablePTD to 1 and send the input pictures in display * order. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] createEncodeParams * Refer ::_NV_ENC_INITIALIZE_PARAMS for details. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncInitializeEncoder (void* encoder, NV_ENC_INITIALIZE_PARAMS* createEncodeParams); // NvEncCreateInputBuffer /** * \brief Allocates Input buffer. * * This function is used to allocate an input buffer. The client must enumerate * the input buffer format before allocating the input buffer resources. The * NV_ENC_INPUT_PTR returned by the NvEncodeAPI interface in the * NV_ENC_CREATE_INPUT_BUFFER::inputBuffer field can be directly used in * ::NvEncEncodePicture() API. The number of input buffers to be allocated by the * client must be at least 4 more than the number of B frames being used for encoding. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] createInputBufferParams * Pointer to the ::NV_ENC_CREATE_INPUT_BUFFER structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncCreateInputBuffer (void* encoder, NV_ENC_CREATE_INPUT_BUFFER* createInputBufferParams); // NvEncDestroyInputBuffer /** * \brief Release an input buffers. * * This function is used to free an input buffer. If the client has allocated * any input buffer using ::NvEncCreateInputBuffer() API, it must free those * input buffers by calling this function. The client must release the input * buffers before destroying the encoder using ::NvEncDestroyEncoder() API. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] inputBuffer * Pointer to the input buffer to be released. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncDestroyInputBuffer (void* encoder, NV_ENC_INPUT_PTR inputBuffer); // NvEncSetIOCudaStreams /** * \brief Set input and output CUDA stream for specified encoder attribute. * * Encoding may involve CUDA pre-processing on the input and post-processing on encoded output. * This function is used to set input and output CUDA streams to pipeline the CUDA pre-processing * and post-processing tasks. Clients should call this function before the call to * NvEncUnlockInputBuffer(). If this function is not called, the default CUDA stream is used for * input and output processing. After a successful call to this function, the streams specified * in that call will replace the previously-used streams. * This API is supported for NVCUVID interface only. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] inputStream * Pointer to CUstream which is used to process ::NV_ENC_PIC_PARAMS::inputFrame for encode. * In case of ME-only mode, inputStream is used to process ::NV_ENC_MEONLY_PARAMS::inputBuffer and * ::NV_ENC_MEONLY_PARAMS::referenceFrame * \param [in] outputStream * Pointer to CUstream which is used to process ::NV_ENC_PIC_PARAMS::outputBuffer for encode. * In case of ME-only mode, outputStream is used to process ::NV_ENC_MEONLY_PARAMS::mvBuffer * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_GENERIC \n */ NVENCSTATUS NVENCAPI NvEncSetIOCudaStreams (void* encoder, NV_ENC_CUSTREAM_PTR inputStream, NV_ENC_CUSTREAM_PTR outputStream); // NvEncCreateBitstreamBuffer /** * \brief Allocates an output bitstream buffer * * This function is used to allocate an output bitstream buffer and returns a * NV_ENC_OUTPUT_PTR to bitstream buffer to the client in the * NV_ENC_CREATE_BITSTREAM_BUFFER::bitstreamBuffer field. * The client can only call this function after the encoder session has been * initialized using ::NvEncInitializeEncoder() API. The minimum number of output * buffers allocated by the client must be at least 4 more than the number of B * B frames being used for encoding. The client can only access the output * bitstream data by locking the \p bitstreamBuffer using the ::NvEncLockBitstream() * function. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] createBitstreamBufferParams * Pointer ::NV_ENC_CREATE_BITSTREAM_BUFFER for details. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncCreateBitstreamBuffer (void* encoder, NV_ENC_CREATE_BITSTREAM_BUFFER* createBitstreamBufferParams); // NvEncDestroyBitstreamBuffer /** * \brief Release a bitstream buffer. * * This function is used to release the output bitstream buffer allocated using * the ::NvEncCreateBitstreamBuffer() function. The client must release the output * bitstreamBuffer using this function before destroying the encoder session. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] bitstreamBuffer * Pointer to the bitstream buffer being released. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncDestroyBitstreamBuffer (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); // NvEncEncodePicture /** * \brief Submit an input picture for encoding. * * This function is used to submit an input picture buffer for encoding. The * encoding parameters are passed using \p *encodePicParams which is a pointer * to the ::_NV_ENC_PIC_PARAMS structure. * * If the client has set NV_ENC_INITIALIZE_PARAMS::enablePTD to 0, then it must * send a valid value for the following fields. * - NV_ENC_PIC_PARAMS::pictureType * - NV_ENC_PIC_PARAMS_H264::displayPOCSyntax (H264 only) * - NV_ENC_PIC_PARAMS_H264::frameNumSyntax(H264 only) * - NV_ENC_PIC_PARAMS_H264::refPicFlag(H264 only) * *\par MVC Encoding: * For MVC encoding the client must call encode picture API for each view separately * and must pass valid view id in NV_ENC_PIC_PARAMS_MVC::viewID field. Currently * NvEncodeAPI only support stereo MVC so client must send viewID as 0 for base * view and view ID as 1 for dependent view. * *\par Asynchronous Encoding * If the client has enabled asynchronous mode of encoding by setting * NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 1 in the ::NvEncInitializeEncoder() * API ,then the client must send a valid NV_ENC_PIC_PARAMS::completionEvent. * Incase of asynchronous mode of operation, client can queue the ::NvEncEncodePicture() * API commands from the main thread and then queue output buffers to be processed * to a secondary worker thread. Before the locking the output buffers in the * secondary thread , the client must wait on NV_ENC_PIC_PARAMS::completionEvent * it has queued in ::NvEncEncodePicture() API call. The client must always process * completion event and the output buffer in the same order in which they have been * submitted for encoding. The NvEncodeAPI interface is responsible for any * re-ordering required for B frames and will always ensure that encoded bitstream * data is written in the same order in which output buffer is submitted. * The NvEncodeAPI interface may return ::NV_ENC_ERR_NEED_MORE_INPUT error code for * some ::NvEncEncodePicture() API calls but the client must not treat it as a fatal error. * The NvEncodeAPI interface might not be able to submit an input picture buffer for encoding * immediately due to re-ordering for B frames. *\code The below example shows how asynchronous encoding in case of 1 B frames ------------------------------------------------------------------------ Suppose the client allocated 4 input buffers(I1,I2..), 4 output buffers(O1,O2..) and 4 completion events(E1, E2, ...). The NvEncodeAPI interface will need to keep a copy of the input buffers for re-ordering and it allocates following internal buffers (NvI1, NvI2...). These internal buffers are managed by NvEncodeAPI and the client is not responsible for the allocating or freeing the memory of the internal buffers. a) The client main thread will queue the following encode frame calls. Note the picture type is unknown to the client, the decision is being taken by NvEncodeAPI interface. The client should pass ::_NV_ENC_PIC_PARAMS parameter consisting of allocated input buffer, output buffer and output events in successive ::NvEncEncodePicture() API calls along with other required encode picture params. For example: 1st EncodePicture parameters - (I1, O1, E1) 2nd EncodePicture parameters - (I2, O2, E2) 3rd EncodePicture parameters - (I3, O3, E3) b) NvEncodeAPI SW will receive the following encode Commands from the client. The left side shows input from client in the form (Input buffer, Output Buffer, Output Event). The right hand side shows a possible picture type decision take by the NvEncodeAPI interface. (I1, O1, E1) ---P1 Frame (I2, O2, E2) ---B2 Frame (I3, O3, E3) ---P3 Frame c) NvEncodeAPI interface will make a copy of the input buffers to its internal buffers for re-ordering. These copies are done as part of nvEncEncodePicture function call from the client and NvEncodeAPI interface is responsible for synchronization of copy operation with the actual encoding operation. I1 --> NvI1 I2 --> NvI2 I3 --> NvI3 d) The NvEncodeAPI encodes I1 as P frame and submits I1 to encoder HW and returns ::NV_ENC_SUCCESS. The NvEncodeAPI tries to encode I2 as B frame and fails with ::NV_ENC_ERR_NEED_MORE_INPUT error code. The error is not fatal and it notifies client that I2 is not submitted to encoder immediately. The NvEncodeAPI encodes I3 as P frame and submits I3 for encoding which will be used as backward reference frame for I2. The NvEncodeAPI then submits I2 for encoding and returns ::NV_ENC_SUCESS. Both the submission are part of the same ::NvEncEncodePicture() function call. e) After returning from ::NvEncEncodePicture() call , the client must queue the output bitstream processing work to the secondary thread. The output bitstream processing for asynchronous mode consist of first waiting on completion event(E1, E2..) and then locking the output bitstream buffer(O1, O2..) for reading the encoded data. The work queued to the secondary thread by the client is in the following order (I1, O1, E1) (I2, O2, E2) (I3, O3, E3) Note they are in the same order in which client calls ::NvEncEncodePicture() API in \p step a). f) NvEncodeAPI interface will do the re-ordering such that Encoder HW will receive the following encode commands: (NvI1, O1, E1) ---P1 Frame (NvI3, O2, E2) ---P3 Frame (NvI2, O3, E3) ---B2 frame g) After the encoding operations are completed, the events will be signaled by NvEncodeAPI interface in the following order : (O1, E1) ---P1 Frame ,output bitstream copied to O1 and event E1 signaled. (O2, E2) ---P3 Frame ,output bitstream copied to O2 and event E2 signaled. (O3, E3) ---B2 Frame ,output bitstream copied to O3 and event E3 signaled. h) The client must lock the bitstream data using ::NvEncLockBitstream() API in the order O1,O2,O3 to read the encoded data, after waiting for the events to be signaled in the same order i.e E1, E2 and E3.The output processing is done in the secondary thread in the following order: Waits on E1, copies encoded bitstream from O1 Waits on E2, copies encoded bitstream from O2 Waits on E3, copies encoded bitstream from O3 -Note the client will receive the events signaling and output buffer in the same order in which they have submitted for encoding. -Note the LockBitstream will have picture type field which will notify the output picture type to the clients. -Note the input, output buffer and the output completion event are free to be reused once NvEncodeAPI interfaced has signaled the event and the client has copied the data from the output buffer. * \endcode * *\par Synchronous Encoding * The client can enable synchronous mode of encoding by setting * NV_ENC_INITIALIZE_PARAMS::enableEncodeAsync to 0 in ::NvEncInitializeEncoder() API. * The NvEncodeAPI interface may return ::NV_ENC_ERR_NEED_MORE_INPUT error code for * some ::NvEncEncodePicture() API calls when NV_ENC_INITIALIZE_PARAMS::enablePTD * is set to 1, but the client must not treat it as a fatal error. The NvEncodeAPI * interface might not be able to submit an input picture buffer for encoding * immediately due to re-ordering for B frames. The NvEncodeAPI interface cannot * submit the input picture which is decided to be encoded as B frame as it waits * for backward reference from temporally subsequent frames. This input picture * is buffered internally and waits for more input picture to arrive. The client * must not call ::NvEncLockBitstream() API on the output buffers whose * ::NvEncEncodePicture() API returns ::NV_ENC_ERR_NEED_MORE_INPUT. The client must * wait for the NvEncodeAPI interface to return ::NV_ENC_SUCCESS before locking the * output bitstreams to read the encoded bitstream data. The following example * explains the scenario with synchronous encoding with 2 B frames. *\code The below example shows how synchronous encoding works in case of 1 B frames ----------------------------------------------------------------------------- Suppose the client allocated 4 input buffers(I1,I2..), 4 output buffers(O1,O2..) and 4 completion events(E1, E2, ...). The NvEncodeAPI interface will need to keep a copy of the input buffers for re-ordering and it allocates following internal buffers (NvI1, NvI2...). These internal buffers are managed by NvEncodeAPI and the client is not responsible for the allocating or freeing the memory of the internal buffers. The client calls ::NvEncEncodePicture() API with input buffer I1 and output buffer O1. The NvEncodeAPI decides to encode I1 as P frame and submits it to encoder HW and returns ::NV_ENC_SUCCESS. The client can now read the encoded data by locking the output O1 by calling NvEncLockBitstream API. The client calls ::NvEncEncodePicture() API with input buffer I2 and output buffer O2. The NvEncodeAPI decides to encode I2 as B frame and buffers I2 by copying it to internal buffer and returns ::NV_ENC_ERR_NEED_MORE_INPUT. The error is not fatal and it notifies client that it cannot read the encoded data by locking the output O2 by calling ::NvEncLockBitstream() API without submitting more work to the NvEncodeAPI interface. The client calls ::NvEncEncodePicture() with input buffer I3 and output buffer O3. The NvEncodeAPI decides to encode I3 as P frame and it first submits I3 for encoding which will be used as backward reference frame for I2. The NvEncodeAPI then submits I2 for encoding and returns ::NV_ENC_SUCESS. Both the submission are part of the same ::NvEncEncodePicture() function call. The client can now read the encoded data for both the frames by locking the output O2 followed by O3 ,by calling ::NvEncLockBitstream() API. The client must always lock the output in the same order in which it has submitted to receive the encoded bitstream in correct encoding order. * \endcode * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] encodePicParams * Pointer to the ::_NV_ENC_PIC_PARAMS structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_ENCODER_BUSY \n * ::NV_ENC_ERR_NEED_MORE_INPUT \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncEncodePicture (void* encoder, NV_ENC_PIC_PARAMS* encodePicParams); // NvEncLockBitstream /** * \brief Lock output bitstream buffer * * This function is used to lock the bitstream buffer to read the encoded data. * The client can only access the encoded data by calling this function. * The pointer to client accessible encoded data is returned in the * NV_ENC_LOCK_BITSTREAM::bitstreamBufferPtr field. The size of the encoded data * in the output buffer is returned in the NV_ENC_LOCK_BITSTREAM::bitstreamSizeInBytes * The NvEncodeAPI interface also returns the output picture type and picture structure * of the encoded frame in NV_ENC_LOCK_BITSTREAM::pictureType and * NV_ENC_LOCK_BITSTREAM::pictureStruct fields respectively. If the client has * set NV_ENC_LOCK_BITSTREAM::doNotWait to 1, the function might return * ::NV_ENC_ERR_LOCK_BUSY if client is operating in synchronous mode. This is not * a fatal failure if NV_ENC_LOCK_BITSTREAM::doNotWait is set to 1. In the above case the client can * retry the function after few milliseconds. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] lockBitstreamBufferParams * Pointer to the ::_NV_ENC_LOCK_BITSTREAM structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_LOCK_BUSY \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncLockBitstream (void* encoder, NV_ENC_LOCK_BITSTREAM* lockBitstreamBufferParams); // NvEncUnlockBitstream /** * \brief Unlock the output bitstream buffer * * This function is used to unlock the output bitstream buffer after the client * has read the encoded data from output buffer. The client must call this function * to unlock the output buffer which it has previously locked using ::NvEncLockBitstream() * function. Using a locked bitstream buffer in ::NvEncEncodePicture() API will cause * the function to fail. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] bitstreamBuffer * bitstream buffer pointer being unlocked * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncUnlockBitstream (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); // NvLockInputBuffer /** * \brief Locks an input buffer * * This function is used to lock the input buffer to load the uncompressed YUV * pixel data into input buffer memory. The client must pass the NV_ENC_INPUT_PTR * it had previously allocated using ::NvEncCreateInputBuffer()in the * NV_ENC_LOCK_INPUT_BUFFER::inputBuffer field. * The NvEncodeAPI interface returns pointer to client accessible input buffer * memory in NV_ENC_LOCK_INPUT_BUFFER::bufferDataPtr field. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] lockInputBufferParams * Pointer to the ::_NV_ENC_LOCK_INPUT_BUFFER structure * * \return * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_LOCK_BUSY \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncLockInputBuffer (void* encoder, NV_ENC_LOCK_INPUT_BUFFER* lockInputBufferParams); // NvUnlockInputBuffer /** * \brief Unlocks the input buffer * * This function is used to unlock the input buffer memory previously locked for * uploading YUV pixel data. The input buffer must be unlocked before being used * again for encoding, otherwise NvEncodeAPI will fail the ::NvEncEncodePicture() * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] inputBuffer * Pointer to the input buffer that is being unlocked. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * * */ NVENCSTATUS NVENCAPI NvEncUnlockInputBuffer (void* encoder, NV_ENC_INPUT_PTR inputBuffer); // NvEncGetEncodeStats /** * \brief Get encoding statistics. * * This function is used to retrieve the encoding statistics. * This API is not supported when encode device type is CUDA. * Note that this API will be removed in future Video Codec SDK release. * Clients should use NvEncLockBitstream() API to retrieve the encoding statistics. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] encodeStats * Pointer to the ::_NV_ENC_STAT structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetEncodeStats (void* encoder, NV_ENC_STAT* encodeStats); // NvEncGetSequenceParams /** * \brief Get encoded sequence and picture header. * * This function can be used to retrieve the sequence and picture header out of * band. The client must call this function only after the encoder has been * initialized using ::NvEncInitializeEncoder() function. The client must * allocate the memory where the NvEncodeAPI interface can copy the bitstream * header and pass the pointer to the memory in NV_ENC_SEQUENCE_PARAM_PAYLOAD::spsppsBuffer. * The size of buffer is passed in the field NV_ENC_SEQUENCE_PARAM_PAYLOAD::inBufferSize. * The NvEncodeAPI interface will copy the bitstream header payload and returns * the actual size of the bitstream header in the field * NV_ENC_SEQUENCE_PARAM_PAYLOAD::outSPSPPSPayloadSize. * The client must call ::NvEncGetSequenceParams() function from the same thread which is * being used to call ::NvEncEncodePicture() function. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] sequenceParamPayload * Pointer to the ::_NV_ENC_SEQUENCE_PARAM_PAYLOAD structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetSequenceParams (void* encoder, NV_ENC_SEQUENCE_PARAM_PAYLOAD* sequenceParamPayload); // NvEncGetSequenceParamEx /** * \brief Get sequence and picture header. * * This function can be used to retrieve the sequence and picture header out of band, even when * encoder has not been initialized using ::NvEncInitializeEncoder() function. * The client must allocate the memory where the NvEncodeAPI interface can copy the bitstream * header and pass the pointer to the memory in NV_ENC_SEQUENCE_PARAM_PAYLOAD::spsppsBuffer. * The size of buffer is passed in the field NV_ENC_SEQUENCE_PARAM_PAYLOAD::inBufferSize. * If encoder has not been initialized using ::NvEncInitializeEncoder() function, client must * send NV_ENC_INITIALIZE_PARAMS as input. The NV_ENC_INITIALIZE_PARAMS passed must be same as the * one which will be used for initializing encoder using ::NvEncInitializeEncoder() function later. * If encoder is already initialized using ::NvEncInitializeEncoder() function, the provided * NV_ENC_INITIALIZE_PARAMS structure is ignored. The NvEncodeAPI interface will copy the bitstream * header payload and returns the actual size of the bitstream header in the field * NV_ENC_SEQUENCE_PARAM_PAYLOAD::outSPSPPSPayloadSize. The client must call ::NvEncGetSequenceParamsEx() * function from the same thread which is being used to call ::NvEncEncodePicture() function. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] encInitParams * Pointer to the _NV_ENC_INITIALIZE_PARAMS structure. * \param [in,out] sequenceParamPayload * Pointer to the ::_NV_ENC_SEQUENCE_PARAM_PAYLOAD structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncGetSequenceParamEx (void* encoder, NV_ENC_INITIALIZE_PARAMS* encInitParams, NV_ENC_SEQUENCE_PARAM_PAYLOAD* sequenceParamPayload); // NvEncRegisterAsyncEvent /** * \brief Register event for notification to encoding completion. * * This function is used to register the completion event with NvEncodeAPI * interface. The event is required when the client has configured the encoder to * work in asynchronous mode. In this mode the client needs to send a completion * event with every output buffer. The NvEncodeAPI interface will signal the * completion of the encoding process using this event. Only after the event is * signaled the client can get the encoded data using ::NvEncLockBitstream() function. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] eventParams * Pointer to the ::_NV_ENC_EVENT_PARAMS structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncRegisterAsyncEvent (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); // NvEncUnregisterAsyncEvent /** * \brief Unregister completion event. * * This function is used to unregister completion event which has been previously * registered using ::NvEncRegisterAsyncEvent() function. The client must unregister * all events before destroying the encoder using ::NvEncDestroyEncoder() function. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] eventParams * Pointer to the ::_NV_ENC_EVENT_PARAMS structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncUnregisterAsyncEvent (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); // NvEncMapInputResource /** * \brief Map an externally created input resource pointer for encoding. * * Maps an externally allocated input resource [using and returns a NV_ENC_INPUT_PTR * which can be used for encoding in the ::NvEncEncodePicture() function. The * mapped resource is returned in the field NV_ENC_MAP_INPUT_RESOURCE::outputResourcePtr. * The NvEncodeAPI interface also returns the buffer format of the mapped resource * in the field NV_ENC_MAP_INPUT_RESOURCE::outbufferFmt. * This function provides synchronization guarantee that any graphics work submitted * on the input buffer is completed before the buffer is used for encoding. This is * also true for compute (i.e. CUDA) work, provided that the previous workload using * the input resource was submitted to the default stream. * The client should not access any input buffer while they are mapped by the encoder. * For D3D12 interface type, this function does not provide synchronization guarantee. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] mapInputResParams * Pointer to the ::_NV_ENC_MAP_INPUT_RESOURCE structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_RESOURCE_NOT_REGISTERED \n * ::NV_ENC_ERR_MAP_FAILED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncMapInputResource (void* encoder, NV_ENC_MAP_INPUT_RESOURCE* mapInputResParams); // NvEncUnmapInputResource /** * \brief UnMaps a NV_ENC_INPUT_PTR which was mapped for encoding * * * UnMaps an input buffer which was previously mapped using ::NvEncMapInputResource() * API. The mapping created using ::NvEncMapInputResource() should be invalidated * using this API before the external resource is destroyed by the client. The client * must unmap the buffer after ::NvEncLockBitstream() API returns successfully for encode * work submitted using the mapped input buffer. * * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] mappedInputBuffer * Pointer to the NV_ENC_INPUT_PTR * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_RESOURCE_NOT_REGISTERED \n * ::NV_ENC_ERR_RESOURCE_NOT_MAPPED \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncUnmapInputResource (void* encoder, NV_ENC_INPUT_PTR mappedInputBuffer); // NvEncDestroyEncoder /** * \brief Destroy Encoding Session * * Destroys the encoder session previously created using ::NvEncOpenEncodeSession() * function. The client must flush the encoder before freeing any resources. In order * to flush the encoder the client must pass a NULL encode picture packet and either * wait for the ::NvEncEncodePicture() function to return in synchronous mode or wait * for the flush event to be signaled by the encoder in asynchronous mode. * The client must free all the input and output resources created using the * NvEncodeAPI interface before destroying the encoder. If the client is operating * in asynchronous mode, it must also unregister the completion events previously * registered. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncDestroyEncoder (void* encoder); // NvEncInvalidateRefFrames /** * \brief Invalidate reference frames * * Invalidates reference frame based on the time stamp provided by the client. * The encoder marks any reference frames or any frames which have been reconstructed * using the corrupt frame as invalid for motion estimation and uses older reference * frames for motion estimation. The encoder forces the current frame to be encoded * as an intra frame if no reference frames are left after invalidation process. * This is useful for low latency application for error resiliency. The client * is recommended to set NV_ENC_CONFIG_H264::maxNumRefFrames to a large value so * that encoder can keep a backup of older reference frames in the DPB and can use them * for motion estimation when the newer reference frames have been invalidated. * This API can be called multiple times. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] invalidRefFrameTimeStamp * Timestamp of the invalid reference frames which needs to be invalidated. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncInvalidateRefFrames(void* encoder, uint64_t invalidRefFrameTimeStamp); // NvEncOpenEncodeSessionEx /** * \brief Opens an encoding session. * * Opens an encoding session and returns a pointer to the encoder interface in * the \p **encoder parameter. The client should start encoding process by calling * this API first. * The client must pass a pointer to IDirect3DDevice9 device or CUDA context in the \p *device parameter. * For the OpenGL interface, \p device must be NULL. An OpenGL context must be current when * calling all NvEncodeAPI functions. * If the creation of encoder session fails, the client must call ::NvEncDestroyEncoder API * before exiting. * * \param [in] openSessionExParams * Pointer to a ::NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS structure. * \param [out] encoder * Encode Session pointer to the NvEncodeAPI interface. * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_NO_ENCODE_DEVICE \n * ::NV_ENC_ERR_UNSUPPORTED_DEVICE \n * ::NV_ENC_ERR_INVALID_DEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncOpenEncodeSessionEx (NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, void** encoder); // NvEncRegisterResource /** * \brief Registers a resource with the Nvidia Video Encoder Interface. * * Registers a resource with the Nvidia Video Encoder Interface for book keeping. * The client is expected to pass the registered resource handle as well, while calling ::NvEncMapInputResource API. * * \param [in] encoder * Pointer to the NVEncodeAPI interface. * * \param [in] registerResParams * Pointer to a ::_NV_ENC_REGISTER_RESOURCE structure * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_RESOURCE_REGISTER_FAILED \n * ::NV_ENC_ERR_GENERIC \n * ::NV_ENC_ERR_UNIMPLEMENTED \n * */ NVENCSTATUS NVENCAPI NvEncRegisterResource (void* encoder, NV_ENC_REGISTER_RESOURCE* registerResParams); // NvEncUnregisterResource /** * \brief Unregisters a resource previously registered with the Nvidia Video Encoder Interface. * * Unregisters a resource previously registered with the Nvidia Video Encoder Interface. * The client is expected to unregister any resource that it has registered with the * Nvidia Video Encoder Interface before destroying the resource. * * \param [in] encoder * Pointer to the NVEncodeAPI interface. * * \param [in] registeredResource * The registered resource pointer that was returned in ::NvEncRegisterResource. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_RESOURCE_NOT_REGISTERED \n * ::NV_ENC_ERR_GENERIC \n * ::NV_ENC_ERR_UNIMPLEMENTED \n * */ NVENCSTATUS NVENCAPI NvEncUnregisterResource (void* encoder, NV_ENC_REGISTERED_PTR registeredResource); // NvEncReconfigureEncoder /** * \brief Reconfigure an existing encoding session. * * Reconfigure an existing encoding session. * The client should call this API to change/reconfigure the parameter passed during * NvEncInitializeEncoder API call. * Currently Reconfiguration of following are not supported. * Change in GOP structure. * Change in sync-Async mode. * Change in MaxWidth & MaxHeight. * Change in PTD mode. * * Resolution change is possible only if maxEncodeWidth & maxEncodeHeight of NV_ENC_INITIALIZE_PARAMS * is set while creating encoder session. * * \param [in] encoder * Pointer to the NVEncodeAPI interface. * * \param [in] reInitEncodeParams * Pointer to a ::NV_ENC_RECONFIGURE_PARAMS structure. * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_NO_ENCODE_DEVICE \n * ::NV_ENC_ERR_UNSUPPORTED_DEVICE \n * ::NV_ENC_ERR_INVALID_DEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_GENERIC \n * */ NVENCSTATUS NVENCAPI NvEncReconfigureEncoder (void *encoder, NV_ENC_RECONFIGURE_PARAMS* reInitEncodeParams); // NvEncCreateMVBuffer /** * \brief Allocates output MV buffer for ME only mode. * * This function is used to allocate an output MV buffer. The size of the mvBuffer is * dependent on the frame height and width of the last ::NvEncCreateInputBuffer() call. * The NV_ENC_OUTPUT_PTR returned by the NvEncodeAPI interface in the * ::NV_ENC_CREATE_MV_BUFFER::mvBuffer field should be used in * ::NvEncRunMotionEstimationOnly() API. * Client must lock ::NV_ENC_CREATE_MV_BUFFER::mvBuffer using ::NvEncLockBitstream() API to get the motion vector data. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in,out] createMVBufferParams * Pointer to the ::NV_ENC_CREATE_MV_BUFFER structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_GENERIC \n */ NVENCSTATUS NVENCAPI NvEncCreateMVBuffer (void* encoder, NV_ENC_CREATE_MV_BUFFER* createMVBufferParams); // NvEncDestroyMVBuffer /** * \brief Release an output MV buffer for ME only mode. * * This function is used to release the output MV buffer allocated using * the ::NvEncCreateMVBuffer() function. The client must release the output * mvBuffer using this function before destroying the encoder session. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] mvBuffer * Pointer to the mvBuffer being released. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n */ NVENCSTATUS NVENCAPI NvEncDestroyMVBuffer (void* encoder, NV_ENC_OUTPUT_PTR mvBuffer); // NvEncRunMotionEstimationOnly /** * \brief Submit an input picture and reference frame for motion estimation in ME only mode. * * This function is used to submit the input frame and reference frame for motion * estimation. The ME parameters are passed using *meOnlyParams which is a pointer * to ::_NV_ENC_MEONLY_PARAMS structure. * Client must lock ::NV_ENC_CREATE_MV_BUFFER::mvBuffer using ::NvEncLockBitstream() API to get the motion vector data. * to get motion vector data. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * \param [in] meOnlyParams * Pointer to the ::_NV_ENC_MEONLY_PARAMS structure. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n * ::NV_ENC_ERR_INVALID_ENCODERDEVICE \n * ::NV_ENC_ERR_DEVICE_NOT_EXIST \n * ::NV_ENC_ERR_UNSUPPORTED_PARAM \n * ::NV_ENC_ERR_OUT_OF_MEMORY \n * ::NV_ENC_ERR_INVALID_PARAM \n * ::NV_ENC_ERR_INVALID_VERSION \n * ::NV_ENC_ERR_NEED_MORE_INPUT \n * ::NV_ENC_ERR_ENCODER_NOT_INITIALIZED \n * ::NV_ENC_ERR_GENERIC \n */ NVENCSTATUS NVENCAPI NvEncRunMotionEstimationOnly (void* encoder, NV_ENC_MEONLY_PARAMS* meOnlyParams); // NvEncodeAPIGetMaxSupportedVersion /** * \brief Get the largest NvEncodeAPI version supported by the driver. * * This function can be used by clients to determine if the driver supports * the NvEncodeAPI header the application was compiled with. * * \param [out] version * Pointer to the requested value. The 4 least significant bits in the returned * indicate the minor version and the rest of the bits indicate the major * version of the largest supported version. * * \return * ::NV_ENC_SUCCESS \n * ::NV_ENC_ERR_INVALID_PTR \n */ NVENCSTATUS NVENCAPI NvEncodeAPIGetMaxSupportedVersion (uint32_t* version); // NvEncGetLastErrorString /** * \brief Get the description of the last error reported by the API. * * This function returns a null-terminated string that can be used by clients to better understand the reason * for failure of a previous API call. * * \param [in] encoder * Pointer to the NvEncodeAPI interface. * * \return * Pointer to buffer containing the details of the last error encountered by the API. */ const char * NVENCAPI NvEncGetLastErrorString (void* encoder); /// \cond API PFN /* * Defines API function pointers */ typedef NVENCSTATUS (NVENCAPI* PNVENCOPENENCODESESSION) (void* device, uint32_t deviceType, void** encoder); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEGUIDCOUNT) (void* encoder, uint32_t* encodeGUIDCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEGUIDS) (void* encoder, GUID* GUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPROFILEGUIDCOUNT) (void* encoder, GUID encodeGUID, uint32_t* encodeProfileGUIDCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPROFILEGUIDS) (void* encoder, GUID encodeGUID, GUID* profileGUIDs, uint32_t guidArraySize, uint32_t* GUIDCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETINPUTFORMATCOUNT) (void* encoder, GUID encodeGUID, uint32_t* inputFmtCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETINPUTFORMATS) (void* encoder, GUID encodeGUID, NV_ENC_BUFFER_FORMAT* inputFmts, uint32_t inputFmtArraySize, uint32_t* inputFmtCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODECAPS) (void* encoder, GUID encodeGUID, NV_ENC_CAPS_PARAM* capsParam, int* capsVal); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPRESETCOUNT) (void* encoder, GUID encodeGUID, uint32_t* encodePresetGUIDCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPRESETGUIDS) (void* encoder, GUID encodeGUID, GUID* presetGUIDs, uint32_t guidArraySize, uint32_t* encodePresetGUIDCount); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPRESETCONFIG) (void* encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_PRESET_CONFIG* presetConfig); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODEPRESETCONFIGEX) (void* encoder, GUID encodeGUID, GUID presetGUID, NV_ENC_TUNING_INFO tuningInfo, NV_ENC_PRESET_CONFIG* presetConfig); typedef NVENCSTATUS (NVENCAPI* PNVENCINITIALIZEENCODER) (void* encoder, NV_ENC_INITIALIZE_PARAMS* createEncodeParams); typedef NVENCSTATUS (NVENCAPI* PNVENCCREATEINPUTBUFFER) (void* encoder, NV_ENC_CREATE_INPUT_BUFFER* createInputBufferParams); typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYINPUTBUFFER) (void* encoder, NV_ENC_INPUT_PTR inputBuffer); typedef NVENCSTATUS (NVENCAPI* PNVENCCREATEBITSTREAMBUFFER) (void* encoder, NV_ENC_CREATE_BITSTREAM_BUFFER* createBitstreamBufferParams); typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYBITSTREAMBUFFER) (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); typedef NVENCSTATUS (NVENCAPI* PNVENCENCODEPICTURE) (void* encoder, NV_ENC_PIC_PARAMS* encodePicParams); typedef NVENCSTATUS (NVENCAPI* PNVENCLOCKBITSTREAM) (void* encoder, NV_ENC_LOCK_BITSTREAM* lockBitstreamBufferParams); typedef NVENCSTATUS (NVENCAPI* PNVENCUNLOCKBITSTREAM) (void* encoder, NV_ENC_OUTPUT_PTR bitstreamBuffer); typedef NVENCSTATUS (NVENCAPI* PNVENCLOCKINPUTBUFFER) (void* encoder, NV_ENC_LOCK_INPUT_BUFFER* lockInputBufferParams); typedef NVENCSTATUS (NVENCAPI* PNVENCUNLOCKINPUTBUFFER) (void* encoder, NV_ENC_INPUT_PTR inputBuffer); typedef NVENCSTATUS (NVENCAPI* PNVENCGETENCODESTATS) (void* encoder, NV_ENC_STAT* encodeStats); typedef NVENCSTATUS (NVENCAPI* PNVENCGETSEQUENCEPARAMS) (void* encoder, NV_ENC_SEQUENCE_PARAM_PAYLOAD* sequenceParamPayload); typedef NVENCSTATUS (NVENCAPI* PNVENCREGISTERASYNCEVENT) (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); typedef NVENCSTATUS (NVENCAPI* PNVENCUNREGISTERASYNCEVENT) (void* encoder, NV_ENC_EVENT_PARAMS* eventParams); typedef NVENCSTATUS (NVENCAPI* PNVENCMAPINPUTRESOURCE) (void* encoder, NV_ENC_MAP_INPUT_RESOURCE* mapInputResParams); typedef NVENCSTATUS (NVENCAPI* PNVENCUNMAPINPUTRESOURCE) (void* encoder, NV_ENC_INPUT_PTR mappedInputBuffer); typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYENCODER) (void* encoder); typedef NVENCSTATUS (NVENCAPI* PNVENCINVALIDATEREFFRAMES) (void* encoder, uint64_t invalidRefFrameTimeStamp); typedef NVENCSTATUS (NVENCAPI* PNVENCOPENENCODESESSIONEX) (NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS *openSessionExParams, void** encoder); typedef NVENCSTATUS (NVENCAPI* PNVENCREGISTERRESOURCE) (void* encoder, NV_ENC_REGISTER_RESOURCE* registerResParams); typedef NVENCSTATUS (NVENCAPI* PNVENCUNREGISTERRESOURCE) (void* encoder, NV_ENC_REGISTERED_PTR registeredRes); typedef NVENCSTATUS (NVENCAPI* PNVENCRECONFIGUREENCODER) (void* encoder, NV_ENC_RECONFIGURE_PARAMS* reInitEncodeParams); typedef NVENCSTATUS (NVENCAPI* PNVENCCREATEMVBUFFER) (void* encoder, NV_ENC_CREATE_MV_BUFFER* createMVBufferParams); typedef NVENCSTATUS (NVENCAPI* PNVENCDESTROYMVBUFFER) (void* encoder, NV_ENC_OUTPUT_PTR mvBuffer); typedef NVENCSTATUS (NVENCAPI* PNVENCRUNMOTIONESTIMATIONONLY) (void* encoder, NV_ENC_MEONLY_PARAMS* meOnlyParams); typedef const char * (NVENCAPI* PNVENCGETLASTERROR) (void* encoder); typedef NVENCSTATUS (NVENCAPI* PNVENCSETIOCUDASTREAMS) (void* encoder, NV_ENC_CUSTREAM_PTR inputStream, NV_ENC_CUSTREAM_PTR outputStream); typedef NVENCSTATUS (NVENCAPI* PNVENCGETSEQUENCEPARAMEX) (void* encoder, NV_ENC_INITIALIZE_PARAMS* encInitParams, NV_ENC_SEQUENCE_PARAM_PAYLOAD* sequenceParamPayload); /// \endcond /** @} */ /* END ENCODE_FUNC */ /** * \ingroup ENCODER_STRUCTURE * NV_ENCODE_API_FUNCTION_LIST */ typedef struct _NV_ENCODE_API_FUNCTION_LIST { uint32_t version; /**< [in]: Client should pass NV_ENCODE_API_FUNCTION_LIST_VER. */ uint32_t reserved; /**< [in]: Reserved and should be set to 0. */ PNVENCOPENENCODESESSION nvEncOpenEncodeSession; /**< [out]: Client should access ::NvEncOpenEncodeSession() API through this pointer. */ PNVENCGETENCODEGUIDCOUNT nvEncGetEncodeGUIDCount; /**< [out]: Client should access ::NvEncGetEncodeGUIDCount() API through this pointer. */ PNVENCGETENCODEPRESETCOUNT nvEncGetEncodeProfileGUIDCount; /**< [out]: Client should access ::NvEncGetEncodeProfileGUIDCount() API through this pointer.*/ PNVENCGETENCODEPRESETGUIDS nvEncGetEncodeProfileGUIDs; /**< [out]: Client should access ::NvEncGetEncodeProfileGUIDs() API through this pointer. */ PNVENCGETENCODEGUIDS nvEncGetEncodeGUIDs; /**< [out]: Client should access ::NvEncGetEncodeGUIDs() API through this pointer. */ PNVENCGETINPUTFORMATCOUNT nvEncGetInputFormatCount; /**< [out]: Client should access ::NvEncGetInputFormatCount() API through this pointer. */ PNVENCGETINPUTFORMATS nvEncGetInputFormats; /**< [out]: Client should access ::NvEncGetInputFormats() API through this pointer. */ PNVENCGETENCODECAPS nvEncGetEncodeCaps; /**< [out]: Client should access ::NvEncGetEncodeCaps() API through this pointer. */ PNVENCGETENCODEPRESETCOUNT nvEncGetEncodePresetCount; /**< [out]: Client should access ::NvEncGetEncodePresetCount() API through this pointer. */ PNVENCGETENCODEPRESETGUIDS nvEncGetEncodePresetGUIDs; /**< [out]: Client should access ::NvEncGetEncodePresetGUIDs() API through this pointer. */ PNVENCGETENCODEPRESETCONFIG nvEncGetEncodePresetConfig; /**< [out]: Client should access ::NvEncGetEncodePresetConfig() API through this pointer. */ PNVENCINITIALIZEENCODER nvEncInitializeEncoder; /**< [out]: Client should access ::NvEncInitializeEncoder() API through this pointer. */ PNVENCCREATEINPUTBUFFER nvEncCreateInputBuffer; /**< [out]: Client should access ::NvEncCreateInputBuffer() API through this pointer. */ PNVENCDESTROYINPUTBUFFER nvEncDestroyInputBuffer; /**< [out]: Client should access ::NvEncDestroyInputBuffer() API through this pointer. */ PNVENCCREATEBITSTREAMBUFFER nvEncCreateBitstreamBuffer; /**< [out]: Client should access ::NvEncCreateBitstreamBuffer() API through this pointer. */ PNVENCDESTROYBITSTREAMBUFFER nvEncDestroyBitstreamBuffer; /**< [out]: Client should access ::NvEncDestroyBitstreamBuffer() API through this pointer. */ PNVENCENCODEPICTURE nvEncEncodePicture; /**< [out]: Client should access ::NvEncEncodePicture() API through this pointer. */ PNVENCLOCKBITSTREAM nvEncLockBitstream; /**< [out]: Client should access ::NvEncLockBitstream() API through this pointer. */ PNVENCUNLOCKBITSTREAM nvEncUnlockBitstream; /**< [out]: Client should access ::NvEncUnlockBitstream() API through this pointer. */ PNVENCLOCKINPUTBUFFER nvEncLockInputBuffer; /**< [out]: Client should access ::NvEncLockInputBuffer() API through this pointer. */ PNVENCUNLOCKINPUTBUFFER nvEncUnlockInputBuffer; /**< [out]: Client should access ::NvEncUnlockInputBuffer() API through this pointer. */ PNVENCGETENCODESTATS nvEncGetEncodeStats; /**< [out]: Client should access ::NvEncGetEncodeStats() API through this pointer. */ PNVENCGETSEQUENCEPARAMS nvEncGetSequenceParams; /**< [out]: Client should access ::NvEncGetSequenceParams() API through this pointer. */ PNVENCREGISTERASYNCEVENT nvEncRegisterAsyncEvent; /**< [out]: Client should access ::NvEncRegisterAsyncEvent() API through this pointer. */ PNVENCUNREGISTERASYNCEVENT nvEncUnregisterAsyncEvent; /**< [out]: Client should access ::NvEncUnregisterAsyncEvent() API through this pointer. */ PNVENCMAPINPUTRESOURCE nvEncMapInputResource; /**< [out]: Client should access ::NvEncMapInputResource() API through this pointer. */ PNVENCUNMAPINPUTRESOURCE nvEncUnmapInputResource; /**< [out]: Client should access ::NvEncUnmapInputResource() API through this pointer. */ PNVENCDESTROYENCODER nvEncDestroyEncoder; /**< [out]: Client should access ::NvEncDestroyEncoder() API through this pointer. */ PNVENCINVALIDATEREFFRAMES nvEncInvalidateRefFrames; /**< [out]: Client should access ::NvEncInvalidateRefFrames() API through this pointer. */ PNVENCOPENENCODESESSIONEX nvEncOpenEncodeSessionEx; /**< [out]: Client should access ::NvEncOpenEncodeSession() API through this pointer. */ PNVENCREGISTERRESOURCE nvEncRegisterResource; /**< [out]: Client should access ::NvEncRegisterResource() API through this pointer. */ PNVENCUNREGISTERRESOURCE nvEncUnregisterResource; /**< [out]: Client should access ::NvEncUnregisterResource() API through this pointer. */ PNVENCRECONFIGUREENCODER nvEncReconfigureEncoder; /**< [out]: Client should access ::NvEncReconfigureEncoder() API through this pointer. */ void* reserved1; PNVENCCREATEMVBUFFER nvEncCreateMVBuffer; /**< [out]: Client should access ::NvEncCreateMVBuffer API through this pointer. */ PNVENCDESTROYMVBUFFER nvEncDestroyMVBuffer; /**< [out]: Client should access ::NvEncDestroyMVBuffer API through this pointer. */ PNVENCRUNMOTIONESTIMATIONONLY nvEncRunMotionEstimationOnly; /**< [out]: Client should access ::NvEncRunMotionEstimationOnly API through this pointer. */ PNVENCGETLASTERROR nvEncGetLastErrorString; /**< [out]: Client should access ::nvEncGetLastErrorString API through this pointer. */ PNVENCSETIOCUDASTREAMS nvEncSetIOCudaStreams; /**< [out]: Client should access ::nvEncSetIOCudaStreams API through this pointer. */ PNVENCGETENCODEPRESETCONFIGEX nvEncGetEncodePresetConfigEx; /**< [out]: Client should access ::NvEncGetEncodePresetConfigEx() API through this pointer. */ PNVENCGETSEQUENCEPARAMEX nvEncGetSequenceParamEx; /**< [out]: Client should access ::NvEncGetSequenceParamEx() API through this pointer. */ void* reserved2[277]; /**< [in]: Reserved and must be set to NULL */ } NV_ENCODE_API_FUNCTION_LIST; /** Macro for constructing the version field of ::_NV_ENCODEAPI_FUNCTION_LIST. */ #define NV_ENCODE_API_FUNCTION_LIST_VER NVENCAPI_STRUCT_VERSION(2) // NvEncodeAPICreateInstance /** * \ingroup ENCODE_FUNC * Entry Point to the NvEncodeAPI interface. * * Creates an instance of the NvEncodeAPI interface, and populates the * pFunctionList with function pointers to the API routines implemented by the * NvEncodeAPI interface. * * \param [out] functionList * * \return * ::NV_ENC_SUCCESS * ::NV_ENC_ERR_INVALID_PTR */ NVENCSTATUS NVENCAPI NvEncodeAPICreateInstance(NV_ENCODE_API_FUNCTION_LIST *functionList); #ifdef __cplusplus } #endif #endif fsdsfdsfdsfdsf-5.13.8/external/stb_image_write.h000066400000000000000000002130651520215207700217530ustar00rootroot00000000000000/* stb_image_write - v1.16 - public domain - http://nothings.org/stb writes out PNG/BMP/TGA/JPEG/HDR images to C stdio - Sean Barrett 2010-2015 no warranty implied; use at your own risk Before #including, #define STB_IMAGE_WRITE_IMPLEMENTATION in the file that you want to have the implementation. Will probably not work correctly with strict-aliasing optimizations. ABOUT: This header file is a library for writing images to C stdio or a callback. The PNG output is not optimal; it is 20-50% larger than the file written by a decent optimizing implementation; though providing a custom zlib compress function (see STBIW_ZLIB_COMPRESS) can mitigate that. This library is designed for source code compactness and simplicity, not optimal image file size or run-time performance. BUILDING: You can #define STBIW_ASSERT(x) before the #include to avoid using assert.h. You can #define STBIW_MALLOC(), STBIW_REALLOC(), and STBIW_FREE() to replace malloc,realloc,free. You can #define STBIW_MEMMOVE() to replace memmove() You can #define STBIW_ZLIB_COMPRESS to use a custom zlib-style compress function for PNG compression (instead of the builtin one), it must have the following signature: unsigned char * my_compress(unsigned char *data, int data_len, int *out_len, int quality); The returned data will be freed with STBIW_FREE() (free() by default), so it must be heap allocated with STBIW_MALLOC() (malloc() by default), UNICODE: If compiling for Windows and you wish to use Unicode filenames, compile with #define STBIW_WINDOWS_UTF8 and pass utf8-encoded filenames. Call stbiw_convert_wchar_to_utf8 to convert Windows wchar_t filenames to utf8. USAGE: There are five functions, one for each image file format: int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); int stbi_write_jpg(char const *filename, int w, int h, int comp, const void *data, int quality); int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); void stbi_flip_vertically_on_write(int flag); // flag is non-zero to flip data vertically There are also five equivalent functions that use an arbitrary write function. You are expected to open/close your file-equivalent before and after calling these: int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); where the callback is: void stbi_write_func(void *context, void *data, int size); You can configure it with these global variables: int stbi_write_tga_with_rle; // defaults to true; set to 0 to disable RLE int stbi_write_png_compression_level; // defaults to 8; set to higher for more compression int stbi_write_force_png_filter; // defaults to -1; set to 0..5 to force a filter mode You can define STBI_WRITE_NO_STDIO to disable the file variant of these functions, so the library will not use stdio.h at all. However, this will also disable HDR writing, because it requires stdio for formatted output. Each function returns 0 on failure and non-0 on success. The functions create an image file defined by the parameters. The image is a rectangle of pixels stored from left-to-right, top-to-bottom. Each pixel contains 'comp' channels of data stored interleaved with 8-bits per channel, in the following order: 1=Y, 2=YA, 3=RGB, 4=RGBA. (Y is monochrome color.) The rectangle is 'w' pixels wide and 'h' pixels tall. The *data pointer points to the first byte of the top-left-most pixel. For PNG, "stride_in_bytes" is the distance in bytes from the first byte of a row of pixels to the first byte of the next row of pixels. PNG creates output files with the same number of components as the input. The BMP format expands Y to RGB in the file format and does not output alpha. PNG supports writing rectangles of data even when the bytes storing rows of data are not consecutive in memory (e.g. sub-rectangles of a larger image), by supplying the stride between the beginning of adjacent rows. The other formats do not. (Thus you cannot write a native-format BMP through the BMP writer, both because it is in BGR order and because it may have padding at the end of the line.) PNG allows you to set the deflate compression level by setting the global variable 'stbi_write_png_compression_level' (it defaults to 8). HDR expects linear float data. Since the format is always 32-bit rgb(e) data, alpha (if provided) is discarded, and for monochrome data it is replicated across all three channels. TGA supports RLE or non-RLE compressed data. To use non-RLE-compressed data, set the global variable 'stbi_write_tga_with_rle' to 0. JPEG does ignore alpha channels in input data; quality is between 1 and 100. Higher quality looks better but results in a bigger image. JPEG baseline (no JPEG progressive). CREDITS: Sean Barrett - PNG/BMP/TGA Baldur Karlsson - HDR Jean-Sebastien Guay - TGA monochrome Tim Kelsey - misc enhancements Alan Hickman - TGA RLE Emmanuel Julien - initial file IO callback implementation Jon Olick - original jo_jpeg.cpp code Daniel Gibson - integrate JPEG, allow external zlib Aarni Koskela - allow choosing PNG filter bugfixes: github:Chribba Guillaume Chereau github:jry2 github:romigrou Sergio Gonzalez Jonas Karlsson Filip Wasil Thatcher Ulrich github:poppolopoppo Patrick Boettcher github:xeekworx Cap Petschulat Simon Rodriguez Ivan Tikhonov github:ignotion Adam Schackart Andrew Kensler LICENSE See end of file for license information. */ #ifndef INCLUDE_STB_IMAGE_WRITE_H #define INCLUDE_STB_IMAGE_WRITE_H #include // if STB_IMAGE_WRITE_STATIC causes problems, try defining STBIWDEF to 'inline' or 'static inline' #ifndef STBIWDEF #ifdef STB_IMAGE_WRITE_STATIC #define STBIWDEF static #else #ifdef __cplusplus #define STBIWDEF extern "C" #else #define STBIWDEF extern #endif #endif #endif #ifndef STB_IMAGE_WRITE_STATIC // C++ forbids static forward declarations STBIWDEF int stbi_write_tga_with_rle; STBIWDEF int stbi_write_png_compression_level; STBIWDEF int stbi_write_force_png_filter; #endif #ifndef STBI_WRITE_NO_STDIO STBIWDEF int stbi_write_png(char const *filename, int w, int h, int comp, const void *data, int stride_in_bytes); STBIWDEF int stbi_write_bmp(char const *filename, int w, int h, int comp, const void *data); STBIWDEF int stbi_write_tga(char const *filename, int w, int h, int comp, const void *data); STBIWDEF int stbi_write_hdr(char const *filename, int w, int h, int comp, const float *data); STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality); #ifdef STBIW_WINDOWS_UTF8 STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input); #endif #endif typedef void stbi_write_func(void *context, void *data, int size); STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data, int stride_in_bytes); STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const void *data); STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int w, int h, int comp, const float *data); STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality); STBIWDEF void stbi_flip_vertically_on_write(int flip_boolean); #endif//INCLUDE_STB_IMAGE_WRITE_H #ifdef STB_IMAGE_WRITE_IMPLEMENTATION #ifdef _WIN32 #ifndef _CRT_SECURE_NO_WARNINGS #define _CRT_SECURE_NO_WARNINGS #endif #ifndef _CRT_NONSTDC_NO_DEPRECATE #define _CRT_NONSTDC_NO_DEPRECATE #endif #endif #ifndef STBI_WRITE_NO_STDIO #include #endif // STBI_WRITE_NO_STDIO #include #include #include #include #if defined(STBIW_MALLOC) && defined(STBIW_FREE) && (defined(STBIW_REALLOC) || defined(STBIW_REALLOC_SIZED)) // ok #elif !defined(STBIW_MALLOC) && !defined(STBIW_FREE) && !defined(STBIW_REALLOC) && !defined(STBIW_REALLOC_SIZED) // ok #else #error "Must define all or none of STBIW_MALLOC, STBIW_FREE, and STBIW_REALLOC (or STBIW_REALLOC_SIZED)." #endif #ifndef STBIW_MALLOC #define STBIW_MALLOC(sz) malloc(sz) #define STBIW_REALLOC(p,newsz) realloc(p,newsz) #define STBIW_FREE(p) free(p) #endif #ifndef STBIW_REALLOC_SIZED #define STBIW_REALLOC_SIZED(p,oldsz,newsz) STBIW_REALLOC(p,newsz) #endif #ifndef STBIW_MEMMOVE #define STBIW_MEMMOVE(a,b,sz) memmove(a,b,sz) #endif #ifndef STBIW_ASSERT #include #define STBIW_ASSERT(x) assert(x) #endif #define STBIW_UCHAR(x) (unsigned char) ((x) & 0xff) #ifdef STB_IMAGE_WRITE_STATIC static int stbi_write_png_compression_level = 8; static int stbi_write_tga_with_rle = 1; static int stbi_write_force_png_filter = -1; #else int stbi_write_png_compression_level = 8; int stbi_write_tga_with_rle = 1; int stbi_write_force_png_filter = -1; #endif static int stbi__flip_vertically_on_write = 0; STBIWDEF void stbi_flip_vertically_on_write(int flag) { stbi__flip_vertically_on_write = flag; } typedef struct { stbi_write_func *func; void *context; unsigned char buffer[64]; int buf_used; } stbi__write_context; // initialize a callback-based context static void stbi__start_write_callbacks(stbi__write_context *s, stbi_write_func *c, void *context) { s->func = c; s->context = context; } #ifndef STBI_WRITE_NO_STDIO static void stbi__stdio_write(void *context, void *data, int size) { fwrite(data,1,size,(FILE*) context); } #if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) #ifdef __cplusplus #define STBIW_EXTERN extern "C" #else #define STBIW_EXTERN extern #endif STBIW_EXTERN __declspec(dllimport) int __stdcall MultiByteToWideChar(unsigned int cp, unsigned long flags, const char *str, int cbmb, wchar_t *widestr, int cchwide); STBIW_EXTERN __declspec(dllimport) int __stdcall WideCharToMultiByte(unsigned int cp, unsigned long flags, const wchar_t *widestr, int cchwide, char *str, int cbmb, const char *defchar, int *used_default); STBIWDEF int stbiw_convert_wchar_to_utf8(char *buffer, size_t bufferlen, const wchar_t* input) { return WideCharToMultiByte(65001 /* UTF8 */, 0, input, -1, buffer, (int) bufferlen, NULL, NULL); } #endif static FILE *stbiw__fopen(char const *filename, char const *mode) { FILE *f; #if defined(_WIN32) && defined(STBIW_WINDOWS_UTF8) wchar_t wMode[64]; wchar_t wFilename[1024]; if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, filename, -1, wFilename, sizeof(wFilename)/sizeof(*wFilename))) return 0; if (0 == MultiByteToWideChar(65001 /* UTF8 */, 0, mode, -1, wMode, sizeof(wMode)/sizeof(*wMode))) return 0; #if defined(_MSC_VER) && _MSC_VER >= 1400 if (0 != _wfopen_s(&f, wFilename, wMode)) f = 0; #else f = _wfopen(wFilename, wMode); #endif #elif defined(_MSC_VER) && _MSC_VER >= 1400 if (0 != fopen_s(&f, filename, mode)) f=0; #else f = fopen(filename, mode); #endif return f; } static int stbi__start_write_file(stbi__write_context *s, const char *filename) { FILE *f = stbiw__fopen(filename, "wb"); stbi__start_write_callbacks(s, stbi__stdio_write, (void *) f); return f != NULL; } static void stbi__end_write_file(stbi__write_context *s) { fclose((FILE *)s->context); } #endif // !STBI_WRITE_NO_STDIO typedef unsigned int stbiw_uint32; typedef int stb_image_write_test[sizeof(stbiw_uint32)==4 ? 1 : -1]; static void stbiw__writefv(stbi__write_context *s, const char *fmt, va_list v) { while (*fmt) { switch (*fmt++) { case ' ': break; case '1': { unsigned char x = STBIW_UCHAR(va_arg(v, int)); s->func(s->context,&x,1); break; } case '2': { int x = va_arg(v,int); unsigned char b[2]; b[0] = STBIW_UCHAR(x); b[1] = STBIW_UCHAR(x>>8); s->func(s->context,b,2); break; } case '4': { stbiw_uint32 x = va_arg(v,int); unsigned char b[4]; b[0]=STBIW_UCHAR(x); b[1]=STBIW_UCHAR(x>>8); b[2]=STBIW_UCHAR(x>>16); b[3]=STBIW_UCHAR(x>>24); s->func(s->context,b,4); break; } default: STBIW_ASSERT(0); return; } } } static void stbiw__writef(stbi__write_context *s, const char *fmt, ...) { va_list v; va_start(v, fmt); stbiw__writefv(s, fmt, v); va_end(v); } static void stbiw__write_flush(stbi__write_context *s) { if (s->buf_used) { s->func(s->context, &s->buffer, s->buf_used); s->buf_used = 0; } } static void stbiw__putc(stbi__write_context *s, unsigned char c) { s->func(s->context, &c, 1); } static void stbiw__write1(stbi__write_context *s, unsigned char a) { if ((size_t)s->buf_used + 1 > sizeof(s->buffer)) stbiw__write_flush(s); s->buffer[s->buf_used++] = a; } static void stbiw__write3(stbi__write_context *s, unsigned char a, unsigned char b, unsigned char c) { int n; if ((size_t)s->buf_used + 3 > sizeof(s->buffer)) stbiw__write_flush(s); n = s->buf_used; s->buf_used = n+3; s->buffer[n+0] = a; s->buffer[n+1] = b; s->buffer[n+2] = c; } static void stbiw__write_pixel(stbi__write_context *s, int rgb_dir, int comp, int write_alpha, int expand_mono, unsigned char *d) { unsigned char bg[3] = { 255, 0, 255}, px[3]; int k; if (write_alpha < 0) stbiw__write1(s, d[comp - 1]); switch (comp) { case 2: // 2 pixels = mono + alpha, alpha is written separately, so same as 1-channel case case 1: if (expand_mono) stbiw__write3(s, d[0], d[0], d[0]); // monochrome bmp else stbiw__write1(s, d[0]); // monochrome TGA break; case 4: if (!write_alpha) { // composite against pink background for (k = 0; k < 3; ++k) px[k] = bg[k] + ((d[k] - bg[k]) * d[3]) / 255; stbiw__write3(s, px[1 - rgb_dir], px[1], px[1 + rgb_dir]); break; } /* FALLTHROUGH */ case 3: stbiw__write3(s, d[1 - rgb_dir], d[1], d[1 + rgb_dir]); break; } if (write_alpha > 0) stbiw__write1(s, d[comp - 1]); } static void stbiw__write_pixels(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, void *data, int write_alpha, int scanline_pad, int expand_mono) { stbiw_uint32 zero = 0; int i,j, j_end; if (y <= 0) return; if (stbi__flip_vertically_on_write) vdir *= -1; if (vdir < 0) { j_end = -1; j = y-1; } else { j_end = y; j = 0; } for (; j != j_end; j += vdir) { for (i=0; i < x; ++i) { unsigned char *d = (unsigned char *) data + (j*x+i)*comp; stbiw__write_pixel(s, rgb_dir, comp, write_alpha, expand_mono, d); } stbiw__write_flush(s); s->func(s->context, &zero, scanline_pad); } } static int stbiw__outfile(stbi__write_context *s, int rgb_dir, int vdir, int x, int y, int comp, int expand_mono, void *data, int alpha, int pad, const char *fmt, ...) { if (y < 0 || x < 0) { return 0; } else { va_list v; va_start(v, fmt); stbiw__writefv(s, fmt, v); va_end(v); stbiw__write_pixels(s,rgb_dir,vdir,x,y,comp,data,alpha,pad, expand_mono); return 1; } } static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data) { if (comp != 4) { // write RGB bitmap int pad = (-x*3) & 3; return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad, "11 4 22 4" "4 44 22 444444", 'B', 'M', 14+40+(x*3+pad)*y, 0,0, 14+40, // file header 40, x,y, 1,24, 0,0,0,0,0,0); // bitmap header } else { // RGBA bitmaps need a v4 header // use BI_BITFIELDS mode with 32bpp and alpha mask // (straight BI_RGB with alpha mask doesn't work in most readers) return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *)data,1,0, "11 4 22 4" "4 44 22 444444 4444 4 444 444 444 444", 'B', 'M', 14+108+x*y*4, 0, 0, 14+108, // file header 108, x,y, 1,32, 3,0,0,0,0,0, 0xff0000,0xff00,0xff,0xff000000u, 0, 0,0,0, 0,0,0, 0,0,0, 0,0,0); // bitmap V4 header } } STBIWDEF int stbi_write_bmp_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) { stbi__write_context s = { 0 }; stbi__start_write_callbacks(&s, func, context); return stbi_write_bmp_core(&s, x, y, comp, data); } #ifndef STBI_WRITE_NO_STDIO STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data) { stbi__write_context s = { 0 }; if (stbi__start_write_file(&s,filename)) { int r = stbi_write_bmp_core(&s, x, y, comp, data); stbi__end_write_file(&s); return r; } else return 0; } #endif //!STBI_WRITE_NO_STDIO static int stbi_write_tga_core(stbi__write_context *s, int x, int y, int comp, void *data) { int has_alpha = (comp == 2 || comp == 4); int colorbytes = has_alpha ? comp-1 : comp; int format = colorbytes < 2 ? 3 : 2; // 3 color channels (RGB/RGBA) = 2, 1 color channel (Y/YA) = 3 if (y < 0 || x < 0) return 0; if (!stbi_write_tga_with_rle) { return stbiw__outfile(s, -1, -1, x, y, comp, 0, (void *) data, has_alpha, 0, "111 221 2222 11", 0, 0, format, 0, 0, 0, 0, 0, x, y, (colorbytes + has_alpha) * 8, has_alpha * 8); } else { int i,j,k; int jend, jdir; stbiw__writef(s, "111 221 2222 11", 0,0,format+8, 0,0,0, 0,0,x,y, (colorbytes + has_alpha) * 8, has_alpha * 8); if (stbi__flip_vertically_on_write) { j = 0; jend = y; jdir = 1; } else { j = y-1; jend = -1; jdir = -1; } for (; j != jend; j += jdir) { unsigned char *row = (unsigned char *) data + j * x * comp; int len; for (i = 0; i < x; i += len) { unsigned char *begin = row + i * comp; int diff = 1; len = 1; if (i < x - 1) { ++len; diff = memcmp(begin, row + (i + 1) * comp, comp); if (diff) { const unsigned char *prev = begin; for (k = i + 2; k < x && len < 128; ++k) { if (memcmp(prev, row + k * comp, comp)) { prev += comp; ++len; } else { --len; break; } } } else { for (k = i + 2; k < x && len < 128; ++k) { if (!memcmp(begin, row + k * comp, comp)) { ++len; } else { break; } } } } if (diff) { unsigned char header = STBIW_UCHAR(len - 1); stbiw__write1(s, header); for (k = 0; k < len; ++k) { stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin + k * comp); } } else { unsigned char header = STBIW_UCHAR(len - 129); stbiw__write1(s, header); stbiw__write_pixel(s, -1, comp, has_alpha, 0, begin); } } } stbiw__write_flush(s); } return 1; } STBIWDEF int stbi_write_tga_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data) { stbi__write_context s = { 0 }; stbi__start_write_callbacks(&s, func, context); return stbi_write_tga_core(&s, x, y, comp, (void *) data); } #ifndef STBI_WRITE_NO_STDIO STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data) { stbi__write_context s = { 0 }; if (stbi__start_write_file(&s,filename)) { int r = stbi_write_tga_core(&s, x, y, comp, (void *) data); stbi__end_write_file(&s); return r; } else return 0; } #endif // ************************************************************************************************* // Radiance RGBE HDR writer // by Baldur Karlsson #define stbiw__max(a, b) ((a) > (b) ? (a) : (b)) #ifndef STBI_WRITE_NO_STDIO static void stbiw__linear_to_rgbe(unsigned char *rgbe, float *linear) { int exponent; float maxcomp = stbiw__max(linear[0], stbiw__max(linear[1], linear[2])); if (maxcomp < 1e-32f) { rgbe[0] = rgbe[1] = rgbe[2] = rgbe[3] = 0; } else { float normalize = (float) frexp(maxcomp, &exponent) * 256.0f/maxcomp; rgbe[0] = (unsigned char)(linear[0] * normalize); rgbe[1] = (unsigned char)(linear[1] * normalize); rgbe[2] = (unsigned char)(linear[2] * normalize); rgbe[3] = (unsigned char)(exponent + 128); } } static void stbiw__write_run_data(stbi__write_context *s, int length, unsigned char databyte) { unsigned char lengthbyte = STBIW_UCHAR(length+128); STBIW_ASSERT(length+128 <= 255); s->func(s->context, &lengthbyte, 1); s->func(s->context, &databyte, 1); } static void stbiw__write_dump_data(stbi__write_context *s, int length, unsigned char *data) { unsigned char lengthbyte = STBIW_UCHAR(length); STBIW_ASSERT(length <= 128); // inconsistent with spec but consistent with official code s->func(s->context, &lengthbyte, 1); s->func(s->context, data, length); } static void stbiw__write_hdr_scanline(stbi__write_context *s, int width, int ncomp, unsigned char *scratch, float *scanline) { unsigned char scanlineheader[4] = { 2, 2, 0, 0 }; unsigned char rgbe[4]; float linear[3]; int x; scanlineheader[2] = (width&0xff00)>>8; scanlineheader[3] = (width&0x00ff); /* skip RLE for images too small or large */ if (width < 8 || width >= 32768) { for (x=0; x < width; x++) { switch (ncomp) { case 4: /* fallthrough */ case 3: linear[2] = scanline[x*ncomp + 2]; linear[1] = scanline[x*ncomp + 1]; linear[0] = scanline[x*ncomp + 0]; break; default: linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; break; } stbiw__linear_to_rgbe(rgbe, linear); s->func(s->context, rgbe, 4); } } else { int c,r; /* encode into scratch buffer */ for (x=0; x < width; x++) { switch(ncomp) { case 4: /* fallthrough */ case 3: linear[2] = scanline[x*ncomp + 2]; linear[1] = scanline[x*ncomp + 1]; linear[0] = scanline[x*ncomp + 0]; break; default: linear[0] = linear[1] = linear[2] = scanline[x*ncomp + 0]; break; } stbiw__linear_to_rgbe(rgbe, linear); scratch[x + width*0] = rgbe[0]; scratch[x + width*1] = rgbe[1]; scratch[x + width*2] = rgbe[2]; scratch[x + width*3] = rgbe[3]; } s->func(s->context, scanlineheader, 4); /* RLE each component separately */ for (c=0; c < 4; c++) { unsigned char *comp = &scratch[width*c]; x = 0; while (x < width) { // find first run r = x; while (r+2 < width) { if (comp[r] == comp[r+1] && comp[r] == comp[r+2]) break; ++r; } if (r+2 >= width) r = width; // dump up to first run while (x < r) { int len = r-x; if (len > 128) len = 128; stbiw__write_dump_data(s, len, &comp[x]); x += len; } // if there's a run, output it if (r+2 < width) { // same test as what we break out of in search loop, so only true if we break'd // find next byte after run while (r < width && comp[r] == comp[x]) ++r; // output run up to r while (x < r) { int len = r-x; if (len > 127) len = 127; stbiw__write_run_data(s, len, comp[x]); x += len; } } } } } } static int stbi_write_hdr_core(stbi__write_context *s, int x, int y, int comp, float *data) { if (y <= 0 || x <= 0 || data == NULL) return 0; else { // Each component is stored separately. Allocate scratch space for full output scanline. unsigned char *scratch = (unsigned char *) STBIW_MALLOC(x*4); int i, len; char buffer[128]; char header[] = "#?RADIANCE\n# Written by stb_image_write.h\nFORMAT=32-bit_rle_rgbe\n"; s->func(s->context, header, sizeof(header)-1); #ifdef __STDC_LIB_EXT1__ len = sprintf_s(buffer, sizeof(buffer), "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); #else len = sprintf(buffer, "EXPOSURE= 1.0000000000000\n\n-Y %d +X %d\n", y, x); #endif s->func(s->context, buffer, len); for(i=0; i < y; i++) stbiw__write_hdr_scanline(s, x, comp, scratch, data + comp*x*(stbi__flip_vertically_on_write ? y-1-i : i)); STBIW_FREE(scratch); return 1; } } STBIWDEF int stbi_write_hdr_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const float *data) { stbi__write_context s = { 0 }; stbi__start_write_callbacks(&s, func, context); return stbi_write_hdr_core(&s, x, y, comp, (float *) data); } STBIWDEF int stbi_write_hdr(char const *filename, int x, int y, int comp, const float *data) { stbi__write_context s = { 0 }; if (stbi__start_write_file(&s,filename)) { int r = stbi_write_hdr_core(&s, x, y, comp, (float *) data); stbi__end_write_file(&s); return r; } else return 0; } #endif // STBI_WRITE_NO_STDIO ////////////////////////////////////////////////////////////////////////////// // // PNG writer // #ifndef STBIW_ZLIB_COMPRESS // stretchy buffer; stbiw__sbpush() == vector<>::push_back() -- stbiw__sbcount() == vector<>::size() #define stbiw__sbraw(a) ((int *) (void *) (a) - 2) #define stbiw__sbm(a) stbiw__sbraw(a)[0] #define stbiw__sbn(a) stbiw__sbraw(a)[1] #define stbiw__sbneedgrow(a,n) ((a)==0 || stbiw__sbn(a)+n >= stbiw__sbm(a)) #define stbiw__sbmaybegrow(a,n) (stbiw__sbneedgrow(a,(n)) ? stbiw__sbgrow(a,n) : 0) #define stbiw__sbgrow(a,n) stbiw__sbgrowf((void **) &(a), (n), sizeof(*(a))) #define stbiw__sbpush(a, v) (stbiw__sbmaybegrow(a,1), (a)[stbiw__sbn(a)++] = (v)) #define stbiw__sbcount(a) ((a) ? stbiw__sbn(a) : 0) #define stbiw__sbfree(a) ((a) ? STBIW_FREE(stbiw__sbraw(a)),0 : 0) static void *stbiw__sbgrowf(void **arr, int increment, int itemsize) { int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1; void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2); STBIW_ASSERT(p); if (p) { if (!*arr) ((int *) p)[1] = 0; *arr = (void *) ((int *) p + 2); stbiw__sbm(*arr) = m; } return *arr; } static unsigned char *stbiw__zlib_flushf(unsigned char *data, unsigned int *bitbuffer, int *bitcount) { while (*bitcount >= 8) { stbiw__sbpush(data, STBIW_UCHAR(*bitbuffer)); *bitbuffer >>= 8; *bitcount -= 8; } return data; } static int stbiw__zlib_bitrev(int code, int codebits) { int res=0; while (codebits--) { res = (res << 1) | (code & 1); code >>= 1; } return res; } static unsigned int stbiw__zlib_countm(unsigned char *a, unsigned char *b, int limit) { int i; for (i=0; i < limit && i < 258; ++i) if (a[i] != b[i]) break; return i; } static unsigned int stbiw__zhash(unsigned char *data) { stbiw_uint32 hash = data[0] + (data[1] << 8) + (data[2] << 16); hash ^= hash << 3; hash += hash >> 5; hash ^= hash << 4; hash += hash >> 17; hash ^= hash << 25; hash += hash >> 6; return hash; } #define stbiw__zlib_flush() (out = stbiw__zlib_flushf(out, &bitbuf, &bitcount)) #define stbiw__zlib_add(code,codebits) \ (bitbuf |= (code) << bitcount, bitcount += (codebits), stbiw__zlib_flush()) #define stbiw__zlib_huffa(b,c) stbiw__zlib_add(stbiw__zlib_bitrev(b,c),c) // default huffman tables #define stbiw__zlib_huff1(n) stbiw__zlib_huffa(0x30 + (n), 8) #define stbiw__zlib_huff2(n) stbiw__zlib_huffa(0x190 + (n)-144, 9) #define stbiw__zlib_huff3(n) stbiw__zlib_huffa(0 + (n)-256,7) #define stbiw__zlib_huff4(n) stbiw__zlib_huffa(0xc0 + (n)-280,8) #define stbiw__zlib_huff(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : (n) <= 255 ? stbiw__zlib_huff2(n) : (n) <= 279 ? stbiw__zlib_huff3(n) : stbiw__zlib_huff4(n)) #define stbiw__zlib_huffb(n) ((n) <= 143 ? stbiw__zlib_huff1(n) : stbiw__zlib_huff2(n)) #define stbiw__ZHASH 16384 #endif // STBIW_ZLIB_COMPRESS STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality) { #ifdef STBIW_ZLIB_COMPRESS // user provided a zlib compress implementation, use that return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality); #else // use builtin static unsigned short lengthc[] = { 3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258, 259 }; static unsigned char lengtheb[]= { 0,0,0,0,0,0,0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 }; static unsigned short distc[] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577, 32768 }; static unsigned char disteb[] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 }; unsigned int bitbuf=0; int i,j, bitcount=0; unsigned char *out = NULL; unsigned char ***hash_table = (unsigned char***) STBIW_MALLOC(stbiw__ZHASH * sizeof(unsigned char**)); if (hash_table == NULL) return NULL; if (quality < 5) quality = 5; stbiw__sbpush(out, 0x78); // DEFLATE 32K window stbiw__sbpush(out, 0x5e); // FLEVEL = 1 stbiw__zlib_add(1,1); // BFINAL = 1 stbiw__zlib_add(1,2); // BTYPE = 1 -- fixed huffman for (i=0; i < stbiw__ZHASH; ++i) hash_table[i] = NULL; i=0; while (i < data_len-3) { // hash next 3 bytes of data to be compressed int h = stbiw__zhash(data+i)&(stbiw__ZHASH-1), best=3; unsigned char *bestloc = 0; unsigned char **hlist = hash_table[h]; int n = stbiw__sbcount(hlist); for (j=0; j < n; ++j) { if (hlist[j]-data > i-32768) { // if entry lies within window int d = stbiw__zlib_countm(hlist[j], data+i, data_len-i); if (d >= best) { best=d; bestloc=hlist[j]; } } } // when hash table entry is too long, delete half the entries if (hash_table[h] && stbiw__sbn(hash_table[h]) == 2*quality) { STBIW_MEMMOVE(hash_table[h], hash_table[h]+quality, sizeof(hash_table[h][0])*quality); stbiw__sbn(hash_table[h]) = quality; } stbiw__sbpush(hash_table[h],data+i); if (bestloc) { // "lazy matching" - check match at *next* byte, and if it's better, do cur byte as literal h = stbiw__zhash(data+i+1)&(stbiw__ZHASH-1); hlist = hash_table[h]; n = stbiw__sbcount(hlist); for (j=0; j < n; ++j) { if (hlist[j]-data > i-32767) { int e = stbiw__zlib_countm(hlist[j], data+i+1, data_len-i-1); if (e > best) { // if next match is better, bail on current match bestloc = NULL; break; } } } } if (bestloc) { int d = (int) (data+i - bestloc); // distance back STBIW_ASSERT(d <= 32767 && best <= 258); for (j=0; best > lengthc[j+1]-1; ++j); stbiw__zlib_huff(j+257); if (lengtheb[j]) stbiw__zlib_add(best - lengthc[j], lengtheb[j]); for (j=0; d > distc[j+1]-1; ++j); stbiw__zlib_add(stbiw__zlib_bitrev(j,5),5); if (disteb[j]) stbiw__zlib_add(d - distc[j], disteb[j]); i += best; } else { stbiw__zlib_huffb(data[i]); ++i; } } // write out final bytes for (;i < data_len; ++i) stbiw__zlib_huffb(data[i]); stbiw__zlib_huff(256); // end of block // pad with 0 bits to byte boundary while (bitcount) stbiw__zlib_add(0,1); for (i=0; i < stbiw__ZHASH; ++i) (void) stbiw__sbfree(hash_table[i]); STBIW_FREE(hash_table); // store uncompressed instead if compression was worse if (stbiw__sbn(out) > data_len + 2 + ((data_len+32766)/32767)*5) { stbiw__sbn(out) = 2; // truncate to DEFLATE 32K window and FLEVEL = 1 for (j = 0; j < data_len;) { int blocklen = data_len - j; if (blocklen > 32767) blocklen = 32767; stbiw__sbpush(out, data_len - j == blocklen); // BFINAL = ?, BTYPE = 0 -- no compression stbiw__sbpush(out, STBIW_UCHAR(blocklen)); // LEN stbiw__sbpush(out, STBIW_UCHAR(blocklen >> 8)); stbiw__sbpush(out, STBIW_UCHAR(~blocklen)); // NLEN stbiw__sbpush(out, STBIW_UCHAR(~blocklen >> 8)); memcpy(out+stbiw__sbn(out), data+j, blocklen); stbiw__sbn(out) += blocklen; j += blocklen; } } { // compute adler32 on input unsigned int s1=1, s2=0; int blocklen = (int) (data_len % 5552); j=0; while (j < data_len) { for (i=0; i < blocklen; ++i) { s1 += data[j+i]; s2 += s1; } s1 %= 65521; s2 %= 65521; j += blocklen; blocklen = 5552; } stbiw__sbpush(out, STBIW_UCHAR(s2 >> 8)); stbiw__sbpush(out, STBIW_UCHAR(s2)); stbiw__sbpush(out, STBIW_UCHAR(s1 >> 8)); stbiw__sbpush(out, STBIW_UCHAR(s1)); } *out_len = stbiw__sbn(out); // make returned pointer freeable STBIW_MEMMOVE(stbiw__sbraw(out), out, *out_len); return (unsigned char *) stbiw__sbraw(out); #endif // STBIW_ZLIB_COMPRESS } static unsigned int stbiw__crc32(unsigned char *buffer, int len) { #ifdef STBIW_CRC32 return STBIW_CRC32(buffer, len); #else static unsigned int crc_table[256] = { 0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0eDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D }; unsigned int crc = ~0u; int i; for (i=0; i < len; ++i) crc = (crc >> 8) ^ crc_table[buffer[i] ^ (crc & 0xff)]; return ~crc; #endif } #define stbiw__wpng4(o,a,b,c,d) ((o)[0]=STBIW_UCHAR(a),(o)[1]=STBIW_UCHAR(b),(o)[2]=STBIW_UCHAR(c),(o)[3]=STBIW_UCHAR(d),(o)+=4) #define stbiw__wp32(data,v) stbiw__wpng4(data, (v)>>24,(v)>>16,(v)>>8,(v)); #define stbiw__wptag(data,s) stbiw__wpng4(data, s[0],s[1],s[2],s[3]) static void stbiw__wpcrc(unsigned char **data, int len) { unsigned int crc = stbiw__crc32(*data - len - 4, len+4); stbiw__wp32(*data, crc); } static unsigned char stbiw__paeth(int a, int b, int c) { int p = a + b - c, pa = abs(p-a), pb = abs(p-b), pc = abs(p-c); if (pa <= pb && pa <= pc) return STBIW_UCHAR(a); if (pb <= pc) return STBIW_UCHAR(b); return STBIW_UCHAR(c); } // @OPTIMIZE: provide an option that always forces left-predict or paeth predict static void stbiw__encode_png_line(unsigned char *pixels, int stride_bytes, int width, int height, int y, int n, int filter_type, signed char *line_buffer) { static int mapping[] = { 0,1,2,3,4 }; static int firstmap[] = { 0,1,0,5,6 }; int *mymap = (y != 0) ? mapping : firstmap; int i; int type = mymap[filter_type]; unsigned char *z = pixels + stride_bytes * (stbi__flip_vertically_on_write ? height-1-y : y); int signed_stride = stbi__flip_vertically_on_write ? -stride_bytes : stride_bytes; if (type==0) { memcpy(line_buffer, z, width*n); return; } // first loop isn't optimized since it's just one pixel for (i = 0; i < n; ++i) { switch (type) { case 1: line_buffer[i] = z[i]; break; case 2: line_buffer[i] = z[i] - z[i-signed_stride]; break; case 3: line_buffer[i] = z[i] - (z[i-signed_stride]>>1); break; case 4: line_buffer[i] = (signed char) (z[i] - stbiw__paeth(0,z[i-signed_stride],0)); break; case 5: line_buffer[i] = z[i]; break; case 6: line_buffer[i] = z[i]; break; } } switch (type) { case 1: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-n]; break; case 2: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - z[i-signed_stride]; break; case 3: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - ((z[i-n] + z[i-signed_stride])>>1); break; case 4: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], z[i-signed_stride], z[i-signed_stride-n]); break; case 5: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - (z[i-n]>>1); break; case 6: for (i=n; i < width*n; ++i) line_buffer[i] = z[i] - stbiw__paeth(z[i-n], 0,0); break; } } STBIWDEF unsigned char *stbi_write_png_to_mem(const unsigned char *pixels, int stride_bytes, int x, int y, int n, int *out_len) { int force_filter = stbi_write_force_png_filter; int ctype[5] = { -1, 0, 4, 2, 6 }; unsigned char sig[8] = { 137,80,78,71,13,10,26,10 }; unsigned char *out,*o, *filt, *zlib; signed char *line_buffer; int j,zlen; if (stride_bytes == 0) stride_bytes = x * n; if (force_filter >= 5) { force_filter = -1; } filt = (unsigned char *) STBIW_MALLOC((x*n+1) * y); if (!filt) return 0; line_buffer = (signed char *) STBIW_MALLOC(x * n); if (!line_buffer) { STBIW_FREE(filt); return 0; } for (j=0; j < y; ++j) { int filter_type; if (force_filter > -1) { filter_type = force_filter; stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, force_filter, line_buffer); } else { // Estimate the best filter by running through all of them: int best_filter = 0, best_filter_val = 0x7fffffff, est, i; for (filter_type = 0; filter_type < 5; filter_type++) { stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, filter_type, line_buffer); // Estimate the entropy of the line using this filter; the less, the better. est = 0; for (i = 0; i < x*n; ++i) { est += abs((signed char) line_buffer[i]); } if (est < best_filter_val) { best_filter_val = est; best_filter = filter_type; } } if (filter_type != best_filter) { // If the last iteration already got us the best filter, don't redo it stbiw__encode_png_line((unsigned char*)(pixels), stride_bytes, x, y, j, n, best_filter, line_buffer); filter_type = best_filter; } } // when we get here, filter_type contains the filter type, and line_buffer contains the data filt[j*(x*n+1)] = (unsigned char) filter_type; STBIW_MEMMOVE(filt+j*(x*n+1)+1, line_buffer, x*n); } STBIW_FREE(line_buffer); zlib = stbi_zlib_compress(filt, y*( x*n+1), &zlen, stbi_write_png_compression_level); STBIW_FREE(filt); if (!zlib) return 0; // each tag requires 12 bytes of overhead out = (unsigned char *) STBIW_MALLOC(8 + 12+13 + 12+zlen + 12); if (!out) return 0; *out_len = 8 + 12+13 + 12+zlen + 12; o=out; STBIW_MEMMOVE(o,sig,8); o+= 8; stbiw__wp32(o, 13); // header length stbiw__wptag(o, "IHDR"); stbiw__wp32(o, x); stbiw__wp32(o, y); *o++ = 8; *o++ = STBIW_UCHAR(ctype[n]); *o++ = 0; *o++ = 0; *o++ = 0; stbiw__wpcrc(&o,13); stbiw__wp32(o, zlen); stbiw__wptag(o, "IDAT"); STBIW_MEMMOVE(o, zlib, zlen); o += zlen; STBIW_FREE(zlib); stbiw__wpcrc(&o, zlen); stbiw__wp32(o,0); stbiw__wptag(o, "IEND"); stbiw__wpcrc(&o,0); STBIW_ASSERT(o == out + *out_len); return out; } #ifndef STBI_WRITE_NO_STDIO STBIWDEF int stbi_write_png(char const *filename, int x, int y, int comp, const void *data, int stride_bytes) { FILE *f; int len; unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); if (png == NULL) return 0; f = stbiw__fopen(filename, "wb"); if (!f) { STBIW_FREE(png); return 0; } fwrite(png, 1, len, f); fclose(f); STBIW_FREE(png); return 1; } #endif STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes) { int len; unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len); if (png == NULL) return 0; func(context, png, len); STBIW_FREE(png); return 1; } /* *************************************************************************** * * JPEG writer * * This is based on Jon Olick's jo_jpeg.cpp: * public domain Simple, Minimalistic JPEG writer - http://www.jonolick.com/code.html */ static const unsigned char stbiw__jpg_ZigZag[] = { 0,1,5,6,14,15,27,28,2,4,7,13,16,26,29,42,3,8,12,17,25,30,41,43,9,11,18, 24,31,40,44,53,10,19,23,32,39,45,52,54,20,22,33,38,46,51,55,60,21,34,37,47,50,56,59,61,35,36,48,49,57,58,62,63 }; static void stbiw__jpg_writeBits(stbi__write_context *s, int *bitBufP, int *bitCntP, const unsigned short *bs) { int bitBuf = *bitBufP, bitCnt = *bitCntP; bitCnt += bs[1]; bitBuf |= bs[0] << (24 - bitCnt); while(bitCnt >= 8) { unsigned char c = (bitBuf >> 16) & 255; stbiw__putc(s, c); if(c == 255) { stbiw__putc(s, 0); } bitBuf <<= 8; bitCnt -= 8; } *bitBufP = bitBuf; *bitCntP = bitCnt; } static void stbiw__jpg_DCT(float *d0p, float *d1p, float *d2p, float *d3p, float *d4p, float *d5p, float *d6p, float *d7p) { float d0 = *d0p, d1 = *d1p, d2 = *d2p, d3 = *d3p, d4 = *d4p, d5 = *d5p, d6 = *d6p, d7 = *d7p; float z1, z2, z3, z4, z5, z11, z13; float tmp0 = d0 + d7; float tmp7 = d0 - d7; float tmp1 = d1 + d6; float tmp6 = d1 - d6; float tmp2 = d2 + d5; float tmp5 = d2 - d5; float tmp3 = d3 + d4; float tmp4 = d3 - d4; // Even part float tmp10 = tmp0 + tmp3; // phase 2 float tmp13 = tmp0 - tmp3; float tmp11 = tmp1 + tmp2; float tmp12 = tmp1 - tmp2; d0 = tmp10 + tmp11; // phase 3 d4 = tmp10 - tmp11; z1 = (tmp12 + tmp13) * 0.707106781f; // c4 d2 = tmp13 + z1; // phase 5 d6 = tmp13 - z1; // Odd part tmp10 = tmp4 + tmp5; // phase 2 tmp11 = tmp5 + tmp6; tmp12 = tmp6 + tmp7; // The rotator is modified from fig 4-8 to avoid extra negations. z5 = (tmp10 - tmp12) * 0.382683433f; // c6 z2 = tmp10 * 0.541196100f + z5; // c2-c6 z4 = tmp12 * 1.306562965f + z5; // c2+c6 z3 = tmp11 * 0.707106781f; // c4 z11 = tmp7 + z3; // phase 5 z13 = tmp7 - z3; *d5p = z13 + z2; // phase 6 *d3p = z13 - z2; *d1p = z11 + z4; *d7p = z11 - z4; *d0p = d0; *d2p = d2; *d4p = d4; *d6p = d6; } static void stbiw__jpg_calcBits(int val, unsigned short bits[2]) { int tmp1 = val < 0 ? -val : val; val = val < 0 ? val-1 : val; bits[1] = 1; while(tmp1 >>= 1) { ++bits[1]; } bits[0] = val & ((1<0)&&(DU[end0pos]==0); --end0pos) { } // end0pos = first element in reverse order !=0 if(end0pos == 0) { stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); return DU[0]; } for(i = 1; i <= end0pos; ++i) { int startpos = i; int nrzeroes; unsigned short bits[2]; for (; DU[i]==0 && i<=end0pos; ++i) { } nrzeroes = i-startpos; if ( nrzeroes >= 16 ) { int lng = nrzeroes>>4; int nrmarker; for (nrmarker=1; nrmarker <= lng; ++nrmarker) stbiw__jpg_writeBits(s, bitBuf, bitCnt, M16zeroes); nrzeroes &= 15; } stbiw__jpg_calcBits(DU[i], bits); stbiw__jpg_writeBits(s, bitBuf, bitCnt, HTAC[(nrzeroes<<4)+bits[1]]); stbiw__jpg_writeBits(s, bitBuf, bitCnt, bits); } if(end0pos != 63) { stbiw__jpg_writeBits(s, bitBuf, bitCnt, EOB); } return DU[0]; } static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) { // Constants that don't pollute global namespace static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0}; static const unsigned char std_dc_luminance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; static const unsigned char std_ac_luminance_nrcodes[] = {0,0,2,1,3,3,2,4,3,5,5,4,4,0,0,1,0x7d}; static const unsigned char std_ac_luminance_values[] = { 0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08, 0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28, 0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59, 0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89, 0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6, 0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2, 0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa }; static const unsigned char std_dc_chrominance_nrcodes[] = {0,0,3,1,1,1,1,1,1,1,1,1,0,0,0,0,0}; static const unsigned char std_dc_chrominance_values[] = {0,1,2,3,4,5,6,7,8,9,10,11}; static const unsigned char std_ac_chrominance_nrcodes[] = {0,0,2,1,2,4,4,3,4,7,5,4,4,0,1,2,0x77}; static const unsigned char std_ac_chrominance_values[] = { 0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91, 0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26, 0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58, 0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87, 0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4, 0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda, 0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,0xf5,0xf6,0xf7,0xf8,0xf9,0xfa }; // Huffman tables static const unsigned short YDC_HT[256][2] = { {0,2},{2,3},{3,3},{4,3},{5,3},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9}}; static const unsigned short UVDC_HT[256][2] = { {0,2},{1,2},{2,2},{6,3},{14,4},{30,5},{62,6},{126,7},{254,8},{510,9},{1022,10},{2046,11}}; static const unsigned short YAC_HT[256][2] = { {10,4},{0,2},{1,2},{4,3},{11,4},{26,5},{120,7},{248,8},{1014,10},{65410,16},{65411,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {12,4},{27,5},{121,7},{502,9},{2038,11},{65412,16},{65413,16},{65414,16},{65415,16},{65416,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {28,5},{249,8},{1015,10},{4084,12},{65417,16},{65418,16},{65419,16},{65420,16},{65421,16},{65422,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {58,6},{503,9},{4085,12},{65423,16},{65424,16},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {59,6},{1016,10},{65430,16},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {122,7},{2039,11},{65438,16},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {123,7},{4086,12},{65446,16},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {250,8},{4087,12},{65454,16},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {504,9},{32704,15},{65462,16},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {505,9},{65470,16},{65471,16},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {506,9},{65479,16},{65480,16},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {1017,10},{65488,16},{65489,16},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {1018,10},{65497,16},{65498,16},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {2040,11},{65506,16},{65507,16},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {65515,16},{65516,16},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{0,0},{0,0},{0,0},{0,0},{0,0}, {2041,11},{65525,16},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} }; static const unsigned short UVAC_HT[256][2] = { {0,2},{1,2},{4,3},{10,4},{24,5},{25,5},{56,6},{120,7},{500,9},{1014,10},{4084,12},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {11,4},{57,6},{246,8},{501,9},{2038,11},{4085,12},{65416,16},{65417,16},{65418,16},{65419,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {26,5},{247,8},{1015,10},{4086,12},{32706,15},{65420,16},{65421,16},{65422,16},{65423,16},{65424,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {27,5},{248,8},{1016,10},{4087,12},{65425,16},{65426,16},{65427,16},{65428,16},{65429,16},{65430,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {58,6},{502,9},{65431,16},{65432,16},{65433,16},{65434,16},{65435,16},{65436,16},{65437,16},{65438,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {59,6},{1017,10},{65439,16},{65440,16},{65441,16},{65442,16},{65443,16},{65444,16},{65445,16},{65446,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {121,7},{2039,11},{65447,16},{65448,16},{65449,16},{65450,16},{65451,16},{65452,16},{65453,16},{65454,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {122,7},{2040,11},{65455,16},{65456,16},{65457,16},{65458,16},{65459,16},{65460,16},{65461,16},{65462,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {249,8},{65463,16},{65464,16},{65465,16},{65466,16},{65467,16},{65468,16},{65469,16},{65470,16},{65471,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {503,9},{65472,16},{65473,16},{65474,16},{65475,16},{65476,16},{65477,16},{65478,16},{65479,16},{65480,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {504,9},{65481,16},{65482,16},{65483,16},{65484,16},{65485,16},{65486,16},{65487,16},{65488,16},{65489,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {505,9},{65490,16},{65491,16},{65492,16},{65493,16},{65494,16},{65495,16},{65496,16},{65497,16},{65498,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {506,9},{65499,16},{65500,16},{65501,16},{65502,16},{65503,16},{65504,16},{65505,16},{65506,16},{65507,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {2041,11},{65508,16},{65509,16},{65510,16},{65511,16},{65512,16},{65513,16},{65514,16},{65515,16},{65516,16},{0,0},{0,0},{0,0},{0,0},{0,0},{0,0}, {16352,14},{65517,16},{65518,16},{65519,16},{65520,16},{65521,16},{65522,16},{65523,16},{65524,16},{65525,16},{0,0},{0,0},{0,0},{0,0},{0,0}, {1018,10},{32707,15},{65526,16},{65527,16},{65528,16},{65529,16},{65530,16},{65531,16},{65532,16},{65533,16},{65534,16},{0,0},{0,0},{0,0},{0,0},{0,0} }; static const int YQT[] = {16,11,10,16,24,40,51,61,12,12,14,19,26,58,60,55,14,13,16,24,40,57,69,56,14,17,22,29,51,87,80,62,18,22, 37,56,68,109,103,77,24,35,55,64,81,104,113,92,49,64,78,87,103,121,120,101,72,92,95,98,112,100,103,99}; static const int UVQT[] = {17,18,24,47,99,99,99,99,18,21,26,66,99,99,99,99,24,26,56,99,99,99,99,99,47,66,99,99,99,99,99,99, 99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99}; static const float aasf[] = { 1.0f * 2.828427125f, 1.387039845f * 2.828427125f, 1.306562965f * 2.828427125f, 1.175875602f * 2.828427125f, 1.0f * 2.828427125f, 0.785694958f * 2.828427125f, 0.541196100f * 2.828427125f, 0.275899379f * 2.828427125f }; int row, col, i, k, subsample; float fdtbl_Y[64], fdtbl_UV[64]; unsigned char YTable[64], UVTable[64]; if(!data || !width || !height || comp > 4 || comp < 1) { return 0; } quality = quality ? quality : 90; subsample = quality <= 90 ? 1 : 0; quality = quality < 1 ? 1 : quality > 100 ? 100 : quality; quality = quality < 50 ? 5000 / quality : 200 - quality * 2; for(i = 0; i < 64; ++i) { int uvti, yti = (YQT[i]*quality+50)/100; YTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (yti < 1 ? 1 : yti > 255 ? 255 : yti); uvti = (UVQT[i]*quality+50)/100; UVTable[stbiw__jpg_ZigZag[i]] = (unsigned char) (uvti < 1 ? 1 : uvti > 255 ? 255 : uvti); } for(row = 0, k = 0; row < 8; ++row) { for(col = 0; col < 8; ++col, ++k) { fdtbl_Y[k] = 1 / (YTable [stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); fdtbl_UV[k] = 1 / (UVTable[stbiw__jpg_ZigZag[k]] * aasf[row] * aasf[col]); } } // Write Headers { static const unsigned char head0[] = { 0xFF,0xD8,0xFF,0xE0,0,0x10,'J','F','I','F',0,1,1,0,0,1,0,1,0,0,0xFF,0xDB,0,0x84,0 }; static const unsigned char head2[] = { 0xFF,0xDA,0,0xC,3,1,0,2,0x11,3,0x11,0,0x3F,0 }; const unsigned char head1[] = { 0xFF,0xC0,0,0x11,8,(unsigned char)(height>>8),STBIW_UCHAR(height),(unsigned char)(width>>8),STBIW_UCHAR(width), 3,1,(unsigned char)(subsample?0x22:0x11),0,2,0x11,1,3,0x11,1,0xFF,0xC4,0x01,0xA2,0 }; s->func(s->context, (void*)head0, sizeof(head0)); s->func(s->context, (void*)YTable, sizeof(YTable)); stbiw__putc(s, 1); s->func(s->context, UVTable, sizeof(UVTable)); s->func(s->context, (void*)head1, sizeof(head1)); s->func(s->context, (void*)(std_dc_luminance_nrcodes+1), sizeof(std_dc_luminance_nrcodes)-1); s->func(s->context, (void*)std_dc_luminance_values, sizeof(std_dc_luminance_values)); stbiw__putc(s, 0x10); // HTYACinfo s->func(s->context, (void*)(std_ac_luminance_nrcodes+1), sizeof(std_ac_luminance_nrcodes)-1); s->func(s->context, (void*)std_ac_luminance_values, sizeof(std_ac_luminance_values)); stbiw__putc(s, 1); // HTUDCinfo s->func(s->context, (void*)(std_dc_chrominance_nrcodes+1), sizeof(std_dc_chrominance_nrcodes)-1); s->func(s->context, (void*)std_dc_chrominance_values, sizeof(std_dc_chrominance_values)); stbiw__putc(s, 0x11); // HTUACinfo s->func(s->context, (void*)(std_ac_chrominance_nrcodes+1), sizeof(std_ac_chrominance_nrcodes)-1); s->func(s->context, (void*)std_ac_chrominance_values, sizeof(std_ac_chrominance_values)); s->func(s->context, (void*)head2, sizeof(head2)); } // Encode 8x8 macroblocks { static const unsigned short fillBits[] = {0x7F, 7}; int DCY=0, DCU=0, DCV=0; int bitBuf=0, bitCnt=0; // comp == 2 is grey+alpha (alpha is ignored) int ofsG = comp > 2 ? 1 : 0, ofsB = comp > 2 ? 2 : 0; const unsigned char *dataR = (const unsigned char *)data; const unsigned char *dataG = dataR + ofsG; const unsigned char *dataB = dataR + ofsB; int x, y, pos; if(subsample) { for(y = 0; y < height; y += 16) { for(x = 0; x < width; x += 16) { float Y[256], U[256], V[256]; for(row = y, pos = 0; row < y+16; ++row) { // row >= height => use last input row int clamped_row = (row < height) ? row : height - 1; int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; for(col = x; col < x+16; ++col, ++pos) { // if col >= width => use pixel from last input column int p = base_p + ((col < width) ? col : (width-1))*comp; float r = dataR[p], g = dataG[p], b = dataB[p]; Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; } } DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+0, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+8, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+128, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y+136, 16, fdtbl_Y, DCY, YDC_HT, YAC_HT); // subsample U,V { float subU[64], subV[64]; int yy, xx; for(yy = 0, pos = 0; yy < 8; ++yy) { for(xx = 0; xx < 8; ++xx, ++pos) { int j = yy*32+xx*2; subU[pos] = (U[j+0] + U[j+1] + U[j+16] + U[j+17]) * 0.25f; subV[pos] = (V[j+0] + V[j+1] + V[j+16] + V[j+17]) * 0.25f; } } DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subU, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, subV, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); } } } } else { for(y = 0; y < height; y += 8) { for(x = 0; x < width; x += 8) { float Y[64], U[64], V[64]; for(row = y, pos = 0; row < y+8; ++row) { // row >= height => use last input row int clamped_row = (row < height) ? row : height - 1; int base_p = (stbi__flip_vertically_on_write ? (height-1-clamped_row) : clamped_row)*width*comp; for(col = x; col < x+8; ++col, ++pos) { // if col >= width => use pixel from last input column int p = base_p + ((col < width) ? col : (width-1))*comp; float r = dataR[p], g = dataG[p], b = dataB[p]; Y[pos]= +0.29900f*r + 0.58700f*g + 0.11400f*b - 128; U[pos]= -0.16874f*r - 0.33126f*g + 0.50000f*b; V[pos]= +0.50000f*r - 0.41869f*g - 0.08131f*b; } } DCY = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, Y, 8, fdtbl_Y, DCY, YDC_HT, YAC_HT); DCU = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, U, 8, fdtbl_UV, DCU, UVDC_HT, UVAC_HT); DCV = stbiw__jpg_processDU(s, &bitBuf, &bitCnt, V, 8, fdtbl_UV, DCV, UVDC_HT, UVAC_HT); } } } // Do the bit alignment of the EOI marker stbiw__jpg_writeBits(s, &bitBuf, &bitCnt, fillBits); } // EOI stbiw__putc(s, 0xFF); stbiw__putc(s, 0xD9); return 1; } STBIWDEF int stbi_write_jpg_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int quality) { stbi__write_context s = { 0 }; stbi__start_write_callbacks(&s, func, context); return stbi_write_jpg_core(&s, x, y, comp, (void *) data, quality); } #ifndef STBI_WRITE_NO_STDIO STBIWDEF int stbi_write_jpg(char const *filename, int x, int y, int comp, const void *data, int quality) { stbi__write_context s = { 0 }; if (stbi__start_write_file(&s,filename)) { int r = stbi_write_jpg_core(&s, x, y, comp, data, quality); stbi__end_write_file(&s); return r; } else return 0; } #endif #endif // STB_IMAGE_WRITE_IMPLEMENTATION /* Revision history 1.16 (2021-07-11) make Deflate code emit uncompressed blocks when it would otherwise expand support writing BMPs with alpha channel 1.15 (2020-07-13) unknown 1.14 (2020-02-02) updated JPEG writer to downsample chroma channels 1.13 1.12 1.11 (2019-08-11) 1.10 (2019-02-07) support utf8 filenames in Windows; fix warnings and platform ifdefs 1.09 (2018-02-11) fix typo in zlib quality API, improve STB_I_W_STATIC in C++ 1.08 (2018-01-29) add stbi__flip_vertically_on_write, external zlib, zlib quality, choose PNG filter 1.07 (2017-07-24) doc fix 1.06 (2017-07-23) writing JPEG (using Jon Olick's code) 1.05 ??? 1.04 (2017-03-03) monochrome BMP expansion 1.03 ??? 1.02 (2016-04-02) avoid allocating large structures on the stack 1.01 (2016-01-16) STBIW_REALLOC_SIZED: support allocators with no realloc support avoid race-condition in crc initialization minor compile issues 1.00 (2015-09-14) installable file IO function 0.99 (2015-09-13) warning fixes; TGA rle support 0.98 (2015-04-08) added STBIW_MALLOC, STBIW_ASSERT etc 0.97 (2015-01-18) fixed HDR asserts, rewrote HDR rle logic 0.96 (2015-01-17) add HDR output fix monochrome BMP 0.95 (2014-08-17) add monochrome TGA output 0.94 (2014-05-31) rename private functions to avoid conflicts with stb_image.h 0.93 (2014-05-27) warning fixes 0.92 (2010-08-01) casts to unsigned char to fix warnings 0.91 (2010-07-17) first public release 0.90 first internal release */ /* ------------------------------------------------------------------------------ This software is available under 2 licenses -- choose whichever you prefer. ------------------------------------------------------------------------------ ALTERNATIVE A - MIT License Copyright (c) 2017 Sean Barrett Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ------------------------------------------------------------------------------ ALTERNATIVE B - Public Domain (www.unlicense.org) This is free and unencumbered software released into the public domain. Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means. In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ------------------------------------------------------------------------------ */ fsdsfdsfdsfdsf-5.13.8/extra/000077500000000000000000000000001520215207700157305ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/extra/gpu-screen-recorder.env000066400000000000000000000003701520215207700223150ustar00rootroot00000000000000WINDOW=screen CONTAINER=mp4 CODEC=h264 AUDIO_CODEC=opus AUDIO_DEVICE=default_output SECONDARY_AUDIO_DEVICE=default_input FRAMERATE=60 REPLAYDURATION=60 OUTPUTDIR=/run/media/dec05eba/SSD1TB/Videos/aaaa KEYINT=2 ENCODER=gpu RESTORE_PORTAL_SESSION=yesfsdsfdsfdsfdsf-5.13.8/extra/gpu-screen-recorder.service000066400000000000000000000023141520215207700231650ustar00rootroot00000000000000[Unit] Description=GPU Screen Recorder Service [Service] EnvironmentFile=-%h/.config/gpu-screen-recorder.env EnvironmentFile=-%h/.config/gpu-screen-recorder/gpu-screen-recorder.env Environment=WINDOW=screen Environment=CONTAINER=mp4 Environment=QUALITY=40000 Environment=BITRATE_MODE=cbr Environment=CODEC=auto Environment=AUDIO_CODEC=opus Environment=AUDIO_DEVICE=default_output Environment=SECONDARY_AUDIO_DEVICE= Environment=FRAMERATE=60 Environment=REPLAYDURATION=60 Environment=OUTPUTDIR=%h/Videos Environment=MAKEFOLDERS=no Environment=COLOR_RANGE=limited Environment=KEYINT=2 Environment=ENCODER=gpu Environment=RESTORE_PORTAL_SESSION=yes Environment=OUTPUT_RESOLUTION=0x0 Environment=ADDITIONAL_ARGS= ExecStart=gpu-screen-recorder -v no -w "${WINDOW}" -s "${OUTPUT_RESOLUTION}" -c "${CONTAINER}" -q "${QUALITY}" -k "${CODEC}" -ac "${AUDIO_CODEC}" -a "${AUDIO_DEVICE}" -a "${SECONDARY_AUDIO_DEVICE}" -f "${FRAMERATE}" -r "${REPLAYDURATION}" -o "${OUTPUTDIR}" -df "${MAKEFOLDERS}" $ADDITIONAL_ARGS -cr "${COLOR_RANGE}" -keyint "${KEYINT}" -restore-portal-session "${RESTORE_PORTAL_SESSION}" -encoder "${ENCODER}" -bm "${BITRATE_MODE}" KillSignal=SIGINT Restart=on-failure RestartSec=5s [Install] WantedBy=default.target fsdsfdsfdsfdsf-5.13.8/extra/gsr-nvidia.conf000066400000000000000000000000661520215207700206440ustar00rootroot00000000000000options nvidia NVreg_PreserveVideoMemoryAllocations=1 fsdsfdsfdsfdsf-5.13.8/extra/meson_post_install.sh000077500000000000000000000004211520215207700222000ustar00rootroot00000000000000#!/bin/sh # Needed to remove password prompt when recording a monitor (without desktop portal option) on amd/intel or nvidia wayland /usr/sbin/setcap cap_sys_admin+ep ${MESON_INSTALL_DESTDIR_PREFIX}/bin/gsr-kms-server \ || echo "\n!!! Please re-run install as root\n" fsdsfdsfdsfdsf-5.13.8/gpu-screen-recorder.1000066400000000000000000000410561520215207700205500ustar00rootroot00000000000000.TH GPU-SCREEN-RECORDER 1 "2026-05-07" "5.13.4" "GPU Screen Recorder Manual" .SH NAME gpu-screen-recorder \- The fastest screen recording tool for Linux .SH SYNOPSIS .B gpu-screen-recorder .B \-w .I window_id|monitor|focused|portal|region|v4l2_device_path .RI [ options ] .B \-o .I output_file .PP .B gpu-screen-recorder .B \-\-help | .B \-\-version | .B \-\-info | .B \-\-list\-capture\-options | .B \-\-list\-monitors | .B \-\-list\-v4l2\-devices | .B \-\-list\-audio\-devices | .B \-\-list\-application\-audio .SH DESCRIPTION .B gpu-screen-recorder is the fastest screen recording tool for Linux. It uses the GPU only to record the screen to minimize system performance impact. It supports recording, live streaming, instant replay (similar to NVIDIA ShadowPlay), and screenshot capture. The tool works on both X11 and Wayland with AMD, Intel, and NVIDIA graphics cards. .PP Key features include: .RS .IP \(bu 3 GPU-accelerated encoding using H264, HEVC, AV1, VP8, or VP9 codecs .IP \(bu 3 Support for HDR recording (HEVC HDR and AV1 HDR) .IP \(bu 3 Instant replay buffer (last N seconds recording) .IP \(bu 3 Live streaming capabilities .IP \(bu 3 Audio recording from devices and applications (PipeWire required for app audio) .IP \(bu 3 Plugin system for custom graphics overlay .IP \(bu 3 Minimal performance impact compared to traditional screen recorders .RE .SH OPTIONS .SS Capture Options .TP .BI \-w " window_id|monitor|focused|portal|region|v4l2_device_path" Specify what to record. Formats: .RS .IP \(bu 3 .B window - Record a specific window (use window ID) (X11 only) .IP \(bu 3 .B screen - Record the first monitor found .IP \(bu 3 .B screen\-direct - NVIDIA X11 only, for VRR/G-SYNC support (not recommended due to driver issues) .IP \(bu 3 .B focused - Record the currently focused window (X11 only) (use with -s option) .IP \(bu 3 .B portal - Use xdg-desktop-portal with PipeWire (Wayland only) .IP \(bu 3 .B region - Record a specific region (use with .B \-region option) .IP \(bu 3 Monitor name (e.g., .BR DP\-1 ) - Record specific monitor .IP \(bu 3 V4L2 device path (e.g., .BR /dev/video0 ) - Record camera device (V4L2). Other applications can't use the camera when GPU Screen Recorder is using the camera and GPU Screen Recorder may not be able to use the camera if another application is already using the camera .IP \(bu 3 Combine sources with | (e.g., .BR "monitor:screen|v4l2:/dev/video0" ) .RE .PP Run .B \-\-list\-capture\-options to list available capture sources. .PP Additional options can be passed to each capture source by splitting capture source with .B ; for example .BR "screen;x=50;y=50". .br These are the available options for all capture sources (optional): .RS .IP \(bu 3 .B x - The X position in pixels. If the number ends with % then this sets the X position relative to the video width (integer percentage where 100 = 100%) .IP \(bu 3 .B y - The Y position in pixels. If the number ends with % then this sets the Y position relative to the video height (integer percentage where 100 = 100%) .IP \(bu 3 .B width - The width in pixels. If the number ends with % then this sets the width relative to the video width (integer percentage where 100 = 100%). A value of 0 means to not scale the capture source and instead use the original width. .IP \(bu 3 .B height - The height in pixels. If the number ends with % then this sets the height relative to the video height (integer percentage where 100 = 100%). A value of 0 means to not scale the capture source and instead use the original height. .IP \(bu 3 .B halign - The horizontal alignment, should be either .BR "start", .B center or .BR "end". Set to .B center by default when using one capture source, otherwise it's set to .B start by default. .IP \(bu 3 .B valign - The vertical alignment, should be either .BR "start", .B center or .BR "end". Set to .B center by default when using one capture source, otherwise it's set to .B start by default. .IP \(bu 3 .B hflip - If the source should be flipped horizontally, should be either .B "true" or .BR "false". Set to .B false by default .IP \(bu 3 .B vflip - If the source should be flipped vertically, should be either .B "true" or .BR "false". Set to .B false by default .RE .PP These are the additional options available for camera (V4L2) sources (optional): .RS .IP \(bu 3 .B pixfmt - The pixel format, should be either .BR "auto", .B yuyv or .BR "mjpeg". Set to .B auto by default .IP \(bu 3 .B camera_fps - The camera fps. Has to match a camera fps returned in .B --info or .B --list-v4l2-devices for the device. A value of 0 means to use the best option available. .IP \(bu 3 .B camera_width - The camera width in pixels. Has to match a camera width returned in .B --info or .B --list-v4l2-devices for the device. A value of 0 means to use the best option available. .IP \(bu 3 .B camera_height - The camera height in pixels. Has to match a camera height returned in .B --info or .B --list-v4l2-devices for the device. A value of 0 means to use the best option available. .RE .TP .BI \-region " WxH+X+Y" Specify region to capture when using .BR \-w " region." Format is width x height + X offset + Y offset. Set width and height to 0 to capture the whole monitor that contains the position. It is compatible with tools such as slop (X11) and slurp (Wayland). .TP .BI \-c " container_format" Container format (mp4, mkv, flv, webm). Defaults to extension from .B \-o filename. .TP .BI \-s " WxH" Output resolution limit (e.g., 1920x1080). Use 0x0 for original resolution. Required for .BR \-w " focused." .TP .BI \-f " fps" Frame rate (default: 60). For variable frame rate mode, this is maximum FPS. .TP .BI \-cursor " yes|no" Record cursor (default: yes). .TP .BI \-restore\-portal\-session " yes|no" Restore previous portal session (used with -w portal option, default: no). .SS Audio Options .TP .BI \-a " audio_source" Audio device or application to record. Can be specified multiple times. Formats: .RS .IP \(bu 3 .B default_output - Default output device .IP \(bu 3 .B default_input - Default input device .IP \(bu 3 .B device:name - Specific device .IP \(bu 3 .B app:name - Application audio (case-insensitive) .IP \(bu 3 .B app\-inverse:name - All applications except specified .IP \(bu 3 Combine sources with | (e.g., .BR "default_output|app:firefox" ) .RE .PP Run .B \-\-list\-audio\-devices to list available audio devices. .br Run .B \-\-list\-application\-audio to list available applications for audio capture. .TP .BI \-ac " aac|opus|flac" Audio codec (default: opus for mp4/mkv, aac otherwise). FLAC temporarily disabled. .TP .BI \-ab " bitrate" Audio bitrate in kbps (default: 128 for opus/flac, 160 for aac). 0 = automatic. .SS Video Quality Options .TP .BI \-k " codec" Video codec: .BR auto ", " h264 ", " hevc ", " av1 ", " vp8 ", " vp9 ", " hevc_hdr ", " av1_hdr ", " hevc_10bit ", " av1_10bit ", " h264_vulkan ", " hevc_vulkan ", " hevc_10bit_vulkan ", " av1_vulkan ", " av1_hdr_vulkan ", " av1_10bit_vulkan HDR options not available on X11 or portal capture. 10-bit capture reduces banding but may not be supported properly by all video players. .br Vulkan codec options are experimental. They may not work properly on your system because of GPU driver issues. .br Using vulkan codecs may result in better gaming performance with older NVIDIA gpu drivers, as vulkan video encoding doesn't suffer from an issue known as "cuda p2 state" .br where the GPU gets downclocked when using nvenc (regular video codecs on NVIDIA). (default: auto → h264). .TP .BI \-q " quality" Quality preset (medium, high, very_high, ultra) for QP/VBR mode, or bitrate (kbps) for CBR mode (default: very_high). .TP .BI \-bm " auto|qp|vbr|cbr" Bitrate mode (default: auto → qp). CBR recommended for replay buffer and live streaming. QP means to capture with constant quality, even in motion, while VBR and CBR means to capture with constant size. .TP .BI \-fm " cfr|vfr|content" Frame rate mode: cfr (constant), vfr (variable), or content (match content) (default: vfr). Content mode is only available on X11 or portal. Content mode syncs video to the captured content and is recommended for smoothest video when the game is running at the same frame rate or lower than what you are trying to record at. .TP .BI \-cr " limited|full" Color range (default: limited). Full range may cause issues with some video players/websites. .TP .BI \-tune " performance|quality" Encoding tune (default: performance). Currently NVIDIA only. .TP .BI \-keyint " seconds" Keyframe interval in seconds (default: 2.0). Affects seeking precision. .TP .BI \-encoder " gpu|cpu" Encoding device (default: gpu). CPU encoding only for H264. .TP .BI \-fallback\-cpu\-encoding " yes|no" Fallback to CPU if GPU encoding unavailable (default: no). .SS Replay Buffer Options .TP .BI \-r " seconds" Replay buffer duration (2-86400 seconds). When set, only saves on command. .TP .BI \-replay\-storage " ram|disk" Buffer storage location (default: ram). Disk mode may reduce SSD lifespan. .TP .BI \-restart\-replay\-on\-save " yes|no" Clear buffer after saving replay (default: no). .TP .BI \-df " yes|no" Organize replays in date-based folders (default: no). .SS Advanced Options .TP .BI \-p " plugin.so" Load plugin (.so file). Can be specified multiple times. .TP .BI \-sc " script_path" Script to run after saving video. Receives filepath and type ("regular", "replay", "screenshot"). .TP .BI \-portal\-session\-token\-filepath " path" Portal session token file (default: ~/.config/gpu-screen-recorder/restore_token). .TP .BI \-ffmpeg-opts " options" Additional arguments to pass to FFmpeg for the file in a list of key-values pairs in the format "key=value;key=value", .br for example: -ffmpeg-opts "hls_list_size=3;hls_time=1;hls_flags=delete_segments". .br Note: this overwrites options set by GPU Screen Recorder with the same name. .TP .BI \-ffmpeg-video-opts " options" Additional arguments to pass to FFmpeg for the video in a list of key-values pairs in the format "key=value;key=value", .br for example: -ffmpeg-video-opts "codec=cabac;rc_mode=CQP;qp=16". .br Note: this overwrites options set by GPU Screen Recorder with the same name. .TP .BI \-ffmpeg-audio-opts " options" Additional arguments to pass to FFmpeg for the audio in a list of key-values pairs in the format "key=value;key=value", .br for example: -ffmpeg-audio-opts "aac_coder=fast;aac_pce=true". .br Note: this overwrites options set by GPU Screen Recorder with the same name. .TP .BI \-gl\-debug " yes|no" OpenGL debug output (default: no). .TP .BI \-v " yes|no" Print FPS and damage info (default: yes). .TP .BI \-low-power " yes|no" Run in low power mode. This currently has only an affect on AMD (as it's only an issue on AMD) and allows the GPU to go into a lower power mode when recording (default: no). .br Setting this to .B yes might not always be ideal because of AMD driver issues where after playing a video with VAAPI on the system the video encoding performance also reduces, which affects GPU Screen Recorder. .br It's recommended to also use the option .B -fm content when this is set to .B yes to only encode frames when the screen content updates to lower GPU and video encoding usage when the system is idle. .TP .BI \-write\-first\-frame\-ts " yes|no" When enabled, writes a timestamp file with extra extension \fI.ts\fR next to the output video containing: .nf monotonic_microsec realtime_microsec .fi (default: no). Ignored for live streaming and when output is piped. .SS Output Options .TP .BI \-o " output" Output file path (or directory for replay mode). Required except when outputting to stdout. .TP .BI \-ro " directory" Output directory for regular recordings during replay/streaming mode. .SS Information Commands .TP .B \-\-help Show help message. .TP .B \-\-version Show version (5.10.2). .TP .B \-\-info Show system info (codecs, capture options). .TP .B \-\-list\-capture\-options List available capture sources (window, monitors, portal, v4l2 device path). .TP .B \-\-list\-monitors List available monitors. .TP .B \-\-list\-v4l2\-devices List available cameras devices (V4L2). .TP .B \-\-list\-audio\-devices List available audio devices. .TP .B \-\-list\-application\-audio List available applications for audio capture. .SH SIGNALS GPU Screen Recorder can be controlled via signals: .TP .B SIGINT (Ctrl+C) Stop and save recording (stop without save in replay mode). .TP .B SIGUSR1 Save replay (replay mode only). .TP .B SIGUSR2 Pause/unpause recording (not for streaming/replay). .TP .B SIGRTMIN Start/stop regular recording during replay/streaming. .TP .B SIGRTMIN+1 Save last 10 seconds (replay mode). .TP .B SIGRTMIN+2 Save last 30 seconds (replay mode). .TP .B SIGRTMIN+3 Save last 60 seconds (replay mode). .TP .B SIGRTMIN+4 Save last 5 minutes (replay mode). .TP .B SIGRTMIN+5 Save last 10 minutes (replay mode). .TP .B SIGRTMIN+6 Save last 30 minutes (replay mode). .PP Use .B pkill to send signals (e.g., .BR "pkill -SIGUSR1 -f ""^gpu-screen-recorder""" ). .SH EXAMPLES Record monitor at 60 FPS with desktop audio: .PP .nf .RS gpu-screen-recorder -w screen -f 60 -a default_output -o video.mp4 .RE .fi .PP Record monitor at 60 FPS with desktop audio and microphone: .PP .nf .RS gpu-screen-recorder -w screen -f 60 -a "default_output|default_input" -o video.mp4 .RE .fi .PP Record specific window (X11 only): .PP .nf .RS gpu-screen-recorder -w $(xdotool selectwindow) -f 60 -o video.mp4 .RE .fi .PP Instant replay (last 60 seconds): .PP .nf .RS gpu-screen-recorder -w screen -c mkv -r 60 -o ~/Videos .RE .fi .PP Record region using slop: .PP .nf .RS gpu-screen-recorder -w $(slop) -o video.mp4 .RE .fi .PP Record region using slurp: .PP .nf .RS gpu-screen-recorder -w $(slurp -f "%wx%h+%x+%y") -o video.mp4 .RE .fi .PP Instant replay and launch a script when saving replay: .PP .nf .RS gpu-screen-recorder -w screen -c mkv -r 60 -sc ./script.sh -o ~/Videos .RE .fi .PP Stream to Twitch with constant bitrate mode: .PP .nf .RS gpu-screen-recorder -w screen -c flv -a default_output -bm cbr -q 8000 -o "rtmp://live.twitch.tv/app/stream_key" .RE .fi .PP Take screenshot: .PP .nf .RS gpu-screen-recorder -w screen -o screenshot.jpg .PP .RE .fi Record screen and camera: .PP .nf .RS gpu-screen-recorder -w "screen|/dev/video0" -o video.mp4 .PP .RE .fi Record screen and camera. The camera is located at the bottom right and flipped horizontally: .PP .nf .RS gpu-screen-recorder -w "screen|/dev/video0;halign=end;valign=end;hflip=true;width=30%;height=30%" -o video.mp4 .PP .RE .fi Record two monitors, side by side (assuming the first monitor has a resolution of 1920x1080) .PP .nf .RS gpu-screen-recorder -w "DP-1|DP-2;x=1920" -o video.mp4 .RE .fi .SH FILES .TP .I ~/.config/gpu-screen-recorder/gpu-screen-recorder.env Environment variables for systemd service (optional). .TP .I /usr/lib/modprobe.d/gsr-nvidia.conf NVIDIA suspend/resume fix. .TP .I ~/.config/gpu-screen-recorder/restore_token Portal session token storage (default location). .SH TIPS .IP \(bu 3 Some video editors don't support videos in variable frame rate mode. Change video container to .mkv or capture in constant frame rate mode instead to workaround this issue .IP \(bu 3 Variable frame rate may cause issues in some video players (use MPV) .IP \(bu 3 H.265/HEVC not supported in browsers/Discord (use H264 for sharing) .IP \(bu 3 Some distros disable hardware codecs (use Flatpak version) .IP \(bu 3 Use CBR mode ( .B \-bm cbr ) for replay buffer to control RAM usage .SH PERFORMANCE TIPS .IP \(bu 3 Save to SSD (HDD may be too slow) .IP \(bu 3 Close other screen recorders (including idle OBS) .SH KNOWN ISSUES .IP \(bu 3 NVIDIA: CUDA breaks after suspend (install gsr-nvidia.conf fix) .IP \(bu 3 AMD: Possible black bars in output video with HEVC/AV1 (use H264 or FFmpeg >=8) .SH AUTHORS Developed by dec05eba and contributors. .SH REPORTING BUGS Report bugs to: .UR mailto:dec05eba@protonmail.com dec05eba@protonmail.com .UE . .br See more information about reporting bugs at the gpu-screen-recorder website: .UR https://git.dec05eba.com/?p=about https://git.dec05eba.com/?p=about .UE . .br Please take a look at the FAQ part of the README before reporting a bug: .UR https://git.dec05eba.com/gpu-screen-recorder/about/ https://git.dec05eba.com/gpu-screen-recorder/about/ .UE . .br The bug may have been previously reported or may not be related to gpu-screen-recorder (such as a driver issue). .SH COPYRIGHT Copyright © dec05eba. Licensed under GPL3-only. .SH SEE ALSO .UR https://git.dec05eba.com/gpu-screen-recorder Project homepage .UE .br .UR https://git.dec05eba.com/gpu-screen-recorder/about Project readme, with more information .UE .br .UR https://git.dec05eba.com/gpu-screen-recorder-gtk GTK GUI version (deprecated) .UE .br .UR https://git.dec05eba.com/gpu-screen-recorder-ui ShadowPlay-style UI .UE .br .BR xdotool (1), .BR slop (1), .BR slurp (1),fsdsfdsfdsfdsf-5.13.8/gsr-kms-server.1000066400000000000000000000050271520215207700175620ustar00rootroot00000000000000.TH GSR\-KMS\-SERVER 1 "2026-05-07" "5.13.4" "GPU Screen Recorder KMS Server Manual" .SH NAME gsr\-kms\-server \- KMS (Kernel Mode Setting) server for GPU Screen Recorder .SH SYNOPSIS .B gsr\-kms\-server <\fIdomain_socket_path\fR> <\fIcard_path\fR> .SH DESCRIPTION \fBgsr\-kms\-server\fR is a companion daemon for GPU Screen Recorder that provides Kernel Mode Setting (KMS) access for screen capture in environments where direct DRM access is required. It acts as a local server that communicates via a Unix domain socket, allowing GPU Screen Recorder to capture screen content through the KMS interface. .PP This component is typically used when GPU Screen Recorder needs to access display hardware directly, bypassing the windowing system for more efficient or lower-level capture. It runs as a separate process and communicates with the main GPU Screen Recorder instance. .SH ARGUMENTS .TP .B \fIdomain_socket_path\fR Path to the Unix domain socket that the server will create and listen on. This socket is used for communication between GPU Screen Recorder and the KMS server. The path should be in a location where both processes have appropriate permissions to read and write. .TP .B \fIcard_path\fR Path to the DRM device file (typically \fI/dev/dri/cardX\fR) that the server will use for KMS operations. This corresponds to a specific graphics card in the system. .SH EXAMPLES Start the KMS server using card0 and create socket at /tmp/gsr-kms.sock: .RS .B gsr\-kms\-server /tmp/gsr\-kms.sock /dev/dri/card0 .RE .PP Start the KMS server using card1 and create socket in a user-specific location: .RS .B gsr\-kms\-server ~/.cache/gsr\-kms.sock /dev/dri/card1 .RE .SH NOTES .IP \(bu 3 The \fBgsr-kms-server\fR typically runs with elevated permissions to access DRM devices, which requires root permission. .IP \(bu 3 Only one instance should run per DRM card at a time. .IP \(bu 3 The server will exit when the client disconnects or when terminated by a signal. .IP \(bu 3 The socket file is created by the server and removed when the server exits. .SH FILES .TP .B /dev/dri/card* DRM device files for graphics cards .TP .B /tmp/gsr-kms.sock Typical location for the domain socket (user-configurable) .SH AUTHORS gsr\-kms\-server was written by the GPU Screen Recorder contributors. .SH REPORTING BUGS Report bugs to: .UR mailto:dec05eba@protonmail.com dec05eba@protonmail.com .UE . .SH COPYRIGHT Copyright © dec05eba. Licensed under GPL3-only. .SH SEE ALSO .BR gpu\-screen\-recorder (1), .BR drm (4) .PP Project homepage: fsdsfdsfdsfdsf-5.13.8/include/000077500000000000000000000000001520215207700162305ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/include/args_parser.h000066400000000000000000000060511520215207700207130ustar00rootroot00000000000000#ifndef GSR_ARGS_PARSER_H #define GSR_ARGS_PARSER_H #include #include #include "defs.h" #include "vec2.h" typedef struct gsr_egl gsr_egl; #define NUM_ARGS 37 typedef enum { GSR_CAPTURE_SOURCE_TYPE_WINDOW, GSR_CAPTURE_SOURCE_TYPE_FOCUSED_WINDOW, GSR_CAPTURE_SOURCE_TYPE_MONITOR, GSR_CAPTURE_SOURCE_TYPE_REGION, GSR_CAPTURE_SOURCE_TYPE_PORTAL, GSR_CAPTURE_SOURCE_TYPE_V4L2 } CaptureSourceType; typedef enum { ARG_TYPE_STRING, ARG_TYPE_BOOLEAN, ARG_TYPE_ENUM, ARG_TYPE_I64, ARG_TYPE_DOUBLE, } ArgType; typedef struct { const char *name; int value; } ArgEnum; typedef struct { ArgType type; const char **values; int capacity_num_values; int num_values; const char *key; bool optional; bool list; const ArgEnum *enum_values; int num_enum_values; int64_t integer_value_min; int64_t integer_value_max; union { bool boolean; int enum_value; int64_t i64_value; double d_value; } typed_value; } Arg; typedef struct { void (*version)(void *userdata); void (*info)(void *userdata); void (*list_audio_devices)(void *userdata); void (*list_application_audio)(void *userdata); void (*list_v4l2_devices)(void *userdata); void (*list_capture_options)(const char *card_path, void *userdata); void (*list_monitors)(void *userdata); } args_handlers; typedef struct { Arg args[NUM_ARGS]; gsr_video_encoder_hardware video_encoder; gsr_pixel_format pixel_format; gsr_framerate_mode framerate_mode; gsr_color_range color_range; gsr_tune tune; gsr_video_codec video_codec; gsr_audio_codec audio_codec; gsr_bitrate_mode bitrate_mode; gsr_video_quality video_quality; gsr_replay_storage replay_storage; const char *capture_source; const char *container_format; const char *filename; const char *replay_recording_directory; const char *portal_session_token_filepath; const char *recording_saved_script; const char *ffmpeg_opts; const char *ffmpeg_video_opts; const char *ffmpeg_audio_opts; bool verbose; bool gl_debug; bool fallback_cpu_encoding; bool low_power; bool record_cursor; bool date_folders; bool restore_portal_session; bool restart_replay_on_save; bool write_first_frame_ts; bool is_livestream; bool is_output_piped; bool low_latency_recording; bool very_old_gpu; int64_t video_bitrate; int64_t audio_bitrate; int64_t fps; int64_t replay_buffer_size_secs; double keyint; vec2i output_resolution; vec2i region_size; vec2i region_position; } args_parser; /* |argv| is stored as a reference */ bool args_parser_parse(args_parser *self, int argc, char **argv, const args_handlers *args_handlers, void *userdata); void args_parser_deinit(args_parser *self); bool args_parser_validate_with_gl_info(args_parser *self, gsr_egl *egl); void args_parser_print_usage(void); Arg* args_parser_get_arg(args_parser *self, const char *arg_name); #endif /* GSR_ARGS_PARSER_H */ fsdsfdsfdsfdsf-5.13.8/include/capture/000077500000000000000000000000001520215207700176735ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/include/capture/capture.h000066400000000000000000000062441520215207700215150ustar00rootroot00000000000000#ifndef GSR_CAPTURE_CAPTURE_H #define GSR_CAPTURE_CAPTURE_H #include "../color_conversion.h" #include #include #include typedef struct AVCodecContext AVCodecContext; typedef struct AVStream AVStream; typedef struct AVFrame AVFrame; typedef struct AVMasteringDisplayMetadata AVMasteringDisplayMetadata; typedef struct AVContentLightMetadata AVContentLightMetadata; typedef struct gsr_capture gsr_capture; typedef struct gsr_capture_metadata gsr_capture_metadata; typedef enum { GSR_CAPTURE_ALIGN_START, GSR_CAPTURE_ALIGN_CENTER, GSR_CAPTURE_ALIGN_END } gsr_capture_alignment; struct gsr_capture_metadata { // Size of the video vec2i video_size; // The captured output gets scaled to this size. By default this will be the same size as the captured target vec2i recording_size; vec2i position; int fps; gsr_capture_alignment halign; gsr_capture_alignment valign; gsr_flip flip; }; struct gsr_capture { /* These methods should not be called manually. Call gsr_capture_* instead. |capture_metadata->video_size| should be set by this function */ int (*start)(gsr_capture *cap, gsr_capture_metadata *capture_metadata); void (*on_event)(gsr_capture *cap, gsr_egl *egl); /* can be NULL */ void (*tick)(gsr_capture *cap); /* can be NULL. If there is an event then |on_event| is called before this */ bool (*should_stop)(gsr_capture *cap, bool *err); /* can be NULL. If NULL, return false */ bool (*capture_has_synchronous_task)(gsr_capture *cap); /* can be NULL. If this returns true then the time spent in |capture| is ignored for video/audio (capture is paused while the synchronous task happens) */ void (*pre_capture)(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion); /* can be NULL */ int (*capture)(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion); /* Return 0 if the frame was captured */ bool (*uses_external_image)(gsr_capture *cap); /* can be NULL. If NULL, return false */ bool (*set_hdr_metadata)(gsr_capture *cap, AVMasteringDisplayMetadata *mastering_display_metadata, AVContentLightMetadata *light_metadata); /* can be NULL. If NULL, return false */ uint64_t (*get_window_id)(gsr_capture *cap); /* can be NULL. Returns 0 if unknown */ bool (*is_damaged)(gsr_capture *cap); /* can be NULL */ void (*clear_damage)(gsr_capture *cap); /* can be NULL */ void (*destroy)(gsr_capture *cap); void *priv; /* can be NULL */ bool started; }; int gsr_capture_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata); void gsr_capture_on_event(gsr_capture *cap, gsr_egl *egl); void gsr_capture_tick(gsr_capture *cap); bool gsr_capture_should_stop(gsr_capture *cap, bool *err); int gsr_capture_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion); bool gsr_capture_uses_external_image(gsr_capture *cap); bool gsr_capture_set_hdr_metadata(gsr_capture *cap, AVMasteringDisplayMetadata *mastering_display_metadata, AVContentLightMetadata *light_metadata); void gsr_capture_destroy(gsr_capture *cap); #endif /* GSR_CAPTURE_CAPTURE_H */ fsdsfdsfdsfdsf-5.13.8/include/capture/kms.h000066400000000000000000000010601520215207700206330ustar00rootroot00000000000000#ifndef GSR_CAPTURE_KMS_H #define GSR_CAPTURE_KMS_H #include "capture.h" #include "../cursor.h" #include "../../kms/kms_shared.h" typedef struct { gsr_egl *egl; gsr_cursor *x11_cursor; gsr_kms_response *kms_response; const char *display_to_capture; /* A copy is made of this */ bool hdr; bool record_cursor; int fps; vec2i output_resolution; vec2i region_size; vec2i region_position; } gsr_capture_kms_params; gsr_capture* gsr_capture_kms_create(const gsr_capture_kms_params *params); #endif /* GSR_CAPTURE_KMS_H */ fsdsfdsfdsfdsf-5.13.8/include/capture/nvfbc.h000066400000000000000000000010571520215207700211450ustar00rootroot00000000000000#ifndef GSR_CAPTURE_NVFBC_H #define GSR_CAPTURE_NVFBC_H #include "capture.h" #include "../vec2.h" typedef struct { gsr_egl *egl; const char *display_to_capture; /* if this is "screen", then the entire x11 screen is captured (all displays). A copy is made of this */ int fps; bool direct_capture; bool record_cursor; vec2i output_resolution; vec2i region_size; vec2i region_position; } gsr_capture_nvfbc_params; gsr_capture* gsr_capture_nvfbc_create(const gsr_capture_nvfbc_params *params); #endif /* GSR_CAPTURE_NVFBC_H */ fsdsfdsfdsfdsf-5.13.8/include/capture/portal.h000066400000000000000000000010421520215207700213420ustar00rootroot00000000000000#ifndef GSR_CAPTURE_PORTAL_H #define GSR_CAPTURE_PORTAL_H #include "capture.h" typedef struct { gsr_egl *egl; bool record_cursor; bool restore_portal_session; /* If this is set to NULL then this defaults to $XDG_CONFIG_HOME/gpu-screen-recorder/restore_token ($XDG_CONFIG_HOME defaults to $HOME/.config) */ const char *portal_session_token_filepath; vec2i output_resolution; } gsr_capture_portal_params; gsr_capture* gsr_capture_portal_create(const gsr_capture_portal_params *params); #endif /* GSR_CAPTURE_PORTAL_H */ fsdsfdsfdsfdsf-5.13.8/include/capture/v4l2.h000066400000000000000000000026211520215207700206340ustar00rootroot00000000000000#ifndef GSR_CAPTURE_V4L2_H #define GSR_CAPTURE_V4L2_H #include "capture.h" typedef enum { GSR_CAPTURE_V4L2_PIXFMT_AUTO, GSR_CAPTURE_V4L2_PIXFMT_YUYV, GSR_CAPTURE_V4L2_PIXFMT_MJPEG } gsr_capture_v4l2_pixfmt; typedef struct { uint32_t width; uint32_t height; } gsr_capture_v4l2_resolution; typedef struct { uint32_t denominator; uint32_t numerator; } gsr_capture_v4l2_framerate; typedef struct { gsr_capture_v4l2_pixfmt pixfmt; gsr_capture_v4l2_resolution resolution; gsr_capture_v4l2_framerate framerate; } gsr_capture_v4l2_supported_setup; typedef struct { gsr_egl *egl; vec2i output_resolution; const char *device_path; gsr_capture_v4l2_pixfmt pixfmt; uint32_t camera_fps; /* Set to 0 if the best option should be chosen */ gsr_capture_v4l2_resolution camera_resolution; /* Set to 0, 0 if the best option should be chosen */ } gsr_capture_v4l2_params; gsr_capture* gsr_capture_v4l2_create(const gsr_capture_v4l2_params *params); const char* gsr_capture_v4l2_pixfmt_to_string(gsr_capture_v4l2_pixfmt pixfmt); uint32_t gsr_capture_v4l2_framerate_to_number(gsr_capture_v4l2_framerate framerate); typedef void (*v4l2_devices_query_callback)(const char *path, const gsr_capture_v4l2_supported_setup *supported_setup, void *userdata); void gsr_capture_v4l2_list_devices(v4l2_devices_query_callback callback, void *userdata); #endif /* GSR_CAPTURE_V4L2_H */ fsdsfdsfdsfdsf-5.13.8/include/capture/xcomposite.h000066400000000000000000000007701520215207700222420ustar00rootroot00000000000000#ifndef GSR_CAPTURE_XCOMPOSITE_H #define GSR_CAPTURE_XCOMPOSITE_H #include "capture.h" #include "../vec2.h" #include "../cursor.h" typedef struct { gsr_egl *egl; gsr_cursor *cursor; unsigned long window; bool follow_focused; /* If this is set then |window| is ignored */ bool record_cursor; vec2i output_resolution; } gsr_capture_xcomposite_params; gsr_capture* gsr_capture_xcomposite_create(const gsr_capture_xcomposite_params *params); #endif /* GSR_CAPTURE_XCOMPOSITE_H */ fsdsfdsfdsfdsf-5.13.8/include/capture/ximage.h000066400000000000000000000007621520215207700213230ustar00rootroot00000000000000#ifndef GSR_CAPTURE_XIMAGE_H #define GSR_CAPTURE_XIMAGE_H #include "capture.h" #include "../vec2.h" #include "../cursor.h" typedef struct { gsr_egl *egl; gsr_cursor *cursor; const char *display_to_capture; /* A copy is made of this */ bool record_cursor; vec2i output_resolution; vec2i region_size; vec2i region_position; } gsr_capture_ximage_params; gsr_capture* gsr_capture_ximage_create(const gsr_capture_ximage_params *params); #endif /* GSR_CAPTURE_XIMAGE_H */ fsdsfdsfdsfdsf-5.13.8/include/codec_query/000077500000000000000000000000001520215207700205325ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/include/codec_query/codec_query.h000066400000000000000000000011631520215207700232060ustar00rootroot00000000000000#ifndef GSR_CODEC_QUERY_H #define GSR_CODEC_QUERY_H #include #include "../vec2.h" typedef struct { bool supported; bool low_power; vec2i max_resolution; } gsr_supported_video_codec; typedef struct { gsr_supported_video_codec h264; gsr_supported_video_codec hevc; gsr_supported_video_codec hevc_hdr; gsr_supported_video_codec hevc_10bit; gsr_supported_video_codec av1; gsr_supported_video_codec av1_hdr; gsr_supported_video_codec av1_10bit; gsr_supported_video_codec vp8; gsr_supported_video_codec vp9; } gsr_supported_video_codecs; #endif /* GSR_CODEC_QUERY_H */ fsdsfdsfdsfdsf-5.13.8/include/codec_query/nvenc.h000066400000000000000000000003441520215207700220150ustar00rootroot00000000000000#ifndef GSR_CODEC_QUERY_NVENC_H #define GSR_CODEC_QUERY_NVENC_H #include "codec_query.h" bool gsr_get_supported_video_codecs_nvenc(gsr_supported_video_codecs *video_codecs, bool cleanup); #endif /* GSR_CODEC_QUERY_NVENC_H */ fsdsfdsfdsfdsf-5.13.8/include/codec_query/vaapi.h000066400000000000000000000003731520215207700220060ustar00rootroot00000000000000#ifndef GSR_CODEC_QUERY_VAAPI_H #define GSR_CODEC_QUERY_VAAPI_H #include "codec_query.h" bool gsr_get_supported_video_codecs_vaapi(gsr_supported_video_codecs *video_codecs, const char *card_path, bool cleanup); #endif /* GSR_CODEC_QUERY_VAAPI_H */ fsdsfdsfdsfdsf-5.13.8/include/codec_query/vulkan.h000066400000000000000000000004261520215207700222050ustar00rootroot00000000000000#ifndef GSR_CODEC_QUERY_VULKAN_H #define GSR_CODEC_QUERY_VULKAN_H #include "codec_query.h" bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_codecs, const char *card_path, int *device_index_ret, bool cleanup); #endif /* GSR_CODEC_QUERY_VULKAN_H */ fsdsfdsfdsfdsf-5.13.8/include/color_conversion.h000066400000000000000000000046131520215207700217700ustar00rootroot00000000000000#ifndef GSR_COLOR_CONVERSION_H #define GSR_COLOR_CONVERSION_H #include "shader.h" #include "defs.h" #include "vec2.h" #include #define GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS 12 #define GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS 2 typedef enum { GSR_SOURCE_COLOR_RGB, GSR_SOURCE_COLOR_BGR, GSR_SOURCE_COLOR_YUYV } gsr_source_color; typedef enum { GSR_DESTINATION_COLOR_NV12, /* YUV420, BT709, 8-bit */ GSR_DESTINATION_COLOR_P010, /* YUV420, BT2020, 10-bit */ GSR_DESTINATION_COLOR_RGB } gsr_destination_color; typedef enum { GSR_ROT_0, GSR_ROT_90, GSR_ROT_180, GSR_ROT_270 } gsr_rotation; typedef enum { GSR_FLIP_NONE = 0, GSR_FLIP_HORIZONTAL = (1 << 0), GSR_FLIP_VERTICAL = (1 << 1) } gsr_flip; typedef struct { int rotation_matrix; int offset; } gsr_color_graphics_uniforms; typedef struct { gsr_egl *egl; gsr_destination_color destination_color; unsigned int destination_textures[2]; vec2i destination_textures_size[2]; int num_destination_textures; gsr_color_range color_range; bool load_external_image_shader; } gsr_color_conversion_params; typedef struct { gsr_color_conversion_params params; gsr_color_graphics_uniforms graphics_uniforms[GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS]; gsr_shader graphics_shaders[GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS]; unsigned int framebuffers[GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS]; unsigned int vertex_array_object_id; unsigned int vertex_buffer_object_id; bool schedule_clear; } gsr_color_conversion; int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conversion_params *params); void gsr_color_conversion_deinit(gsr_color_conversion *self); void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, gsr_flip flip, gsr_source_color source_color, bool external_texture); void gsr_color_conversion_clear(gsr_color_conversion *self); void gsr_color_conversion_read_destination_texture(gsr_color_conversion *self, int destination_texture_index, int x, int y, int width, int height, unsigned int color_format, unsigned int data_format, void *pixels); gsr_rotation gsr_monitor_rotation_to_rotation(gsr_monitor_rotation monitor_rotation); #endif /* GSR_COLOR_CONVERSION_H */ fsdsfdsfdsfdsf-5.13.8/include/cuda.h000066400000000000000000000103631520215207700173200ustar00rootroot00000000000000#ifndef GSR_CUDA_H #define GSR_CUDA_H #include #include // To prevent hwcontext_cuda.h from including cuda.h #define CUDA_VERSION 11070 #define CU_CTX_SCHED_AUTO 0 #if defined(_WIN64) || defined(__LP64__) typedef unsigned long long CUdeviceptr_v2; #else typedef unsigned int CUdeviceptr_v2; #endif typedef CUdeviceptr_v2 CUdeviceptr; typedef int CUresult; typedef int CUdevice_v1; typedef CUdevice_v1 CUdevice; typedef struct CUctx_st *CUcontext; typedef struct CUstream_st *CUstream; typedef struct CUarray_st *CUarray; #define CUDA_SUCCESS 0 typedef enum CUgraphicsMapResourceFlags_enum { CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE = 0x00, CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY = 0x01, CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD = 0x02 } CUgraphicsMapResourceFlags; typedef enum CUgraphicsRegisterFlags_enum { CU_GRAPHICS_REGISTER_FLAGS_NONE = 0x00, CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY = 0x01, CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD = 0x02, CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST = 0x04, CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER = 0x08 } CUgraphicsRegisterFlags; typedef enum CUmemorytype_enum { CU_MEMORYTYPE_HOST = 0x01, /**< Host memory */ CU_MEMORYTYPE_DEVICE = 0x02, /**< Device memory */ CU_MEMORYTYPE_ARRAY = 0x03, /**< Array memory */ CU_MEMORYTYPE_UNIFIED = 0x04 /**< Unified device or host memory */ } CUmemorytype; typedef struct CUDA_MEMCPY2D_st { size_t srcXInBytes; /**< Source X in bytes */ size_t srcY; /**< Source Y */ CUmemorytype srcMemoryType; /**< Source memory type (host, device, array) */ const void *srcHost; /**< Source host pointer */ CUdeviceptr srcDevice; /**< Source device pointer */ CUarray srcArray; /**< Source array reference */ size_t srcPitch; /**< Source pitch (ignored when src is array) */ size_t dstXInBytes; /**< Destination X in bytes */ size_t dstY; /**< Destination Y */ CUmemorytype dstMemoryType; /**< Destination memory type (host, device, array) */ void *dstHost; /**< Destination host pointer */ CUdeviceptr dstDevice; /**< Destination device pointer */ CUarray dstArray; /**< Destination array reference */ size_t dstPitch; /**< Destination pitch (ignored when dst is array) */ size_t WidthInBytes; /**< Width of 2D memory copy in bytes */ size_t Height; /**< Height of 2D memory copy */ } CUDA_MEMCPY2D_v2; typedef CUDA_MEMCPY2D_v2 CUDA_MEMCPY2D; typedef struct CUgraphicsResource_st *CUgraphicsResource; typedef struct gsr_cuda gsr_cuda; struct gsr_cuda { void *library; CUcontext cu_ctx; CUresult (*cuInit)(unsigned int Flags); CUresult (*cuDeviceGetCount)(int *count); CUresult (*cuDeviceGet)(CUdevice *device, int ordinal); CUresult (*cuCtxCreate_v2)(CUcontext *pctx, unsigned int flags, CUdevice dev); CUresult (*cuCtxDestroy_v2)(CUcontext ctx); CUresult (*cuCtxPushCurrent_v2)(CUcontext ctx); CUresult (*cuCtxPopCurrent_v2)(CUcontext *pctx); CUresult (*cuGetErrorString)(CUresult error, const char **pStr); CUresult (*cuMemcpy2D_v2)(const CUDA_MEMCPY2D *pCopy); CUresult (*cuMemcpy2DAsync_v2)(const CUDA_MEMCPY2D *pcopy, CUstream hStream); CUresult (*cuStreamSynchronize)(CUstream hStream); CUresult (*cuGraphicsGLRegisterImage)(CUgraphicsResource *pCudaResource, unsigned int image, unsigned int target, unsigned int flags); CUresult (*cuGraphicsEGLRegisterImage)(CUgraphicsResource *pCudaResource, void *image, unsigned int flags); CUresult (*cuGraphicsResourceSetMapFlags)(CUgraphicsResource resource, unsigned int flags); CUresult (*cuGraphicsMapResources)(unsigned int count, CUgraphicsResource *resources, CUstream hStream); CUresult (*cuGraphicsUnmapResources)(unsigned int count, CUgraphicsResource *resources, CUstream hStream); CUresult (*cuGraphicsUnregisterResource)(CUgraphicsResource resource); CUresult (*cuGraphicsSubResourceGetMappedArray)(CUarray *pArray, CUgraphicsResource resource, unsigned int arrayIndex, unsigned int mipLevel); }; bool gsr_cuda_load(gsr_cuda *self); void gsr_cuda_unload(gsr_cuda *self); #endif /* GSR_CUDA_H */ fsdsfdsfdsfdsf-5.13.8/include/cursor.h000066400000000000000000000012061520215207700177150ustar00rootroot00000000000000#ifndef GSR_CURSOR_H #define GSR_CURSOR_H #include "egl.h" #include "vec2.h" typedef struct { gsr_egl *egl; Display *display; int x_fixes_event_base; unsigned int texture_id; vec2i size; vec2i hotspot; vec2i position; bool cursor_image_set; bool visible; } gsr_cursor; int gsr_cursor_init(gsr_cursor *self, gsr_egl *egl, Display *display); void gsr_cursor_deinit(gsr_cursor *self); /* Returns true if the cursor image has updated or if the cursor has moved */ bool gsr_cursor_on_event(gsr_cursor *self, XEvent *xev); void gsr_cursor_tick(gsr_cursor *self, Window relative_to); #endif /* GSR_CURSOR_H */ fsdsfdsfdsfdsf-5.13.8/include/damage.h000066400000000000000000000036471520215207700176310ustar00rootroot00000000000000#ifndef GSR_DAMAGE_H #define GSR_DAMAGE_H #include "cursor.h" #include "utils.h" #include #include typedef struct _XDisplay Display; typedef union _XEvent XEvent; #define GSR_DAMAGE_MAX_MONITORS 32 #define GSR_DAMAGE_MAX_TRACKED_TARGETS 12 typedef struct { int64_t window_id; vec2i window_pos; vec2i window_size; uint64_t damage; int refcount; } gsr_damage_window; typedef struct { char *monitor_name; gsr_monitor *monitor; int refcount; } gsr_damage_monitor; typedef struct { gsr_egl *egl; Display *display; bool track_cursor; int damage_event; int damage_error; bool damaged; uint64_t monitor_damage; int randr_event; int randr_error; gsr_cursor *cursor; gsr_monitor monitors[GSR_DAMAGE_MAX_MONITORS]; int num_monitors; gsr_damage_window windows_tracked[GSR_DAMAGE_MAX_TRACKED_TARGETS]; int num_windows_tracked; gsr_damage_monitor monitors_tracked[GSR_DAMAGE_MAX_TRACKED_TARGETS]; int num_monitors_tracked; int all_monitors_tracked_refcount; vec2i cursor_pos; } gsr_damage; bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, gsr_cursor *cursor, bool track_cursor); void gsr_damage_deinit(gsr_damage *self); /* This is reference counted */ bool gsr_damage_start_tracking_window(gsr_damage *self, int64_t window); void gsr_damage_stop_tracking_window(gsr_damage *self, int64_t window); /* This is reference counted. If |monitor_name| is NULL then all monitors are tracked */ bool gsr_damage_start_tracking_monitor(gsr_damage *self, const char *monitor_name); void gsr_damage_stop_tracking_monitor(gsr_damage *self, const char *monitor_name); void gsr_damage_on_event(gsr_damage *self, XEvent *xev); void gsr_damage_tick(gsr_damage *self); /* Also returns true if damage tracking is not available */ bool gsr_damage_is_damaged(gsr_damage *self); void gsr_damage_clear(gsr_damage *self); #endif /* GSR_DAMAGE_H */ fsdsfdsfdsfdsf-5.13.8/include/dbus.h000066400000000000000000000037421520215207700173440ustar00rootroot00000000000000#ifndef GSR_DBUS_H #define GSR_DBUS_H #include #include #include #define DBUS_RANDOM_STR_SIZE 16 typedef enum { GSR_PORTAL_CAPTURE_TYPE_MONITOR = 1 << 0, GSR_PORTAL_CAPTURE_TYPE_WINDOW = 1 << 1, GSR_PORTAL_CAPTURE_TYPE_VIRTUAL = 1 << 2, GSR_PORTAL_CAPTURE_TYPE_ALL = GSR_PORTAL_CAPTURE_TYPE_MONITOR | GSR_PORTAL_CAPTURE_TYPE_WINDOW | GSR_PORTAL_CAPTURE_TYPE_VIRTUAL } gsr_portal_capture_type; typedef enum { GSR_PORTAL_CURSOR_MODE_HIDDEN = 1 << 0, GSR_PORTAL_CURSOR_MODE_EMBEDDED = 1 << 1, GSR_PORTAL_CURSOR_MODE_METADATA = 1 << 2 } gsr_portal_cursor_mode; typedef struct { DBusConnection *con; DBusError err; char random_str[DBUS_RANDOM_STR_SIZE + 1]; unsigned int handle_counter; bool desktop_portal_rule_added; uint32_t screencast_version; char *screencast_restore_token; } gsr_dbus; /* Blocking. TODO: Make non-blocking */ bool gsr_dbus_init(gsr_dbus *self, const char *screencast_restore_token); void gsr_dbus_deinit(gsr_dbus *self); /* The follow functions should be called in order to setup ScreenCast properly */ /* These functions that return an int return the response status code */ int gsr_dbus_screencast_create_session(gsr_dbus *self, char **session_handle); /* |capture_type| is a bitmask of gsr_portal_capture_type values. gsr_portal_capture_type values that are not supported by the desktop portal will be ignored. |gsr_portal_cursor_mode| is a bitmask of gsr_portal_cursor_mode values. gsr_portal_cursor_mode values that are not supported will be ignored. */ int gsr_dbus_screencast_select_sources(gsr_dbus *self, const char *session_handle, uint32_t capture_type, uint32_t cursor_mode); int gsr_dbus_screencast_start(gsr_dbus *self, const char *session_handle, uint32_t *pipewire_node); bool gsr_dbus_screencast_open_pipewire_remote(gsr_dbus *self, const char *session_handle, int *pipewire_fd); const char* gsr_dbus_screencast_get_restore_token(gsr_dbus *self); #endif /* GSR_DBUS_H */ fsdsfdsfdsfdsf-5.13.8/include/defs.h000066400000000000000000000052341520215207700173260ustar00rootroot00000000000000#ifndef GSR_DEFS_H #define GSR_DEFS_H #include #define GSR_VIDEO_CODEC_AUTO -1 #define GSR_BITRATE_MODE_AUTO -1 typedef enum { GSR_GPU_VENDOR_AMD, GSR_GPU_VENDOR_INTEL, GSR_GPU_VENDOR_NVIDIA, GSR_GPU_VENDOR_BROADCOM, } gsr_gpu_vendor; typedef struct { gsr_gpu_vendor vendor; int gpu_version; /* 0 if unknown */ bool is_steam_deck; } gsr_gpu_info; typedef enum { GSR_MONITOR_ROT_0, GSR_MONITOR_ROT_90, GSR_MONITOR_ROT_180, GSR_MONITOR_ROT_270, } gsr_monitor_rotation; typedef enum { GSR_CONNECTION_X11, GSR_CONNECTION_WAYLAND, GSR_CONNECTION_DRM, } gsr_connection_type; typedef enum { GSR_VIDEO_QUALITY_MEDIUM, GSR_VIDEO_QUALITY_HIGH, GSR_VIDEO_QUALITY_VERY_HIGH, GSR_VIDEO_QUALITY_ULTRA, } gsr_video_quality; typedef enum { GSR_VIDEO_CODEC_H264, GSR_VIDEO_CODEC_HEVC, GSR_VIDEO_CODEC_HEVC_HDR, GSR_VIDEO_CODEC_HEVC_10BIT, GSR_VIDEO_CODEC_AV1, GSR_VIDEO_CODEC_AV1_HDR, GSR_VIDEO_CODEC_AV1_10BIT, GSR_VIDEO_CODEC_VP8, GSR_VIDEO_CODEC_VP9, GSR_VIDEO_CODEC_H264_VULKAN, GSR_VIDEO_CODEC_HEVC_VULKAN, GSR_VIDEO_CODEC_HEVC_HDR_VULKAN, GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN, GSR_VIDEO_CODEC_AV1_VULKAN, GSR_VIDEO_CODEC_AV1_HDR_VULKAN, GSR_VIDEO_CODEC_AV1_10BIT_VULKAN, } gsr_video_codec; typedef enum { GSR_AUDIO_CODEC_AAC, GSR_AUDIO_CODEC_OPUS, GSR_AUDIO_CODEC_FLAC, } gsr_audio_codec; typedef enum { GSR_PIXEL_FORMAT_YUV420, GSR_PIXEL_FORMAT_YUV444, } gsr_pixel_format; typedef enum { GSR_FRAMERATE_MODE_CONSTANT, GSR_FRAMERATE_MODE_VARIABLE, GSR_FRAMERATE_MODE_CONTENT, } gsr_framerate_mode; typedef enum { GSR_BITRATE_MODE_QP, GSR_BITRATE_MODE_VBR, GSR_BITRATE_MODE_CBR, } gsr_bitrate_mode; typedef enum { GSR_TUNE_PERFORMANCE, GSR_TUNE_QUALITY, } gsr_tune; typedef enum { GSR_VIDEO_ENCODER_HW_GPU, GSR_VIDEO_ENCODER_HW_CPU, } gsr_video_encoder_hardware; typedef enum { GSR_COLOR_RANGE_LIMITED, GSR_COLOR_RANGE_FULL, } gsr_color_range; typedef enum { GSR_COLOR_DEPTH_8_BITS, GSR_COLOR_DEPTH_10_BITS, } gsr_color_depth; typedef enum { GSR_REPLAY_STORAGE_RAM, GSR_REPLAY_STORAGE_DISK, } gsr_replay_storage; bool video_codec_is_hdr(gsr_video_codec video_codec); gsr_video_codec hdr_video_codec_to_sdr_video_codec(gsr_video_codec video_codec); gsr_color_depth video_codec_to_bit_depth(gsr_video_codec video_codec); const char* video_codec_to_string(gsr_video_codec video_codec); bool video_codec_is_av1(gsr_video_codec video_codec); bool video_codec_is_vulkan(gsr_video_codec video_codec); const char* audio_codec_get_name(gsr_audio_codec audio_codec); #endif /* GSR_DEFS_H */ fsdsfdsfdsfdsf-5.13.8/include/egl.h000066400000000000000000000441451520215207700171600ustar00rootroot00000000000000#ifndef GSR_EGL_H #define GSR_EGL_H /* OpenGL EGL library with a hidden window context (to allow using the opengl functions) */ #include #include #include #include #include "vec2.h" #include "defs.h" typedef struct gsr_window gsr_window; #ifdef _WIN64 typedef signed long long int khronos_intptr_t; typedef unsigned long long int khronos_uintptr_t; typedef signed long long int khronos_ssize_t; typedef unsigned long long int khronos_usize_t; #else typedef signed long int khronos_intptr_t; typedef unsigned long int khronos_uintptr_t; typedef signed long int khronos_ssize_t; typedef unsigned long int khronos_usize_t; #endif typedef void* EGLDisplay; typedef void* EGLNativeDisplayType; typedef uintptr_t EGLNativeWindowType; typedef uintptr_t EGLNativePixmapType; typedef void* EGLConfig; typedef void* EGLSurface; typedef void* EGLContext; typedef void* EGLClientBuffer; typedef void* EGLImage; typedef void* EGLImageKHR; typedef void *GLeglImageOES; typedef void (*__eglMustCastToProperFunctionPointerType)(void); typedef struct __GLXFBConfigRec *GLXFBConfig; typedef struct __GLXcontextRec *GLXContext; typedef XID GLXDrawable; typedef void(*__GLXextFuncPtr)(void); #define EGL_SUCCESS 0x3000 #define EGL_BUFFER_SIZE 0x3020 #define EGL_RENDERABLE_TYPE 0x3040 #define EGL_OPENGL_API 0x30A2 #define EGL_OPENGL_ES_API 0x30A0 #define EGL_OPENGL_BIT 0x0008 #define EGL_OPENGL_ES_BIT 0x0001 #define EGL_OPENGL_ES2_BIT 0x0004 #define EGL_OPENGL_ES3_BIT 0x00000040 #define EGL_NONE 0x3038 #define EGL_CONTEXT_CLIENT_VERSION 0x3098 #define EGL_CONTEXT_OPENGL_DEBUG 0x31B0 #define EGL_BACK_BUFFER 0x3084 #define EGL_GL_TEXTURE_2D 0x30B1 #define EGL_TRUE 1 #define EGL_IMAGE_PRESERVED_KHR 0x30D2 #define EGL_NATIVE_PIXMAP_KHR 0x30B0 #define EGL_LINUX_DRM_FOURCC_EXT 0x3271 #define EGL_WIDTH 0x3057 #define EGL_HEIGHT 0x3056 #define EGL_DMA_BUF_PLANE0_FD_EXT 0x3272 #define EGL_DMA_BUF_PLANE0_OFFSET_EXT 0x3273 #define EGL_DMA_BUF_PLANE0_PITCH_EXT 0x3274 #define EGL_DMA_BUF_PLANE1_FD_EXT 0x3275 #define EGL_DMA_BUF_PLANE1_OFFSET_EXT 0x3276 #define EGL_DMA_BUF_PLANE1_PITCH_EXT 0x3277 #define EGL_DMA_BUF_PLANE2_FD_EXT 0x3278 #define EGL_DMA_BUF_PLANE2_OFFSET_EXT 0x3279 #define EGL_DMA_BUF_PLANE2_PITCH_EXT 0x327A #define EGL_DMA_BUF_PLANE3_FD_EXT 0x3440 #define EGL_DMA_BUF_PLANE3_OFFSET_EXT 0x3441 #define EGL_DMA_BUF_PLANE3_PITCH_EXT 0x3442 #define EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT 0x3443 #define EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT 0x3444 #define EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT 0x3445 #define EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT 0x3446 #define EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT 0x3447 #define EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT 0x3448 #define EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT 0x3449 #define EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT 0x344A #define EGL_LINUX_DMA_BUF_EXT 0x3270 #define EGL_RED_SIZE 0x3024 #define EGL_ALPHA_SIZE 0x3021 #define EGL_BLUE_SIZE 0x3022 #define EGL_GREEN_SIZE 0x3023 #define EGL_DEVICE_EXT 0x322C #define EGL_DRM_DEVICE_FILE_EXT 0x3233 #define GL_FLOAT 0x1406 #define GL_FALSE 0 #define GL_TRUE 1 #define GL_TRIANGLES 0x0004 #define GL_TEXTURE_2D 0x0DE1 #define GL_TEXTURE_EXTERNAL_OES 0x8D65 #define GL_RED 0x1903 #define GL_GREEN 0x1904 #define GL_BLUE 0x1905 #define GL_ALPHA 0x1906 #define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 #define GL_RG 0x8227 #define GL_RGB 0x1907 #define GL_RGBA 0x1908 #define GL_RGB8 0x8051 #define GL_RGBA8 0x8058 #define GL_RGBA16 0x805B #define GL_R8 0x8229 #define GL_RG8 0x822B #define GL_R16 0x822A #define GL_RG16 0x822C #define GL_RGB16 0x8054 #define GL_RGBA32F 0x8814 #define GL_UNSIGNED_BYTE 0x1401 #define GL_COLOR_BUFFER_BIT 0x00004000 #define GL_TEXTURE_WRAP_S 0x2802 #define GL_TEXTURE_WRAP_T 0x2803 #define GL_TEXTURE_MAG_FILTER 0x2800 #define GL_TEXTURE_MIN_FILTER 0x2801 #define GL_NEAREST 0x2600 #define GL_CLAMP_TO_EDGE 0x812F #define GL_LINEAR 0x2601 #define GL_FRAMEBUFFER 0x8D40 #define GL_COLOR_ATTACHMENT0 0x8CE0 #define GL_FRAMEBUFFER_COMPLETE 0x8CD5 #define GL_DYNAMIC_DRAW 0x88E8 #define GL_ARRAY_BUFFER 0x8892 #define GL_BLEND 0x0BE2 #define GL_SRC_ALPHA 0x0302 #define GL_ONE_MINUS_SRC_ALPHA 0x0303 #define GL_DEBUG_OUTPUT_SYNCHRONOUS 0x8242 #define GL_SCISSOR_TEST 0x0C11 #define GL_PACK_ALIGNMENT 0x0D05 #define GL_UNPACK_ALIGNMENT 0x0CF5 #define GL_TEXTURE0 0x84C0 #define GL_TEXTURE1 0x84C1 #define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020 #define GL_ALL_BARRIER_BITS 0xFFFFFFFF #define GL_PIXEL_UNPACK_BUFFER 0x88EC #define GL_MAP_WRITE_BIT 0x0002 #define GL_VENDOR 0x1F00 #define GL_RENDERER 0x1F01 #define GL_VERSION 0x1F02 #define GL_COMPILE_STATUS 0x8B81 #define GL_INFO_LOG_LENGTH 0x8B84 #define GL_FRAGMENT_SHADER 0x8B30 #define GL_VERTEX_SHADER 0x8B31 #define GL_COMPILE_STATUS 0x8B81 #define GL_LINK_STATUS 0x8B82 typedef unsigned int (*FUNC_eglExportDMABUFImageQueryMESA)(EGLDisplay dpy, EGLImageKHR image, int *fourcc, int *num_planes, uint64_t *modifiers); typedef unsigned int (*FUNC_eglExportDMABUFImageMESA)(EGLDisplay dpy, EGLImageKHR image, int *fds, int32_t *strides, int32_t *offsets); typedef void (*FUNC_glEGLImageTargetTexture2DOES)(unsigned int target, GLeglImageOES image); typedef GLXContext (*FUNC_glXCreateContextAttribsARB)(Display *dpy, GLXFBConfig config, GLXContext share_context, Bool direct, const int *attrib_list); typedef void (*FUNC_glXSwapIntervalEXT)(Display * dpy, GLXDrawable drawable, int interval); typedef int (*FUNC_glXSwapIntervalMESA)(unsigned int interval); typedef int (*FUNC_glXSwapIntervalSGI)(int interval); typedef void (*GLDEBUGPROC)(unsigned int source, unsigned int type, unsigned int id, unsigned int severity, int length, const char *message, const void *userParam); typedef int (*FUNC_eglQueryDisplayAttribEXT)(EGLDisplay dpy, int32_t attribute, intptr_t *value); typedef const char* (*FUNC_eglQueryDeviceStringEXT)(void *device, int32_t name); typedef int (*FUNC_eglQueryDmaBufModifiersEXT)(EGLDisplay dpy, int32_t format, int32_t max_modifiers, uint64_t *modifiers, int *external_only, int32_t *num_modifiers); typedef void (*FUNC_glCreateMemoryObjectsEXT)(int n, unsigned int *memoryObjects); typedef void (*FUNC_glImportMemoryFdEXT)(unsigned int memory, uint64_t size, unsigned int handleType, int fd); typedef unsigned char (*FUNC_glIsMemoryObjectEXT)(unsigned int memoryObject); typedef void (*FUNC_glTexStorageMem2DEXT)(unsigned int target, int levels, unsigned int internalFormat, int width, int height, unsigned int memory, uint64_t offset); typedef void (*FUNC_glBufferStorageMemEXT)(unsigned int target, ssize_t size, unsigned int memory, uint64_t offset); typedef void (*FUNC_glNamedBufferStorageMemEXT)(unsigned int buffer, ssize_t size, unsigned int memory, uint64_t offset); typedef void (*FUNC_glMemoryObjectParameterivEXT)(unsigned int memoryObject, unsigned int pname, const int *params); typedef void (*FUNC_glGenSemaphoresEXT)(int n, unsigned int *semaphores); typedef void (*FUNC_glImportSemaphoreFdEXT)(unsigned int semaphore, unsigned int handleType, int fd); typedef void (*FUNC_glSignalSemaphoreEXT)(unsigned int semaphore, unsigned int numBufferBarriers, const unsigned int *buffers, unsigned int numTextureBarriers, const unsigned int *textures, const unsigned int *dstLayouts); typedef enum { GSR_GL_CONTEXT_TYPE_EGL, GSR_GL_CONTEXT_TYPE_GLX } gsr_gl_context_type; typedef struct gsr_egl gsr_egl; struct gsr_egl { void *egl_library; void *glx_library; void *gl_library; gsr_gl_context_type context_type; gsr_window *window; EGLDisplay egl_display; EGLSurface egl_surface; EGLContext egl_context; const char *dri_card_path; void *glx_context; void *glx_fb_config; gsr_gpu_info gpu_info; char card_path[128]; int vulkan_device_index; int32_t (*eglGetError)(void); EGLDisplay (*eglGetDisplay)(EGLNativeDisplayType display_id); unsigned int (*eglInitialize)(EGLDisplay dpy, int32_t *major, int32_t *minor); unsigned int (*eglTerminate)(EGLDisplay dpy); unsigned int (*eglChooseConfig)(EGLDisplay dpy, const int32_t *attrib_list, EGLConfig *configs, int32_t config_size, int32_t *num_config); EGLSurface (*eglCreateWindowSurface)(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const int32_t *attrib_list); EGLContext (*eglCreateContext)(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const int32_t *attrib_list); unsigned int (*eglMakeCurrent)(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); EGLImage (*eglCreateImage)(EGLDisplay dpy, EGLContext ctx, unsigned int target, EGLClientBuffer buffer, const intptr_t *attrib_list); unsigned int (*eglDestroyContext)(EGLDisplay dpy, EGLContext ctx); unsigned int (*eglDestroySurface)(EGLDisplay dpy, EGLSurface surface); unsigned int (*eglDestroyImage)(EGLDisplay dpy, EGLImage image); unsigned int (*eglSwapInterval)(EGLDisplay dpy, int32_t interval); unsigned int (*eglSwapBuffers)(EGLDisplay dpy, EGLSurface surface); unsigned int (*eglBindAPI)(unsigned int api); __eglMustCastToProperFunctionPointerType (*eglGetProcAddress)(const char *procname); FUNC_eglExportDMABUFImageQueryMESA eglExportDMABUFImageQueryMESA; FUNC_eglExportDMABUFImageMESA eglExportDMABUFImageMESA; FUNC_glEGLImageTargetTexture2DOES glEGLImageTargetTexture2DOES; FUNC_eglQueryDisplayAttribEXT eglQueryDisplayAttribEXT; FUNC_eglQueryDeviceStringEXT eglQueryDeviceStringEXT; FUNC_eglQueryDmaBufModifiersEXT eglQueryDmaBufModifiersEXT; FUNC_glCreateMemoryObjectsEXT glCreateMemoryObjectsEXT; FUNC_glImportMemoryFdEXT glImportMemoryFdEXT; FUNC_glIsMemoryObjectEXT glIsMemoryObjectEXT; FUNC_glTexStorageMem2DEXT glTexStorageMem2DEXT; FUNC_glBufferStorageMemEXT glBufferStorageMemEXT; FUNC_glNamedBufferStorageMemEXT glNamedBufferStorageMemEXT; FUNC_glMemoryObjectParameterivEXT glMemoryObjectParameterivEXT; FUNC_glGenSemaphoresEXT glGenSemaphoresEXT; FUNC_glImportSemaphoreFdEXT glImportSemaphoreFdEXT; FUNC_glSignalSemaphoreEXT glSignalSemaphoreEXT; __GLXextFuncPtr (*glXGetProcAddress)(const unsigned char *procName); GLXFBConfig* (*glXChooseFBConfig)(Display *dpy, int screen, const int *attribList, int *nitems); Bool (*glXMakeContextCurrent)(Display *dpy, GLXDrawable draw, GLXDrawable read, GLXContext ctx); // TODO: Remove GLXContext (*glXCreateNewContext)(Display *dpy, GLXFBConfig config, int renderType, GLXContext shareList, Bool direct); void (*glXDestroyContext)(Display *dpy, GLXContext ctx); void (*glXSwapBuffers)(Display *dpy, GLXDrawable drawable); FUNC_glXCreateContextAttribsARB glXCreateContextAttribsARB; /* Optional */ FUNC_glXSwapIntervalEXT glXSwapIntervalEXT; FUNC_glXSwapIntervalMESA glXSwapIntervalMESA; FUNC_glXSwapIntervalSGI glXSwapIntervalSGI; unsigned int (*glGetError)(void); const unsigned char* (*glGetString)(unsigned int name); void (*glFlush)(void); void (*glFinish)(void); void (*glClear)(unsigned int mask); void (*glClearColor)(float red, float green, float blue, float alpha); void (*glGenTextures)(int n, unsigned int *textures); void (*glDeleteTextures)(int n, const unsigned int *texture); void (*glActiveTexture)(unsigned int texture); void (*glBindTexture)(unsigned int target, unsigned int texture); void (*glBindImageTexture)(unsigned int unit, unsigned int texture, int level, unsigned char layered, int layer, unsigned int access, unsigned int format); void (*glTexParameteri)(unsigned int target, unsigned int pname, int param); void (*glTexParameteriv)(unsigned int target, unsigned int pname, const int *params); void (*glTexParameterfv)(unsigned int target, unsigned int pname, const float *params); void (*glTexImage2D)(unsigned int target, int level, int internalFormat, int width, int height, int border, unsigned int format, unsigned int type, const void *pixels); void (*glTexSubImage2D)(unsigned int target, int level, int xoffset, int yoffset, int width, int height, unsigned format, unsigned type, const void *pixels); void (*glTexStorage2D)(unsigned int target, int levels, unsigned int internalformat, int width, int height); void (*glGetTexImage)(unsigned int target, int level, unsigned int format, unsigned int type, void *pixels); void (*glGenFramebuffers)(int n, unsigned int *framebuffers); void (*glBindFramebuffer)(unsigned int target, unsigned int framebuffer); void (*glDeleteFramebuffers)(int n, const unsigned int *framebuffers); /* TODO: Note: this is only available since OpenGL ES 3.1 */ void (*glMemoryBarrier)(unsigned int barriers); void (*glViewport)(int x, int y, int width, int height); void (*glFramebufferTexture2D)(unsigned int target, unsigned int attachment, unsigned int textarget, unsigned int texture, int level); void (*glDrawBuffers)(int n, const unsigned int *bufs); unsigned int (*glCheckFramebufferStatus)(unsigned int target); void (*glBindBuffer)(unsigned int target, unsigned int buffer); void (*glGenBuffers)(int n, unsigned int *buffers); void (*glBufferData)(unsigned int target, khronos_ssize_t size, const void *data, unsigned int usage); void (*glBufferSubData)(unsigned int target, khronos_intptr_t offset, khronos_ssize_t size, const void *data); void (*glDeleteBuffers)(int n, const unsigned int *buffers); void (*glGenVertexArrays)(int n, unsigned int *arrays); void (*glBindVertexArray)(unsigned int array); void (*glDeleteVertexArrays)(int n, const unsigned int *arrays); unsigned int (*glCreateProgram)(void); unsigned int (*glCreateShader)(unsigned int type); void (*glAttachShader)(unsigned int program, unsigned int shader); void (*glBindAttribLocation)(unsigned int program, unsigned int index, const char *name); void (*glCompileShader)(unsigned int shader); void (*glLinkProgram)(unsigned int program); void (*glShaderSource)(unsigned int shader, int count, const char *const*string, const int *length); void (*glUseProgram)(unsigned int program); void (*glGetProgramInfoLog)(unsigned int program, int bufSize, int *length, char *infoLog); void (*glGetShaderiv)(unsigned int shader, unsigned int pname, int *params); void (*glGetShaderInfoLog)(unsigned int shader, int bufSize, int *length, char *infoLog); void (*glDeleteProgram)(unsigned int program); void (*glDeleteShader)(unsigned int shader); void (*glGetProgramiv)(unsigned int program, unsigned int pname, int *params); void (*glVertexAttribPointer)(unsigned int index, int size, unsigned int type, unsigned char normalized, int stride, const void *pointer); void (*glEnableVertexAttribArray)(unsigned int index); void (*glDrawArrays)(unsigned int mode, int first, int count); void (*glEnable)(unsigned int cap); void (*glDisable)(unsigned int cap); void (*glBlendFunc)(unsigned int sfactor, unsigned int dfactor); void (*glPixelStorei)(unsigned int pname, int param); int (*glGetUniformLocation)(unsigned int program, const char *name); void (*glUniform1f)(int location, float v0); void (*glUniform2f)(int location, float v0, float v1); void (*glUniform1i)(int location, int v0); void (*glUniform2i)(int location, int v0, int v1); void (*glUniformMatrix2fv)(int location, int count, unsigned char transpose, const float *value); void (*glDebugMessageCallback)(GLDEBUGPROC callback, const void *userParam); void (*glScissor)(int x, int y, int width, int height); void (*glCreateBuffers)(int n, unsigned int *buffers); void (*glReadPixels)(int x, int y, int width, int height, unsigned int format, unsigned int type, void *pixels); void* (*glMapBufferRange)(unsigned int target, intptr_t offset, ssize_t length, unsigned int access); unsigned char (*glUnmapBuffer)(unsigned int target); void (*glGetIntegerv)(unsigned int pname, int *params); }; bool gsr_egl_load(gsr_egl *self, gsr_window *window, bool is_monitor_capture, bool enable_debug); void gsr_egl_unload(gsr_egl *self); /* Does opengl swap with egl or glx, depending on which one is active */ void gsr_egl_swap_buffers(gsr_egl *self); #endif /* GSR_EGL_H */ fsdsfdsfdsfdsf-5.13.8/include/encoder/000077500000000000000000000000001520215207700176475ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/include/encoder/encoder.h000066400000000000000000000034751520215207700214500ustar00rootroot00000000000000#ifndef GSR_ENCODER_H #define GSR_ENCODER_H #include "../replay_buffer/replay_buffer.h" #include #include #include #include #define GSR_MAX_RECORDING_DESTINATIONS 128 typedef struct AVCodecContext AVCodecContext; typedef struct AVFormatContext AVFormatContext; typedef struct AVStream AVStream; typedef struct { size_t id; AVCodecContext *codec_context; AVFormatContext *format_context; AVStream *stream; int64_t start_pts; int64_t first_pts; bool has_received_keyframe; char *first_frame_ts_filepath; bool first_frame_ts_written; } gsr_encoder_recording_destination; typedef struct { gsr_replay_buffer *replay_buffer; int64_t first_pts; pthread_mutex_t file_write_mutex; bool file_write_mutex_created; pthread_mutex_t replay_mutex; bool replay_mutex_created; gsr_encoder_recording_destination recording_destinations[GSR_MAX_RECORDING_DESTINATIONS]; size_t num_recording_destinations; size_t recording_destination_id_counter; } gsr_encoder; bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size_t replay_buffer_num_packets, double replay_buffer_time, const char *replay_directory); void gsr_encoder_deinit(gsr_encoder *self); void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_context, int64_t pts, int stream_index); /* Returns the id to the recording destination, or -1 on error */ size_t gsr_encoder_add_recording_destination(gsr_encoder *self, AVCodecContext *codec_context, AVFormatContext *format_context, AVStream *stream, int64_t start_pts); bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id); bool gsr_encoder_set_recording_destination_first_frame_ts_filepath(gsr_encoder *self, size_t id, const char *filepath); #endif /* GSR_ENCODER_H */ fsdsfdsfdsfdsf-5.13.8/include/encoder/video/000077500000000000000000000000001520215207700207555ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/include/encoder/video/nvenc.h000066400000000000000000000005521520215207700222410ustar00rootroot00000000000000#ifndef GSR_ENCODER_VIDEO_NVENC_H #define GSR_ENCODER_VIDEO_NVENC_H #include "video.h" typedef struct gsr_egl gsr_egl; typedef struct { gsr_egl *egl; gsr_color_depth color_depth; } gsr_video_encoder_nvenc_params; gsr_video_encoder* gsr_video_encoder_nvenc_create(const gsr_video_encoder_nvenc_params *params); #endif /* GSR_ENCODER_VIDEO_NVENC_H */ fsdsfdsfdsfdsf-5.13.8/include/encoder/video/software.h000066400000000000000000000005741520215207700227660ustar00rootroot00000000000000#ifndef GSR_ENCODER_VIDEO_SOFTWARE_H #define GSR_ENCODER_VIDEO_SOFTWARE_H #include "video.h" typedef struct gsr_egl gsr_egl; typedef struct { gsr_egl *egl; gsr_color_depth color_depth; } gsr_video_encoder_software_params; gsr_video_encoder* gsr_video_encoder_software_create(const gsr_video_encoder_software_params *params); #endif /* GSR_ENCODER_VIDEO_SOFTWARE_H */ fsdsfdsfdsfdsf-5.13.8/include/encoder/video/vaapi.h000066400000000000000000000005521520215207700222300ustar00rootroot00000000000000#ifndef GSR_ENCODER_VIDEO_VAAPI_H #define GSR_ENCODER_VIDEO_VAAPI_H #include "video.h" typedef struct gsr_egl gsr_egl; typedef struct { gsr_egl *egl; gsr_color_depth color_depth; } gsr_video_encoder_vaapi_params; gsr_video_encoder* gsr_video_encoder_vaapi_create(const gsr_video_encoder_vaapi_params *params); #endif /* GSR_ENCODER_VIDEO_VAAPI_H */ fsdsfdsfdsfdsf-5.13.8/include/encoder/video/video.h000066400000000000000000000027571520215207700222470ustar00rootroot00000000000000#ifndef GSR_ENCODER_VIDEO_H #define GSR_ENCODER_VIDEO_H #include "../../color_conversion.h" #include #define GSR_MAX_RECORDING_DESTINATIONS 128 typedef struct gsr_video_encoder gsr_video_encoder; typedef struct AVCodecContext AVCodecContext; typedef struct AVFrame AVFrame; struct gsr_video_encoder { bool (*start)(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame); void (*destroy)(gsr_video_encoder *encoder, AVCodecContext *video_codec_context); void (*copy_textures_to_frame)(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion); /* Can be NULL */ /* |textures| should be able to fit 2 elements */ void (*get_textures)(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color); void *priv; bool started; }; /* Set |replay_buffer_time_seconds| and |fps| to 0 to disable replay buffer */ bool gsr_video_encoder_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame); void gsr_video_encoder_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context); void gsr_video_encoder_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion); void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color); #endif /* GSR_ENCODER_VIDEO_H */ fsdsfdsfdsfdsf-5.13.8/include/encoder/video/vulkan.h000066400000000000000000000005601520215207700224270ustar00rootroot00000000000000#ifndef GSR_ENCODER_VIDEO_VULKAN_H #define GSR_ENCODER_VIDEO_VULKAN_H #include "video.h" typedef struct gsr_egl gsr_egl; typedef struct { gsr_egl *egl; gsr_color_depth color_depth; } gsr_video_encoder_vulkan_params; gsr_video_encoder* gsr_video_encoder_vulkan_create(const gsr_video_encoder_vulkan_params *params); #endif /* GSR_ENCODER_VIDEO_VULKAN_H */ fsdsfdsfdsfdsf-5.13.8/include/image_writer.h000066400000000000000000000013311520215207700210550ustar00rootroot00000000000000#ifndef GSR_IMAGE_WRITER_H #define GSR_IMAGE_WRITER_H #include typedef struct gsr_egl gsr_egl; typedef enum { GSR_IMAGE_FORMAT_JPEG, GSR_IMAGE_FORMAT_PNG } gsr_image_format; typedef struct { gsr_egl *egl; int width; int height; unsigned int texture; } gsr_image_writer; bool gsr_image_writer_init_opengl(gsr_image_writer *self, gsr_egl *egl, int width, int height); void gsr_image_writer_deinit(gsr_image_writer *self); /* Quality is between 1 and 100 where 100 is the max quality. Quality doesn't apply to lossless formats */ bool gsr_image_writer_write_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality); #endif /* GSR_IMAGE_WRITER_H */ fsdsfdsfdsfdsf-5.13.8/include/library_loader.h000066400000000000000000000007371520215207700214020ustar00rootroot00000000000000#ifndef GSR_LIBRARY_LOADER_H #define GSR_LIBRARY_LOADER_H #include typedef struct { void **func; const char *name; } dlsym_assign; void* dlsym_print_fail(void *handle, const char *name, bool required); /* |dlsyms| should be null terminated */ bool dlsym_load_list(void *handle, const dlsym_assign *dlsyms); /* |dlsyms| should be null terminated */ void dlsym_load_list_optional(void *handle, const dlsym_assign *dlsyms); #endif /* GSR_LIBRARY_LOADER_H */ fsdsfdsfdsfdsf-5.13.8/include/pipewire_audio.h000066400000000000000000000155041520215207700214130ustar00rootroot00000000000000#ifndef GSR_PIPEWIRE_AUDIO_H #define GSR_PIPEWIRE_AUDIO_H #include #include #include #include #include typedef enum { GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT, /* Application audio */ GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_INPUT, /* Audio recording input */ GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE /* Audio output or input device or combined (virtual) sink */ } gsr_pipewire_audio_node_type; typedef struct { uint32_t id; char *name; gsr_pipewire_audio_node_type type; } gsr_pipewire_audio_node; typedef enum { GSR_PIPEWIRE_AUDIO_PORT_DIRECTION_INPUT, GSR_PIPEWIRE_AUDIO_PORT_DIRECTION_OUTPUT } gsr_pipewire_audio_port_direction; typedef struct { uint32_t id; uint32_t node_id; gsr_pipewire_audio_port_direction direction; char *name; } gsr_pipewire_audio_port; typedef struct { uint32_t id; uint32_t output_node_id; uint32_t input_node_id; } gsr_pipewire_audio_link; typedef enum { GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM, /* Application */ GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK /* Combined (virtual) sink */ } gsr_pipewire_audio_link_input_type; typedef enum { GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD, GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT, GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT } gsr_pipewire_audio_requested_type; typedef struct { char *name; gsr_pipewire_audio_requested_type type; } gsr_pipewire_audio_requested_output; typedef struct { gsr_pipewire_audio_requested_output *outputs; int num_outputs; char *input_name; bool inverted; gsr_pipewire_audio_node_type output_type; gsr_pipewire_audio_link_input_type input_type; } gsr_pipewire_audio_requested_link; typedef struct { struct pw_thread_loop *thread_loop; struct pw_context *context; struct pw_core *core; struct spa_hook core_listener; struct pw_registry *registry; struct spa_hook registry_listener; int server_version_sync; struct pw_proxy *metadata_proxy; struct spa_hook metadata_listener; struct spa_hook metadata_proxy_listener; char default_output_device_name[128]; char default_input_device_name[128]; gsr_pipewire_audio_node *stream_nodes; size_t num_stream_nodes; size_t stream_nodes_capacity_items; gsr_pipewire_audio_port *ports; size_t num_ports; size_t ports_capacity_items; gsr_pipewire_audio_link *links; size_t num_links; size_t links_capacity_items; gsr_pipewire_audio_requested_link *requested_links; size_t num_requested_links; size_t requested_links_capacity_items; bool running; } gsr_pipewire_audio; bool gsr_pipewire_audio_init(gsr_pipewire_audio *self); void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self); /* This function links audio source outputs from applications that match the name |app_names| to the input that matches the name |stream_name_input|. If an application or a new application starts outputting audio after this function is called and the app name matches then it will automatically link the audio sources. |app_names| and |stream_name_input| are case-insensitive matches. */ bool gsr_pipewire_audio_add_link_from_apps_to_stream(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *stream_name_input); /* This function links audio source outputs from all applications except the ones that match the name |app_names| to the input that matches the name |stream_name_input|. If an application or a new application starts outputting audio after this function is called and the app name doesn't match then it will automatically link the audio sources. |app_names| and |stream_name_input| are case-insensitive matches. */ bool gsr_pipewire_audio_add_link_from_apps_to_stream_inverted(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *stream_name_input); /* This function links audio source outputs from applications that match the name |app_names| to the input that matches the name |sink_name_input|. If an application or a new application starts outputting audio after this function is called and the app name matches then it will automatically link the audio sources. |app_names| and |sink_name_input| are case-insensitive matches. */ bool gsr_pipewire_audio_add_link_from_apps_to_sink(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *sink_name_input); /* This function links audio source outputs from all applications except the ones that match the name |app_names| to the input that matches the name |sink_name_input|. If an application or a new application starts outputting audio after this function is called and the app name doesn't match then it will automatically link the audio sources. |app_names| and |sink_name_input| are case-insensitive matches. */ bool gsr_pipewire_audio_add_link_from_apps_to_sink_inverted(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *sink_name_input); /* This function links audio source outputs from devices that match the name |source_names| to the input that matches the name |stream_name_input|. If a device or a new device starts outputting audio after this function is called and the device name matches then it will automatically link the audio sources. |source_names| and |stream_name_input| are case-insensitive matches. |source_names| can include "default_output" or "default_input" to use the default output/input and it will automatically switch when the default output/input is changed in system audio settings. */ bool gsr_pipewire_audio_add_link_from_sources_to_stream(gsr_pipewire_audio *self, const char **source_names, int num_source_names, const char *stream_name_input); /* This function links audio source outputs from devices that match the name |source_names| to the input that matches the name |sink_name_input|. If a device or a new device starts outputting audio after this function is called and the device name matches then it will automatically link the audio sources. |source_names| and |sink_name_input| are case-insensitive matches. |source_names| can include "default_output" or "default_input" to use the default output/input and it will automatically switch when the default output/input is changed in system audio settings. */ bool gsr_pipewire_audio_add_link_from_sources_to_sink(gsr_pipewire_audio *self, const char **source_names, int num_source_names, const char *sink_name_input); /* Return true to continue */ typedef bool (*gsr_pipewire_audio_app_query_callback)(const char *app_name, void *userdata); void gsr_pipewire_audio_for_each_app(gsr_pipewire_audio *self, gsr_pipewire_audio_app_query_callback callback, void *userdata); #endif /* GSR_PIPEWIRE_AUDIO_H */ fsdsfdsfdsfdsf-5.13.8/include/pipewire_video.h000066400000000000000000000067731520215207700214300ustar00rootroot00000000000000#ifndef GSR_PIPEWIRE_VIDEO_H #define GSR_PIPEWIRE_VIDEO_H #include "defs.h" #include #include #include #include #include #define GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS 1024 #define GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS 10 #define GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES 4 typedef struct gsr_egl gsr_egl; typedef struct { int major; int minor; int micro; } gsr_pipewire_video_data_version; typedef struct { uint32_t fps_num; uint32_t fps_den; } gsr_pipewire_video_video_info; typedef struct { int fd; uint32_t offset; int32_t stride; } gsr_pipewire_video_dmabuf_data; typedef struct { int x, y; int width, height; } gsr_pipewire_video_region; typedef struct { enum spa_video_format format; size_t modifiers_index; size_t modifiers_size; } gsr_video_format; typedef struct { unsigned int texture_id; unsigned int external_texture_id; unsigned int cursor_texture_id; } gsr_texture_map; typedef struct { gsr_pipewire_video_region region; gsr_pipewire_video_region cursor_region; gsr_pipewire_video_dmabuf_data dmabuf_data[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES]; int num_dmabuf_data; uint32_t fourcc; uint64_t modifiers; bool using_external_image; gsr_monitor_rotation rotation; int texture_width; int texture_height; } gsr_map_texture_output; typedef struct { gsr_egl *egl; int fd; uint32_t node; pthread_mutex_t mutex; bool mutex_initialized; struct pw_thread_loop *thread_loop; struct pw_context *context; struct pw_core *core; struct spa_hook core_listener; struct pw_stream *stream; struct spa_hook stream_listener; struct spa_source *reneg; struct spa_video_info format; int server_version_sync; bool negotiated; bool damaged; bool has_modifier; struct { bool visible; bool valid; uint8_t *data; int x, y; int hotspot_x, hotspot_y; int width, height; } cursor; struct { bool valid; int x, y; uint32_t width, height; } crop; gsr_video_format supported_video_formats[GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS]; gsr_pipewire_video_data_version server_version; gsr_pipewire_video_video_info video_info; gsr_pipewire_video_dmabuf_data dmabuf_data[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES]; size_t dmabuf_num_planes; bool no_modifiers_fallback; bool external_texture_fallback; uint64_t modifiers[GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS]; size_t num_modifiers; bool paused; double paused_start_secs; bool streaming; gsr_monitor_rotation rotation; } gsr_pipewire_video; /* |capture_cursor| only applies to when capturing a window or region. In other cases |pipewire_node|'s setup will determine if the cursor is included. Note that the cursor is not guaranteed to be shown even if set to true, it depends on the wayland compositor. */ bool gsr_pipewire_video_init(gsr_pipewire_video *self, int pipewire_fd, uint32_t pipewire_node, int fps, bool capture_cursor, gsr_egl *egl); void gsr_pipewire_video_deinit(gsr_pipewire_video *self); bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map texture_map, gsr_map_texture_output *output); bool gsr_pipewire_video_is_damaged(gsr_pipewire_video *self); void gsr_pipewire_video_clear_damage(gsr_pipewire_video *self); bool gsr_pipewire_video_should_restart(gsr_pipewire_video *self); #endif /* GSR_PIPEWIRE_VIDEO_H */ fsdsfdsfdsfdsf-5.13.8/include/plugins.h000066400000000000000000000020171520215207700200620ustar00rootroot00000000000000#ifndef GSR_PLUGINS_H #define GSR_PLUGINS_H #include "../plugin/plugin.h" #include #include "color_conversion.h" #define GSR_MAX_PLUGINS 128 typedef bool (*gsr_plugin_init_func)(const gsr_plugin_init_params *params, gsr_plugin_init_return *ret); typedef void (*gsr_plugin_deinit_func)(void *userdata); typedef struct { gsr_plugin_init_return data; void *lib; gsr_plugin_init_func gsr_plugin_init; gsr_plugin_deinit_func gsr_plugin_deinit; } gsr_plugin; typedef struct { gsr_plugin plugins[GSR_MAX_PLUGINS]; int num_plugins; gsr_plugin_init_params init_params; gsr_egl *egl; unsigned int texture; gsr_color_conversion color_conversion; } gsr_plugins; bool gsr_plugins_init(gsr_plugins *self, gsr_plugin_init_params init_params, gsr_egl *egl); /* Plugins are unloaded in reverse order */ void gsr_plugins_deinit(gsr_plugins *self); bool gsr_plugins_load_plugin(gsr_plugins *self, const char *plugin_filepath); void gsr_plugins_draw(gsr_plugins *self); #endif /* GSR_PLUGINS_H */ fsdsfdsfdsfdsf-5.13.8/include/replay_buffer/000077500000000000000000000000001520215207700210555ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/include/replay_buffer/replay_buffer.h000066400000000000000000000051471520215207700240620ustar00rootroot00000000000000#ifndef GSR_REPLAY_BUFFER_H #define GSR_REPLAY_BUFFER_H #include "../defs.h" #include #include typedef struct gsr_replay_buffer gsr_replay_buffer; typedef struct { size_t packet_index; size_t file_index; } gsr_replay_buffer_iterator; struct gsr_replay_buffer { void (*destroy)(gsr_replay_buffer *self); bool (*append)(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp); void (*clear)(gsr_replay_buffer *self); AVPacket* (*iterator_get_packet)(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator); /* The returned data should be free'd with free */ uint8_t* (*iterator_get_packet_data)(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator); /* The clone has to be destroyed before the replay buffer it clones is destroyed */ gsr_replay_buffer* (*clone)(gsr_replay_buffer *self); /* Returns {0, 0} if replay buffer is empty */ gsr_replay_buffer_iterator (*find_packet_index_by_time_passed)(gsr_replay_buffer *self, int seconds); /* Returns {-1, 0} if not found */ gsr_replay_buffer_iterator (*find_keyframe)(gsr_replay_buffer *self, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index); bool (*iterator_next)(gsr_replay_buffer *self, gsr_replay_buffer_iterator *iterator); }; gsr_replay_buffer* gsr_replay_buffer_create(gsr_replay_storage replay_storage, const char *replay_directory, double replay_buffer_time, size_t replay_buffer_num_packets); void gsr_replay_buffer_destroy(gsr_replay_buffer *self); bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp); void gsr_replay_buffer_clear(gsr_replay_buffer *self); AVPacket* gsr_replay_buffer_iterator_get_packet(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator); /* The returned data should be free'd with free */ uint8_t* gsr_replay_buffer_iterator_get_packet_data(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator); /* The clone has to be destroyed before the replay buffer it clones is destroyed */ gsr_replay_buffer* gsr_replay_buffer_clone(gsr_replay_buffer *self); /* Returns {0, 0} if replay buffer is empty */ gsr_replay_buffer_iterator gsr_replay_buffer_find_packet_index_by_time_passed(gsr_replay_buffer *self, int seconds); /* Returns {-1, 0} if not found */ gsr_replay_buffer_iterator gsr_replay_buffer_find_keyframe(gsr_replay_buffer *self, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index); bool gsr_replay_buffer_iterator_next(gsr_replay_buffer *self, gsr_replay_buffer_iterator *iterator); #endif /* GSR_REPLAY_BUFFER_H */fsdsfdsfdsfdsf-5.13.8/include/replay_buffer/replay_buffer_disk.h000066400000000000000000000021501520215207700250630ustar00rootroot00000000000000#ifndef GSR_REPLAY_BUFFER_DISK_H #define GSR_REPLAY_BUFFER_DISK_H #include "replay_buffer.h" #include #define GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES 1024 typedef struct { AVPacket packet; size_t data_index; double timestamp; } gsr_av_packet_disk; typedef struct { size_t id; double start_timestamp; double end_timestamp; int ref_counter; int fd; gsr_av_packet_disk *packets; size_t capacity_num_packets; size_t num_packets; } gsr_replay_buffer_file; typedef struct { gsr_replay_buffer replay_buffer; double replay_buffer_time; size_t storage_counter; size_t storage_num_bytes_written; int storage_fd; gsr_replay_buffer_file *files[GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES]; // GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES * REPLAY_BUFFER_FILE_SIZE_BYTES = 256gb, should be enough for everybody size_t num_files; char replay_directory[PATH_MAX]; bool owns_directory; } gsr_replay_buffer_disk; gsr_replay_buffer* gsr_replay_buffer_disk_create(const char *replay_directory, double replay_buffer_time); #endif /* GSR_REPLAY_BUFFER_DISK_H */fsdsfdsfdsfdsf-5.13.8/include/replay_buffer/replay_buffer_ram.h000066400000000000000000000007701520215207700247160ustar00rootroot00000000000000#ifndef GSR_REPLAY_BUFFER_RAM_H #define GSR_REPLAY_BUFFER_RAM_H #include "replay_buffer.h" typedef struct { AVPacket packet; int ref_counter; double timestamp; } gsr_av_packet_ram; typedef struct { gsr_replay_buffer replay_buffer; gsr_av_packet_ram **packets; size_t capacity_num_packets; size_t num_packets; size_t index; } gsr_replay_buffer_ram; gsr_replay_buffer* gsr_replay_buffer_ram_create(size_t replay_buffer_num_packets); #endif /* GSR_REPLAY_BUFFER_RAM_H */fsdsfdsfdsfdsf-5.13.8/include/shader.h000066400000000000000000000012001520215207700176400ustar00rootroot00000000000000#ifndef GSR_SHADER_H #define GSR_SHADER_H #include typedef struct gsr_egl gsr_egl; typedef struct { gsr_egl *egl; unsigned int program_id; } gsr_shader; /* |vertex_shader| or |fragment_shader| may be NULL */ int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader); void gsr_shader_deinit(gsr_shader *self); int gsr_shader_bind_attribute_location(gsr_shader *self, const char *attribute, int location); void gsr_shader_use(gsr_shader *self); void gsr_shader_use_none(gsr_shader *self); void gsr_shader_enable_debug_output(bool enable); #endif /* GSR_SHADER_H */ fsdsfdsfdsfdsf-5.13.8/include/sound.hpp000066400000000000000000000047271520215207700201030ustar00rootroot00000000000000/* Copyright (C) 2020 dec05eba 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 . */ #ifndef GPU_SCREEN_RECORDER_H #define GPU_SCREEN_RECORDER_H #include #include typedef struct { void *handle; unsigned int frames; } SoundDevice; struct AudioDevice { std::string name; std::string description; }; struct AudioDevices { std::string default_output; std::string default_input; std::vector audio_inputs; }; enum class AudioInputType { DEVICE, APPLICATION }; struct AudioInput { std::string name; AudioInputType type = AudioInputType::DEVICE; bool inverted = false; }; struct MergedAudioInputs { std::string track_name; std::vector audio_inputs; }; typedef enum { S16, S32, F32 } AudioFormat; /* Get a sound device by name, returning the device into the |device| parameter. |device_name| can be a device name or "default_output", "default_input" or "" to not connect to any device (used for app audio for example). If the device name is "default_output" or "default_input" then it will automatically switch which device is records from when the default output/input is changed in the system audio settings. Returns 0 on success, or a negative value on failure. */ int sound_device_get_by_name(SoundDevice *device, const char *node_name, const char *device_name, const char *description, unsigned int num_channels, unsigned int period_frame_size, AudioFormat audio_format); void sound_device_close(SoundDevice *device); /* Returns the next chunk of audio into @buffer. Returns the number of frames read, or a negative value on failure. */ int sound_device_read_next_chunk(SoundDevice *device, void **buffer, double timeout_sec, double *latency_seconds); AudioDevices get_pulseaudio_inputs(); bool pulseaudio_server_is_pipewire(); #endif /* GPU_SCREEN_RECORDER_H */ fsdsfdsfdsfdsf-5.13.8/include/utils.h000066400000000000000000000057131520215207700175470ustar00rootroot00000000000000#ifndef GSR_UTILS_H #define GSR_UTILS_H #include "vec2.h" #include "../include/egl.h" #include "../include/defs.h" #include #include typedef struct AVCodecContext AVCodecContext; typedef struct AVFrame AVFrame; typedef struct gsr_capture_metadata gsr_capture_metadata; typedef struct { const char *name; int name_len; vec2i pos; /* This is 0, 0 on wayland. Use |drm_monitor_get_display_server_data| to get the position */ vec2i size; vec2i logical_pos; vec2i logical_size; uint32_t connector_id; /* Only on x11 and drm */ gsr_monitor_rotation rotation; /* Only on x11 and wayland */ uint32_t monitor_identifier; /* On x11 this is the crtc id */ } gsr_monitor; typedef struct { const char *name; int name_len; gsr_monitor *monitor; bool found_monitor; } get_monitor_by_name_userdata; double clock_get_monotonic_seconds(void); bool generate_random_characters(char *buffer, int buffer_size, const char *alphabet, size_t alphabet_size); bool generate_random_characters_standard_alphabet(char *buffer, int buffer_size); typedef void (*active_monitor_callback)(const gsr_monitor *monitor, void *userdata); void for_each_active_monitor_output_x11_not_cached(Display *display, active_monitor_callback callback, void *userdata); void for_each_active_monitor_output(const gsr_window *window, const char *card_path, gsr_connection_type connection_type, active_monitor_callback callback, void *userdata); bool get_monitor_by_name(const gsr_egl *egl, gsr_connection_type connection_type, const char *name, gsr_monitor *monitor); bool drm_monitor_get_display_server_data(const gsr_window *window, const gsr_monitor *monitor, gsr_monitor_rotation *monitor_rotation, vec2i *monitor_position); int get_connector_type_by_name(const char *name); int get_connector_type_id_by_name(const char *name); uint32_t monitor_identifier_from_type_and_count(int monitor_type_index, int monitor_type_count); bool gl_get_gpu_info(gsr_egl *egl, gsr_gpu_info *info); bool try_card_has_valid_plane(const char *card_path); /* |output| should be at least 128 bytes in size */ bool gsr_get_valid_card_path(gsr_egl *egl, char *output, bool is_monitor_capture); /* |render_path| should be at least 128 bytes in size */ bool gsr_card_path_get_render_path(const char *card_path, char *render_path); int create_directory_recursive(char *path); /* |img_attr| needs to be at least 44 in size */ void setup_dma_buf_attrs(intptr_t *img_attr, uint32_t format, uint32_t width, uint32_t height, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, int num_planes, bool use_modifier); vec2i scale_keep_aspect_ratio(vec2i from, vec2i to); vec2i gsr_capture_get_target_position(vec2i output_size, gsr_capture_metadata *capture_metadata); unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format, int filter); bool get_nvidia_driver_version(int *major, int *minor); #endif /* GSR_UTILS_H */ fsdsfdsfdsfdsf-5.13.8/include/vec2.h000066400000000000000000000002631520215207700172410ustar00rootroot00000000000000#ifndef VEC2_H #define VEC2_H typedef struct { int x, y; } vec2i; typedef struct { float x, y; } vec2f; typedef struct { double x, y; } vec2d; #endif /* VEC2_H */ fsdsfdsfdsfdsf-5.13.8/include/window/000077500000000000000000000000001520215207700175375ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/include/window/wayland.h000066400000000000000000000002401520215207700213430ustar00rootroot00000000000000#ifndef GSR_WINDOW_WAYLAND_H #define GSR_WINDOW_WAYLAND_H #include "window.h" gsr_window* gsr_window_wayland_create(void); #endif /* GSR_WINDOW_WAYLAND_H */ fsdsfdsfdsfdsf-5.13.8/include/window/window.h000066400000000000000000000023671520215207700212270ustar00rootroot00000000000000#ifndef GSR_WINDOW_H #define GSR_WINDOW_H #include "../utils.h" #include typedef union _XEvent XEvent; typedef struct gsr_window gsr_window; typedef enum { GSR_DISPLAY_SERVER_X11, GSR_DISPLAY_SERVER_WAYLAND } gsr_display_server; struct gsr_window { void (*destroy)(gsr_window *self); /* Returns true if an event is available */ bool (*process_event)(gsr_window *self); XEvent* (*get_event_data)(gsr_window *self); /* can be NULL */ gsr_display_server (*get_display_server)(void); void* (*get_display)(gsr_window *self); void* (*get_window)(gsr_window *self); void (*for_each_active_monitor_output_cached)(const gsr_window *self, active_monitor_callback callback, void *userdata); void *priv; }; void gsr_window_destroy(gsr_window *self); /* Returns true if an event is available */ bool gsr_window_process_event(gsr_window *self); XEvent* gsr_window_get_event_data(gsr_window *self); gsr_display_server gsr_window_get_display_server(const gsr_window *self); void* gsr_window_get_display(gsr_window *self); void* gsr_window_get_window(gsr_window *self); void gsr_window_for_each_active_monitor_output_cached(const gsr_window *self, active_monitor_callback callback, void *userdata); #endif /* GSR_WINDOW_H */ fsdsfdsfdsfdsf-5.13.8/include/window/x11.h000066400000000000000000000002771520215207700203270ustar00rootroot00000000000000#ifndef GSR_WINDOW_X11_H #define GSR_WINDOW_X11_H #include "window.h" typedef struct _XDisplay Display; gsr_window* gsr_window_x11_create(Display *display); #endif /* GSR_WINDOW_X11_H */ fsdsfdsfdsfdsf-5.13.8/include/window_texture.h000066400000000000000000000013531520215207700214720ustar00rootroot00000000000000#ifndef WINDOW_TEXTURE_H #define WINDOW_TEXTURE_H #include "egl.h" typedef struct { Display *display; Window window; Pixmap pixmap; EGLImage image; unsigned int texture_id; int redirected; gsr_egl *egl; unsigned int window_width; unsigned int window_height; } WindowTexture; /* Returns 0 on success */ int window_texture_init(WindowTexture *window_texture, Display *display, Window window, gsr_egl *egl); void window_texture_deinit(WindowTexture *self); /* This should ONLY be called when the target window is resized. Returns 0 on success. */ int window_texture_on_resize(WindowTexture *self); unsigned int window_texture_get_opengl_texture_id(WindowTexture *self); #endif /* WINDOW_TEXTURE_H */ fsdsfdsfdsfdsf-5.13.8/install.sh000077500000000000000000000006611520215207700166150ustar00rootroot00000000000000#!/bin/sh -e script_dir=$(dirname "$0") cd "$script_dir" [ $(id -u) -ne 0 ] && echo "You need root privileges to run the install script" && exit 1 echo "Warning: this install.sh script is deprecated. Use meson directly instead if possible" rm -rf build meson setup build meson configure --prefix=/usr --buildtype=release -Dsystemd=true -Dstrip=true build ninja -C build install echo "Successfully installed gpu-screen-recorder" fsdsfdsfdsfdsf-5.13.8/kms/000077500000000000000000000000001520215207700153775ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/kms/client/000077500000000000000000000000001520215207700166555ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/kms/client/kms_client.c000066400000000000000000000434311520215207700211560ustar00rootroot00000000000000#include "kms_client.h" #include "../../include/utils.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __linux__ #include #endif #ifdef __FreeBSD__ #include #endif #define GSR_SOCKET_PAIR_LOCAL 0 #define GSR_SOCKET_PAIR_REMOTE 1 static void cleanup_socket(gsr_kms_client *self, bool kill_server); static int gsr_kms_client_replace_connection(gsr_kms_client *self); static void close_fds(gsr_kms_response *response) { for(int i = 0; i < response->num_items; ++i) { for(int j = 0; j < response->items[i].num_dma_bufs; ++j) { gsr_kms_response_dma_buf *dma_buf = &response->items[i].dma_buf[j]; if(dma_buf->fd > 0) { close(dma_buf->fd); dma_buf->fd = -1; } } response->items[i].num_dma_bufs = 0; } response->num_items = 0; } static int send_msg_to_server(int server_fd, gsr_kms_request *request) { struct iovec iov; iov.iov_base = request; iov.iov_len = sizeof(*request); struct msghdr response_message = {0}; response_message.msg_iov = &iov; response_message.msg_iovlen = 1; char cmsgbuf[CMSG_SPACE(sizeof(int) * 1)]; memset(cmsgbuf, 0, sizeof(cmsgbuf)); if(request->new_connection_fd > 0) { response_message.msg_control = cmsgbuf; response_message.msg_controllen = sizeof(cmsgbuf); struct cmsghdr *cmsg = CMSG_FIRSTHDR(&response_message); cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_len = CMSG_LEN(sizeof(int) * 1); int *fds = (int*)CMSG_DATA(cmsg); fds[0] = request->new_connection_fd; response_message.msg_controllen = cmsg->cmsg_len; } return sendmsg(server_fd, &response_message, 0); } static int recv_msg_from_server(int server_pid, int server_fd, gsr_kms_response *response) { struct iovec iov; iov.iov_base = response; iov.iov_len = sizeof(*response); struct msghdr response_message = {0}; response_message.msg_iov = &iov; response_message.msg_iovlen = 1; char cmsgbuf[CMSG_SPACE(sizeof(int) * GSR_KMS_MAX_ITEMS * GSR_KMS_MAX_DMA_BUFS)]; memset(cmsgbuf, 0, sizeof(cmsgbuf)); response_message.msg_control = cmsgbuf; response_message.msg_controllen = sizeof(cmsgbuf); int res = 0; for(;;) { res = recvmsg(server_fd, &response_message, MSG_DONTWAIT); if(res <= 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) { // If we are replacing the connection and closing the application at the same time // then recvmsg can get stuck (because the server died), so we prevent that by doing // non-blocking recvmsg and checking if the server died int status = 0; int wait_result = waitpid(server_pid, &status, WNOHANG); if(wait_result != 0) { res = -1; break; } usleep(1000); } else { break; } } if(res > 0 && response->num_items > 0) { struct cmsghdr *cmsg = CMSG_FIRSTHDR(&response_message); if(cmsg) { int *fds = (int*)CMSG_DATA(cmsg); int fd_index = 0; for(int i = 0; i < response->num_items; ++i) { for(int j = 0; j < response->items[i].num_dma_bufs; ++j) { gsr_kms_response_dma_buf *dma_buf = &response->items[i].dma_buf[j]; dma_buf->fd = fds[fd_index++]; } } } else { close_fds(response); } } return res; } /* We have to use $HOME because in flatpak there is no simple path that is accessible, read and write, that multiple flatpak instances can access */ static bool create_socket_path(char *output_path, size_t output_path_size) { const bool inside_flatpak = getenv("FLATPAK_ID") != NULL; const char *home = getenv("HOME"); // Portable home with AppImage can cause the socket path to be longer than 108 characters (unix domain socket path max length). // Using gsr-kms-socket in $HOME is only needed in flatpak, so use /tmp everywhere else instead. if(!home || !inside_flatpak) home = "/tmp"; char random_characters[11]; random_characters[10] = '\0'; if(!generate_random_characters_standard_alphabet(random_characters, 10)) return false; snprintf(output_path, output_path_size, "%s/.gsr-kms-socket-%s", home, random_characters); return true; } #ifdef __linux__ static bool readlink_realpath(const char *filepath, char *buffer) { char symlinked_path[PATH_MAX]; ssize_t bytes_written = readlink(filepath, symlinked_path, sizeof(symlinked_path) - 1); if(bytes_written == -1 && errno == EINVAL) { /* Not a symlink */ snprintf(symlinked_path, sizeof(symlinked_path), "%s", filepath); } else if(bytes_written == -1) { return false; } else { symlinked_path[bytes_written] = '\0'; } if(!realpath(symlinked_path, buffer)) return false; return true; } #endif static bool strcat_safe(char *str, int size, const char *str_to_add) { const int str_len = strlen(str); const int str_to_add_len = strlen(str_to_add); if(str_len + str_to_add_len + 1 >= size) return false; memcpy(str + str_len, str_to_add, str_to_add_len); str[str_len + str_to_add_len] = '\0'; return true; } static void file_get_directory(char *filepath) { char *end = strrchr(filepath, '/'); if(end == NULL) filepath[0] = '\0'; else *end = '\0'; } static bool find_program_in_path(const char *program_name, char *filepath, int filepath_len) { const char *path = getenv("PATH"); if(!path) return false; int program_name_len = strlen(program_name); const char *end = path + strlen(path); while(path != end) { const char *part_end = strchr(path, ':'); const char *next = part_end; if(part_end) { next = part_end + 1; } else { part_end = end; next = end; } int len = part_end - path; if(len + 1 + program_name_len < filepath_len) { memcpy(filepath, path, len); filepath[len] = '/'; memcpy(filepath + len + 1, program_name, program_name_len); filepath[len + 1 + program_name_len] = '\0'; if(access(filepath, F_OK) == 0) return true; } path = next; } return false; } int gsr_kms_client_init(gsr_kms_client *self, const char *card_path) { int result = -1; self->kms_server_pid = -1; self->initial_socket_fd = -1; self->initial_client_fd = -1; self->initial_socket_path[0] = '\0'; self->socket_pair[0] = -1; self->socket_pair[1] = -1; struct sockaddr_un local_addr = {0}; struct sockaddr_un remote_addr = {0}; if(!create_socket_path(self->initial_socket_path, sizeof(self->initial_socket_path))) { fprintf(stderr, "gsr error: gsr_kms_client_init: failed to create path to kms socket\n"); return -1; } char server_filepath[PATH_MAX]; #ifdef __linux__ if(!readlink_realpath("/proc/self/exe", server_filepath)) { fprintf(stderr, "gsr error: gsr_kms_client_init: failed to resolve /proc/self/exe\n"); return -1; } #elif defined(__FreeBSD__) int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, getpid() }; size_t size = PATH_MAX; if (sysctl(mib, 4, server_filepath, &size, NULL, 0) != 0) { fprintf(stderr, "gsr error: gsr_kms_client_init: failed to resolve pathname using sysctl\n"); return -1; } #else #error "Implement it by yourself" #endif file_get_directory(server_filepath); if(!strcat_safe(server_filepath, sizeof(server_filepath), "/gsr-kms-server")) { fprintf(stderr, "gsr error: gsr_kms_client_init: gsr-kms-server path too long\n"); return -1; } if(access(server_filepath, F_OK) != 0) { fprintf(stderr, "gsr info: gsr_kms_client_init: gsr-kms-server is not installed in the same directory as gpu-screen-recorder (%s not found), looking for gsr-kms-server in PATH instead\n", server_filepath); if(!find_program_in_path("gsr-kms-server", server_filepath, sizeof(server_filepath)) || access(server_filepath, F_OK) != 0) { fprintf(stderr, "gsr error: gsr_kms_client_init: gsr-kms-server was not found in PATH. Please install gpu-screen-recorder properly\n"); return -1; } } fprintf(stderr, "gsr info: gsr_kms_client_init: setting up connection to %s\n", server_filepath); const bool inside_flatpak = getenv("FLATPAK_ID") != NULL; const char *home = getenv("HOME"); if(!home) home = "/tmp"; bool has_perm = 0; if(geteuid() == 0) { has_perm = true; } else { #ifdef __linux__ cap_t kms_server_cap = cap_get_file(server_filepath); if(kms_server_cap) { cap_flag_value_t res = CAP_CLEAR; cap_get_flag(kms_server_cap, CAP_SYS_ADMIN, CAP_PERMITTED, &res); if(res == CAP_SET) { //fprintf(stderr, "has permission!\n"); has_perm = true; } else { //fprintf(stderr, "No permission:(\n"); } cap_free(kms_server_cap); } else if(!inside_flatpak) { if(errno == ENODATA) fprintf(stderr, "gsr info: gsr_kms_client_init: gsr-kms-server is missing sys_admin cap and will require root authentication. To bypass this automatically, run: sudo setcap cap_sys_admin+ep '%s'\n", server_filepath); else fprintf(stderr, "gsr info: gsr_kms_client_init: failed to get cap\n"); } #else fprintf(stderr, "gsr info: gsr_kms_client_init: platform doesn't support cap\n"); #endif } if(socketpair(AF_UNIX, SOCK_STREAM, 0, self->socket_pair) == -1) { fprintf(stderr, "gsr error: gsr_kms_client_init: socketpair failed, error: %s\n", strerror(errno)); goto err; } self->initial_socket_fd = socket(AF_UNIX, SOCK_STREAM, 0); if(self->initial_socket_fd == -1) { fprintf(stderr, "gsr error: gsr_kms_client_init: socket failed, error: %s\n", strerror(errno)); goto err; } local_addr.sun_family = AF_UNIX; snprintf(local_addr.sun_path, sizeof(local_addr.sun_path), "%s", (const char*)self->initial_socket_path); const mode_t prev_mask = umask(0000); const int bind_res = bind(self->initial_socket_fd, (struct sockaddr*)&local_addr, sizeof(local_addr.sun_family) + strlen(local_addr.sun_path)); umask(prev_mask); if(bind_res == -1) { fprintf(stderr, "gsr error: gsr_kms_client_init: failed to bind socket, error: %s\n", strerror(errno)); goto err; } if(listen(self->initial_socket_fd, 1) == -1) { fprintf(stderr, "gsr error: gsr_kms_client_init: failed to listen on socket, error: %s\n", strerror(errno)); goto err; } pid_t pid = fork(); if(pid == -1) { fprintf(stderr, "gsr error: gsr_kms_client_init: fork failed, error: %s\n", strerror(errno)); goto err; } else if(pid == 0) { /* child */ if(inside_flatpak) { const char *args[] = { "flatpak-spawn", "--host", "/var/lib/flatpak/app/com.dec05eba.gpu_screen_recorder/current/active/files/bin/kms-server-proxy", self->initial_socket_path, card_path, home, NULL }; execvp(args[0], (char *const*)args); } else if(has_perm) { const char *args[] = { server_filepath, self->initial_socket_path, card_path, NULL }; execvp(args[0], (char *const*)args); } else { const char *args[] = { "pkexec", server_filepath, self->initial_socket_path, card_path, NULL }; execvp(args[0], (char *const*)args); } fprintf(stderr, "gsr error: gsr_kms_client_init: failed to launch \"gsr-kms-server\", error: %s\n", strerror(errno)); _exit(127); } else { /* parent */ self->kms_server_pid = pid; } // We need this dumb-shit retardation with unix domain socket and then replace it with socketpair because // pkexec doesn't work with socketpair................ fprintf(stderr, "gsr info: gsr_kms_client_init: waiting for server to connect\n"); struct pollfd poll_fd = { .fd = self->initial_socket_fd, .events = POLLIN, .revents = 0 }; for(;;) { int poll_res = poll(&poll_fd, 1, 100); if(poll_res > 0 && (poll_fd.revents & POLLIN)) { socklen_t sock_len = 0; self->initial_client_fd = accept(self->initial_socket_fd, (struct sockaddr*)&remote_addr, &sock_len); if(self->initial_client_fd == -1) { fprintf(stderr, "gsr error: gsr_kms_client_init: accept failed on socket, error: %s\n", strerror(errno)); goto err; } break; } else { int status = 0; int wait_result = waitpid(self->kms_server_pid, &status, WNOHANG); if(wait_result != 0) { int exit_code = -1; if(WIFEXITED(status)) exit_code = WEXITSTATUS(status); fprintf(stderr, "gsr error: gsr_kms_client_init: kms server died or never started, exit code: %d\n", exit_code); self->kms_server_pid = -1; if(exit_code != 0) result = exit_code; goto err; } } poll_fd.revents = 0; } fprintf(stderr, "gsr info: gsr_kms_client_init: server connected\n"); fprintf(stderr, "gsr info: replacing file-backed unix domain socket with socketpair\n"); if(gsr_kms_client_replace_connection(self) != 0) goto err; cleanup_socket(self, false); fprintf(stderr, "gsr info: using socketpair\n"); return 0; err: gsr_kms_client_deinit(self); return result; } void cleanup_socket(gsr_kms_client *self, bool kill_server) { if(self->initial_client_fd > 0) { close(self->initial_client_fd); self->initial_client_fd = -1; } if(self->initial_socket_fd > 0) { close(self->initial_socket_fd); self->initial_socket_fd = -1; } if(kill_server) { for(int i = 0; i < 2; ++i) { if(self->socket_pair[i] > 0) { close(self->socket_pair[i]); self->socket_pair[i] = -1; } } } if(kill_server && self->kms_server_pid > 0) { kill(self->kms_server_pid, SIGKILL); // TODO: //int status; //waitpid(self->kms_server_pid, &status, 0); self->kms_server_pid = -1; } if(self->initial_socket_path[0] != '\0') { remove(self->initial_socket_path); self->initial_socket_path[0] = '\0'; } } void gsr_kms_client_deinit(gsr_kms_client *self) { cleanup_socket(self, true); } int gsr_kms_client_replace_connection(gsr_kms_client *self) { gsr_kms_response response; response.version = 0; response.result = KMS_RESULT_FAILED_TO_SEND; response.err_msg[0] = '\0'; gsr_kms_request request; request.version = GSR_KMS_PROTOCOL_VERSION; request.type = KMS_REQUEST_TYPE_REPLACE_CONNECTION; request.new_connection_fd = self->socket_pair[GSR_SOCKET_PAIR_REMOTE]; if(send_msg_to_server(self->initial_client_fd, &request) == -1) { fprintf(stderr, "gsr error: gsr_kms_client_replace_connection: failed to send request message to server\n"); return -1; } const int recv_res = recv_msg_from_server(self->kms_server_pid, self->socket_pair[GSR_SOCKET_PAIR_LOCAL], &response); if(recv_res == 0) { fprintf(stderr, "gsr warning: gsr_kms_client_replace_connection: kms server shut down\n"); return -1; } else if(recv_res == -1) { fprintf(stderr, "gsr error: gsr_kms_client_replace_connection: failed to receive response\n"); return -1; } if(response.version != GSR_KMS_PROTOCOL_VERSION) { fprintf(stderr, "gsr error: gsr_kms_client_replace_connection: expected gsr-kms-server protocol version to be %u, but it's %u. please reinstall gpu screen recorder\n", GSR_KMS_PROTOCOL_VERSION, response.version); /*close_fds(response);*/ return -1; } return 0; } int gsr_kms_client_get_kms(gsr_kms_client *self, gsr_kms_response *response) { response->version = 0; response->result = KMS_RESULT_FAILED_TO_SEND; response->err_msg[0] = '\0'; response->num_items = 0; gsr_kms_request request; request.version = GSR_KMS_PROTOCOL_VERSION; request.type = KMS_REQUEST_TYPE_GET_KMS; request.new_connection_fd = 0; if(send_msg_to_server(self->socket_pair[GSR_SOCKET_PAIR_LOCAL], &request) == -1) { fprintf(stderr, "gsr error: gsr_kms_client_get_kms: failed to send request message to server\n"); strcpy(response->err_msg, "failed to send"); return -1; } const int recv_res = recv_msg_from_server(self->kms_server_pid, self->socket_pair[GSR_SOCKET_PAIR_LOCAL], response); if(recv_res == 0) { fprintf(stderr, "gsr warning: gsr_kms_client_get_kms: kms server shut down\n"); strcpy(response->err_msg, "failed to receive"); return -1; } else if(recv_res == -1) { fprintf(stderr, "gsr error: gsr_kms_client_get_kms: failed to receive response\n"); strcpy(response->err_msg, "failed to receive"); return -1; } if(response->version != GSR_KMS_PROTOCOL_VERSION) { fprintf(stderr, "gsr error: gsr_kms_client_get_kms: expected gsr-kms-server protocol version to be %u, but it's %u. please reinstall gpu screen recorder\n", GSR_KMS_PROTOCOL_VERSION, response->version); /*close_fds(response);*/ strcpy(response->err_msg, "mismatching protocol version"); return -1; } return 0; } fsdsfdsfdsfdsf-5.13.8/kms/client/kms_client.h000066400000000000000000000012121520215207700211520ustar00rootroot00000000000000#ifndef GSR_KMS_CLIENT_H #define GSR_KMS_CLIENT_H #include "../kms_shared.h" #include #include typedef struct gsr_kms_client gsr_kms_client; struct gsr_kms_client { pid_t kms_server_pid; int initial_socket_fd; int initial_client_fd; char initial_socket_path[PATH_MAX]; int socket_pair[2]; }; /* |card_path| should be a path to card, for example /dev/dri/card0 */ int gsr_kms_client_init(gsr_kms_client *self, const char *card_path); void gsr_kms_client_deinit(gsr_kms_client *self); int gsr_kms_client_get_kms(gsr_kms_client *self, gsr_kms_response *response); #endif /* #define GSR_KMS_CLIENT_H */ fsdsfdsfdsfdsf-5.13.8/kms/kms_shared.h000066400000000000000000000033021520215207700176660ustar00rootroot00000000000000#ifndef GSR_KMS_SHARED_H #define GSR_KMS_SHARED_H #include #include #include #define GSR_KMS_PROTOCOL_VERSION 5 #define GSR_KMS_MAX_ITEMS 8 #define GSR_KMS_MAX_DMA_BUFS 4 typedef struct gsr_kms_response_dma_buf gsr_kms_response_dma_buf; typedef struct gsr_kms_response_item gsr_kms_response_item; typedef struct gsr_kms_response gsr_kms_response; typedef enum { KMS_REQUEST_TYPE_REPLACE_CONNECTION, KMS_REQUEST_TYPE_GET_KMS } gsr_kms_request_type; typedef enum { KMS_RESULT_OK, KMS_RESULT_INVALID_REQUEST, KMS_RESULT_FAILED_TO_GET_PLANE, KMS_RESULT_FAILED_TO_GET_PLANES, KMS_RESULT_FAILED_TO_SEND } gsr_kms_result; typedef struct { uint32_t version; /* GSR_KMS_PROTOCOL_VERSION */ int type; /* gsr_kms_request_type */ int new_connection_fd; } gsr_kms_request; struct gsr_kms_response_dma_buf { int fd; uint32_t pitch; uint32_t offset; }; typedef enum { KMS_ROT_0, KMS_ROT_90, KMS_ROT_180, KMS_ROT_270 } gsr_kms_rotation; struct gsr_kms_response_item { gsr_kms_response_dma_buf dma_buf[GSR_KMS_MAX_DMA_BUFS]; int num_dma_bufs; uint32_t width; uint32_t height; uint32_t pixel_format; uint64_t modifier; uint32_t connector_id; /* 0 if unknown */ bool is_cursor; bool has_hdr_metadata; gsr_kms_rotation rotation; int x; int y; int src_w; int src_h; struct hdr_output_metadata hdr_metadata; }; struct gsr_kms_response { uint32_t version; /* GSR_KMS_PROTOCOL_VERSION */ int result; /* gsr_kms_result */ char err_msg[128]; gsr_kms_response_item items[GSR_KMS_MAX_ITEMS]; int num_items; }; #endif /* #define GSR_KMS_SHARED_H */ fsdsfdsfdsfdsf-5.13.8/kms/server/000077500000000000000000000000001520215207700167055ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/kms/server/.gitignore000066400000000000000000000000141520215207700206700ustar00rootroot00000000000000sibs-build/ fsdsfdsfdsfdsf-5.13.8/kms/server/kms_server.c000066400000000000000000000556171520215207700212470ustar00rootroot00000000000000#ifndef _GNU_SOURCE #define _GNU_SOURCE #endif #include "../kms_shared.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define MAX_CONNECTORS 32 typedef struct { int drmfd; } gsr_drm; typedef struct { uint32_t connector_id; uint64_t crtc_id; uint64_t hdr_metadata_blob_id; } connector_crtc_pair; typedef struct { connector_crtc_pair maps[MAX_CONNECTORS]; int num_maps; } connector_to_crtc_map; static int max_int(int a, int b) { return a > b ? a : b; } static int count_num_fds(const gsr_kms_response *response) { int num_fds = 0; for(int i = 0; i < response->num_items; ++i) { num_fds += response->items[i].num_dma_bufs; } return num_fds; } static int send_msg_to_client(int client_fd, gsr_kms_response *response) { struct iovec iov; iov.iov_base = response; iov.iov_len = sizeof(*response); struct msghdr response_message = {0}; response_message.msg_iov = &iov; response_message.msg_iovlen = 1; const int num_fds = count_num_fds(response); char cmsgbuf[CMSG_SPACE(sizeof(int) * max_int(1, num_fds))]; memset(cmsgbuf, 0, sizeof(cmsgbuf)); if(num_fds > 0) { response_message.msg_control = cmsgbuf; response_message.msg_controllen = sizeof(cmsgbuf); struct cmsghdr *cmsg = CMSG_FIRSTHDR(&response_message); cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_len = CMSG_LEN(sizeof(int) * num_fds); int *fds = (int*)CMSG_DATA(cmsg); int fd_index = 0; for(int i = 0; i < response->num_items; ++i) { for(int j = 0; j < response->items[i].num_dma_bufs; ++j) { fds[fd_index++] = response->items[i].dma_buf[j].fd; } } response_message.msg_controllen = cmsg->cmsg_len; } return sendmsg(client_fd, &response_message, 0); } static int recv_msg_from_client(int client_fd, gsr_kms_request *request) { struct iovec iov; iov.iov_base = request; iov.iov_len = sizeof(*request); struct msghdr response_message = {0}; response_message.msg_iov = &iov; response_message.msg_iovlen = 1; char cmsgbuf[CMSG_SPACE(sizeof(int) * 1)]; memset(cmsgbuf, 0, sizeof(cmsgbuf)); response_message.msg_control = cmsgbuf; response_message.msg_controllen = sizeof(cmsgbuf); int res = recvmsg(client_fd, &response_message, MSG_WAITALL); if(res <= 0) return res; if(request->new_connection_fd > 0) { struct cmsghdr *cmsg = CMSG_FIRSTHDR(&response_message); if(cmsg) { int *fds = (int*)CMSG_DATA(cmsg); request->new_connection_fd = fds[0]; } else { if(request->new_connection_fd > 0) { close(request->new_connection_fd); request->new_connection_fd = 0; } } } return res; } static bool connector_get_property_by_name(int drmfd, drmModeConnectorPtr props, const char *name, uint64_t *result) { for(int i = 0; i < props->count_props; ++i) { drmModePropertyPtr prop = drmModeGetProperty(drmfd, props->props[i]); if(prop) { if(strcmp(name, prop->name) == 0) { *result = props->prop_values[i]; drmModeFreeProperty(prop); return true; } drmModeFreeProperty(prop); } } return false; } typedef enum { PLANE_PROPERTY_X = 1 << 0, PLANE_PROPERTY_Y = 1 << 1, PLANE_PROPERTY_SRC_X = 1 << 2, PLANE_PROPERTY_SRC_Y = 1 << 3, PLANE_PROPERTY_SRC_W = 1 << 4, PLANE_PROPERTY_SRC_H = 1 << 5, PLANE_PROPERTY_IS_CURSOR = 1 << 6, PLANE_PROPERTY_IS_PRIMARY = 1 << 7, PLANE_PROPERTY_ROTATION = 1 << 8, } plane_property_mask; /* Returns plane_property_mask */ static uint32_t plane_get_properties(int drmfd, uint32_t plane_id, int *x, int *y, int *src_x, int *src_y, int *src_w, int *src_h, gsr_kms_rotation *rotation) { *x = 0; *y = 0; *src_x = 0; *src_y = 0; *src_w = 0; *src_h = 0; *rotation = KMS_ROT_0; plane_property_mask property_mask = 0; drmModeObjectPropertiesPtr props = drmModeObjectGetProperties(drmfd, plane_id, DRM_MODE_OBJECT_PLANE); if(!props) return property_mask; // TODO: Dont do this every frame for(uint32_t i = 0; i < props->count_props; ++i) { drmModePropertyPtr prop = drmModeGetProperty(drmfd, props->props[i]); if(!prop) continue; // SRC_* values are fixed 16.16 points const uint32_t type = prop->flags & (DRM_MODE_PROP_LEGACY_TYPE | DRM_MODE_PROP_EXTENDED_TYPE); if((type & DRM_MODE_PROP_SIGNED_RANGE) && strcmp(prop->name, "CRTC_X") == 0) { *x = (int)props->prop_values[i]; property_mask |= PLANE_PROPERTY_X; } else if((type & DRM_MODE_PROP_SIGNED_RANGE) && strcmp(prop->name, "CRTC_Y") == 0) { *y = (int)props->prop_values[i]; property_mask |= PLANE_PROPERTY_Y; } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "SRC_X") == 0) { *src_x = (int)(props->prop_values[i] >> 16); property_mask |= PLANE_PROPERTY_SRC_X; } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "SRC_Y") == 0) { *src_y = (int)(props->prop_values[i] >> 16); property_mask |= PLANE_PROPERTY_SRC_Y; } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "SRC_W") == 0) { *src_w = (int)(props->prop_values[i] >> 16); property_mask |= PLANE_PROPERTY_SRC_W; } else if((type & DRM_MODE_PROP_RANGE) && strcmp(prop->name, "SRC_H") == 0) { *src_h = (int)(props->prop_values[i] >> 16); property_mask |= PLANE_PROPERTY_SRC_H; } else if((type & DRM_MODE_PROP_ENUM) && strcmp(prop->name, "type") == 0) { const uint64_t current_enum_value = props->prop_values[i]; for(int j = 0; j < prop->count_enums; ++j) { if(prop->enums[j].value == current_enum_value && strcmp(prop->enums[j].name, "Primary") == 0) { property_mask |= PLANE_PROPERTY_IS_PRIMARY; break; } else if(prop->enums[j].value == current_enum_value && strcmp(prop->enums[j].name, "Cursor") == 0) { property_mask |= PLANE_PROPERTY_IS_CURSOR; break; } } } else if((type & DRM_MODE_PROP_BITMASK) && strcmp(prop->name, "rotation") == 0) { const uint64_t rotation_bitmask = props->prop_values[i]; *rotation = KMS_ROT_0; if(rotation_bitmask & 2) *rotation = (*rotation + KMS_ROT_90) % 4; if(rotation_bitmask & 4) *rotation = (*rotation + KMS_ROT_180) % 4; if(rotation_bitmask & 8) *rotation = (*rotation + KMS_ROT_270) % 4; } drmModeFreeProperty(prop); } drmModeFreeObjectProperties(props); return property_mask; } /* Returns NULL if not found */ static const connector_crtc_pair* get_connector_pair_by_crtc_id(const connector_to_crtc_map *c2crtc_map, uint32_t crtc_id) { for(int i = 0; i < c2crtc_map->num_maps; ++i) { if(c2crtc_map->maps[i].crtc_id == crtc_id) return &c2crtc_map->maps[i]; } return NULL; } static void map_crtc_to_connector_ids(gsr_drm *drm, connector_to_crtc_map *c2crtc_map) { c2crtc_map->num_maps = 0; drmModeResPtr resources = drmModeGetResources(drm->drmfd); if(!resources) return; for(int i = 0; i < resources->count_connectors && c2crtc_map->num_maps < MAX_CONNECTORS; ++i) { drmModeConnectorPtr connector = drmModeGetConnectorCurrent(drm->drmfd, resources->connectors[i]); if(!connector) continue; uint64_t crtc_id = 0; connector_get_property_by_name(drm->drmfd, connector, "CRTC_ID", &crtc_id); uint64_t hdr_output_metadata_blob_id = 0; connector_get_property_by_name(drm->drmfd, connector, "HDR_OUTPUT_METADATA", &hdr_output_metadata_blob_id); c2crtc_map->maps[c2crtc_map->num_maps].connector_id = connector->connector_id; c2crtc_map->maps[c2crtc_map->num_maps].crtc_id = crtc_id; c2crtc_map->maps[c2crtc_map->num_maps].hdr_metadata_blob_id = hdr_output_metadata_blob_id; ++c2crtc_map->num_maps; drmModeFreeConnector(connector); } drmModeFreeResources(resources); } static void drm_mode_cleanup_handles(int drmfd, drmModeFB2Ptr drmfb) { for(int i = 0; i < 4; ++i) { if(!drmfb->handles[i]) continue; bool already_closed = false; for(int j = 0; j < i; ++j) { if(drmfb->handles[i] == drmfb->handles[j]) { already_closed = true; break; } } if(already_closed) continue; drmCloseBufferHandle(drmfd, drmfb->handles[i]); } } static bool get_hdr_metadata(int drm_fd, uint64_t hdr_metadata_blob_id, struct hdr_output_metadata *hdr_metadata) { drmModePropertyBlobPtr hdr_metadata_blob = drmModeGetPropertyBlob(drm_fd, hdr_metadata_blob_id); if(!hdr_metadata_blob) return false; if(hdr_metadata_blob->length >= sizeof(struct hdr_output_metadata)) *hdr_metadata = *(struct hdr_output_metadata*)hdr_metadata_blob->data; drmModeFreePropertyBlob(hdr_metadata_blob); return true; } /* Returns the number of drm handles that we managed to get */ static int drm_prime_handles_to_fds(gsr_drm *drm, drmModeFB2Ptr drmfb, int *fb_fds) { for(int i = 0; i < GSR_KMS_MAX_DMA_BUFS; ++i) { if(!drmfb->handles[i]) return i; const int ret = drmPrimeHandleToFD(drm->drmfd, drmfb->handles[i], O_RDONLY, &fb_fds[i]); if(ret != 0 || fb_fds[i] == -1) return i; } return GSR_KMS_MAX_DMA_BUFS; } static int kms_get_fb(gsr_drm *drm, gsr_kms_response *response) { int result = -1; response->result = KMS_RESULT_OK; response->err_msg[0] = '\0'; response->num_items = 0; connector_to_crtc_map c2crtc_map; c2crtc_map.num_maps = 0; map_crtc_to_connector_ids(drm, &c2crtc_map); drmModePlaneResPtr planes = drmModeGetPlaneResources(drm->drmfd); if(!planes) { fprintf(stderr, "kms server error: failed to get plane resources, error: %s\n", strerror(errno)); goto done; } for(uint32_t i = 0; i < planes->count_planes && response->num_items < GSR_KMS_MAX_ITEMS; ++i) { drmModePlanePtr plane = NULL; drmModeFB2Ptr drmfb = NULL; plane = drmModeGetPlane(drm->drmfd, planes->planes[i]); if(!plane) { response->result = KMS_RESULT_FAILED_TO_GET_PLANE; snprintf(response->err_msg, sizeof(response->err_msg), "failed to get drm plane with id %u, error: %s\n", planes->planes[i], strerror(errno)); fprintf(stderr, "kms server error: %s\n", response->err_msg); goto next; } if(!plane->fb_id) goto next; drmfb = drmModeGetFB2(drm->drmfd, plane->fb_id); if(!drmfb) { // Commented out for now because we get here if the cursor is moved to another monitor and we dont care about the cursor //response->result = KMS_RESULT_FAILED_TO_GET_PLANE; //snprintf(response->err_msg, sizeof(response->err_msg), "drmModeGetFB2 failed, error: %s", strerror(errno)); //fprintf(stderr, "kms server error: %s\n", response->err_msg); goto next; } if(!drmfb->handles[0]) { response->result = KMS_RESULT_FAILED_TO_GET_PLANE; snprintf(response->err_msg, sizeof(response->err_msg), "drmfb handle is NULL"); fprintf(stderr, "kms server error: %s\n", response->err_msg); goto cleanup_handles; } // TODO: Check if dimensions have changed by comparing width and height to previous time this was called. // TODO: Support other plane formats than rgb (with multiple planes, such as direct YUV420 on wayland). int x = 0, y = 0, src_x = 0, src_y = 0, src_w = 0, src_h = 0; gsr_kms_rotation rotation = KMS_ROT_0; const uint32_t property_mask = plane_get_properties(drm->drmfd, plane->plane_id, &x, &y, &src_x, &src_y, &src_w, &src_h, &rotation); if(!(property_mask & PLANE_PROPERTY_IS_PRIMARY) && !(property_mask & PLANE_PROPERTY_IS_CURSOR)) continue; int fb_fds[GSR_KMS_MAX_DMA_BUFS]; const int num_fb_fds = drm_prime_handles_to_fds(drm, drmfb, fb_fds); if(num_fb_fds == 0) { response->result = KMS_RESULT_FAILED_TO_GET_PLANE; snprintf(response->err_msg, sizeof(response->err_msg), "failed to get fd from drm handle, error: %s", strerror(errno)); fprintf(stderr, "kms server error: %s\n", response->err_msg); goto cleanup_handles; } const int item_index = response->num_items; const connector_crtc_pair *crtc_pair = get_connector_pair_by_crtc_id(&c2crtc_map, plane->crtc_id); if(crtc_pair && crtc_pair->hdr_metadata_blob_id) { response->items[item_index].has_hdr_metadata = get_hdr_metadata(drm->drmfd, crtc_pair->hdr_metadata_blob_id, &response->items[item_index].hdr_metadata); } else { response->items[item_index].has_hdr_metadata = false; } for(int j = 0; j < num_fb_fds; ++j) { response->items[item_index].dma_buf[j].fd = fb_fds[j]; response->items[item_index].dma_buf[j].pitch = drmfb->pitches[j]; response->items[item_index].dma_buf[j].offset = drmfb->offsets[j]; } response->items[item_index].num_dma_bufs = num_fb_fds; response->items[item_index].width = drmfb->width; response->items[item_index].height = drmfb->height; response->items[item_index].pixel_format = drmfb->pixel_format; response->items[item_index].modifier = drmfb->flags & DRM_MODE_FB_MODIFIERS ? drmfb->modifier : DRM_FORMAT_MOD_INVALID; response->items[item_index].connector_id = crtc_pair ? crtc_pair->connector_id : 0; response->items[item_index].rotation = rotation; response->items[item_index].is_cursor = property_mask & PLANE_PROPERTY_IS_CURSOR; if(property_mask & PLANE_PROPERTY_IS_CURSOR) { response->items[item_index].x = x; response->items[item_index].y = y; response->items[item_index].src_w = 0; response->items[item_index].src_h = 0; } else { response->items[item_index].x = src_x; response->items[item_index].y = src_y; response->items[item_index].src_w = src_w; response->items[item_index].src_h = src_h; } ++response->num_items; cleanup_handles: drm_mode_cleanup_handles(drm->drmfd, drmfb); next: if(drmfb) drmModeFreeFB2(drmfb); if(plane) drmModeFreePlane(plane); } done: if(planes) drmModeFreePlaneResources(planes); if(response->num_items > 0) response->result = KMS_RESULT_OK; if(response->result == KMS_RESULT_OK) { result = 0; } else { for(int i = 0; i < response->num_items; ++i) { for(int j = 0; j < response->items[i].num_dma_bufs; ++j) { gsr_kms_response_dma_buf *dma_buf = &response->items[i].dma_buf[j]; if(dma_buf->fd > 0) { close(dma_buf->fd); dma_buf->fd = -1; } } response->items[i].num_dma_bufs = 0; } response->num_items = 0; } return result; } static double clock_get_monotonic_seconds(void) { struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = 0; clock_gettime(CLOCK_MONOTONIC, &ts); return (double)ts.tv_sec + (double)ts.tv_nsec * 0.000000001; } int main(int argc, char **argv) { setlocale(LC_ALL, "C"); // Sigh... stupid C int res = 0; int socket_fd = 0; gsr_drm drm; drm.drmfd = 0; if(argc != 3) { fprintf(stderr, "usage: gsr-kms-server \n"); return 1; } const char *domain_socket_path = argv[1]; socket_fd = socket(AF_UNIX, SOCK_STREAM, 0); if(socket_fd == -1) { fprintf(stderr, "kms server error: failed to create socket, error: %s\n", strerror(errno)); return 2; } const char *card_path = argv[2]; drm.drmfd = open(card_path, O_RDONLY); if(drm.drmfd < 0) { fprintf(stderr, "kms server error: failed to open %s, error: %s", card_path, strerror(errno)); res = 2; goto done; } if(drmSetClientCap(drm.drmfd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1) != 0) { fprintf(stderr, "kms server error: drmSetClientCap DRM_CLIENT_CAP_UNIVERSAL_PLANES failed, error: %s\n", strerror(errno)); res = 2; goto done; } if(drmSetClientCap(drm.drmfd, DRM_CLIENT_CAP_ATOMIC, 1) != 0) { fprintf(stderr, "kms server warning: drmSetClientCap DRM_CLIENT_CAP_ATOMIC failed, error: %s. The wrong monitor may be captured as a result\n", strerror(errno)); } fprintf(stderr, "kms server info: connecting to the client\n"); bool connected = false; const double connect_timeout_sec = 5.0; const double start_time = clock_get_monotonic_seconds(); while(clock_get_monotonic_seconds() - start_time < connect_timeout_sec) { struct sockaddr_un remote_addr = {0}; remote_addr.sun_family = AF_UNIX; snprintf(remote_addr.sun_path, sizeof(remote_addr.sun_path), "%s", domain_socket_path); // TODO: Check if parent disconnected if(connect(socket_fd, (struct sockaddr*)&remote_addr, sizeof(remote_addr.sun_family) + strlen(remote_addr.sun_path)) == -1) { if(errno == ECONNREFUSED || errno == ENOENT) { goto next; } else if(errno == EISCONN) { connected = true; break; } fprintf(stderr, "kms server error: connect failed, error: %s (%d)\n", strerror(errno), errno); res = 2; goto done; } next: usleep(30 * 1000); // 30 milliseconds } if(connected) { fprintf(stderr, "kms server info: connected to the client\n"); } else { fprintf(stderr, "kms server error: failed to connect to the client in %f seconds\n", connect_timeout_sec); res = 2; goto done; } for(;;) { gsr_kms_request request; request.version = 0; request.type = -1; request.new_connection_fd = 0; const int recv_res = recv_msg_from_client(socket_fd, &request); if(recv_res == 0) { fprintf(stderr, "kms server info: kms client shutdown, shutting down the server\n"); res = 3; goto done; } else if(recv_res == -1) { const int err = errno; fprintf(stderr, "kms server error: failed to read all data in client request (error: %s), ignoring\n", strerror(err)); if(err == EBADF) { fprintf(stderr, "kms server error: invalid client fd, shutting down the server\n"); res = 3; goto done; } continue; } if(request.version != GSR_KMS_PROTOCOL_VERSION) { fprintf(stderr, "kms server error: expected gpu screen recorder protocol version to be %u, but it's %u. please reinstall gpu screen recorder\n", GSR_KMS_PROTOCOL_VERSION, request.version); /* if(request.new_connection_fd > 0) close(request.new_connection_fd); */ continue; } switch(request.type) { case KMS_REQUEST_TYPE_REPLACE_CONNECTION: { gsr_kms_response response; response.version = GSR_KMS_PROTOCOL_VERSION; response.num_items = 0; if(request.new_connection_fd > 0) { if(socket_fd > 0) close(socket_fd); socket_fd = request.new_connection_fd; response.result = KMS_RESULT_OK; if(send_msg_to_client(socket_fd, &response) == -1) fprintf(stderr, "kms server error: failed to respond to client KMS_REQUEST_TYPE_REPLACE_CONNECTION request\n"); } else { response.result = KMS_RESULT_INVALID_REQUEST; snprintf(response.err_msg, sizeof(response.err_msg), "received invalid connection fd"); fprintf(stderr, "kms server error: %s\n", response.err_msg); if(send_msg_to_client(socket_fd, &response) == -1) fprintf(stderr, "kms server error: failed to respond to client request\n"); } break; } case KMS_REQUEST_TYPE_GET_KMS: { gsr_kms_response response; response.version = GSR_KMS_PROTOCOL_VERSION; response.num_items = 0; if(kms_get_fb(&drm, &response) == 0) { if(send_msg_to_client(socket_fd, &response) == -1) fprintf(stderr, "kms server error: failed to respond to client KMS_REQUEST_TYPE_GET_KMS request\n"); } else { if(send_msg_to_client(socket_fd, &response) == -1) fprintf(stderr, "kms server error: failed to respond to client KMS_REQUEST_TYPE_GET_KMS request\n"); } for(int i = 0; i < response.num_items; ++i) { for(int j = 0; j < response.items[i].num_dma_bufs; ++j) { gsr_kms_response_dma_buf *dma_buf = &response.items[i].dma_buf[j]; if(dma_buf->fd > 0) { close(dma_buf->fd); dma_buf->fd = -1; } } response.items[i].num_dma_bufs = 0; } response.num_items = 0; break; } default: { gsr_kms_response response; response.version = GSR_KMS_PROTOCOL_VERSION; response.result = KMS_RESULT_INVALID_REQUEST; response.num_items = 0; snprintf(response.err_msg, sizeof(response.err_msg), "invalid request type %d, expected %d (%s)", request.type, KMS_REQUEST_TYPE_GET_KMS, "KMS_REQUEST_TYPE_GET_KMS"); fprintf(stderr, "kms server error: %s\n", response.err_msg); if(send_msg_to_client(socket_fd, &response) == -1) fprintf(stderr, "kms server error: failed to respond to client request\n"); break; } } } done: if(drm.drmfd > 0) close(drm.drmfd); if(socket_fd > 0) close(socket_fd); return res; } fsdsfdsfdsfdsf-5.13.8/kms/server/project.conf000066400000000000000000000002411520215207700212170ustar00rootroot00000000000000[package] name = "gsr-kms-server" type = "executable" version = "1.0.0" platforms = ["posix"] [config] error_on_warning = "true" [dependencies] libdrm = ">=2" fsdsfdsfdsfdsf-5.13.8/meson.build000066400000000000000000000074271520215207700167610ustar00rootroot00000000000000project('gpu-screen-recorder', ['c', 'cpp'], version : '5.13.8', default_options : ['warning_level=2']) add_project_arguments('-Wshadow', language : ['c', 'cpp']) if get_option('buildtype') == 'debug' add_project_arguments('-g3', language : ['c', 'cpp']) elif get_option('buildtype') == 'release' add_project_arguments('-DNDEBUG', language : ['c', 'cpp']) endif src = [ 'kms/client/kms_client.c', 'src/capture/capture.c', 'src/capture/nvfbc.c', 'src/capture/xcomposite.c', 'src/capture/ximage.c', 'src/capture/kms.c', 'src/capture/v4l2.c', 'src/encoder/encoder.c', 'src/encoder/video/video.c', 'src/encoder/video/nvenc.c', 'src/encoder/video/vaapi.c', 'src/encoder/video/vulkan.c', 'src/encoder/video/software.c', 'src/codec_query/nvenc.c', 'src/codec_query/vaapi.c', 'src/codec_query/vulkan.c', 'src/window/window.c', 'src/window/x11.c', 'src/window/wayland.c', 'src/replay_buffer/replay_buffer.c', 'src/replay_buffer/replay_buffer_ram.c', 'src/replay_buffer/replay_buffer_disk.c', 'src/egl.c', 'src/cuda.c', 'src/window_texture.c', 'src/shader.c', 'src/color_conversion.c', 'src/utils.c', 'src/library_loader.c', 'src/cursor.c', 'src/damage.c', 'src/image_writer.c', 'src/args_parser.c', 'src/defs.c', 'src/plugins.c', 'src/sound.cpp', 'src/main.cpp', ] subdir('protocol') src += protocol_src cc = meson.get_compiler('c') m_dep = cc.find_library('m', required : true) dep = [ dependency('threads'), m_dep, dependency('libavcodec'), dependency('libavformat'), dependency('libavutil'), dependency('x11'), dependency('xcomposite'), dependency('xrandr'), dependency('xfixes'), dependency('xdamage'), dependency('libpulse'), dependency('libswresample'), dependency('libavfilter'), dependency('libva'), dependency('libva-drm'), dependency('libdrm'), dependency('wayland-egl'), dependency('wayland-client'), dependency('vulkan'), ] if build_machine.system() == 'linux' dep += [ dependency('libcap'), ] endif uses_pipewire = false if get_option('portal') == true src += [ 'src/capture/portal.c', 'src/dbus.c', 'src/pipewire_video.c', ] add_project_arguments('-DGSR_PORTAL', language : ['c', 'cpp']) uses_pipewire = true endif if get_option('app_audio') == true src += [ 'src/pipewire_audio.c', ] add_project_arguments('-DGSR_APP_AUDIO', language : ['c', 'cpp']) uses_pipewire = true endif if uses_pipewire == true dep += [ dependency('libpipewire-0.3'), dependency('libspa-0.2'), dependency('dbus-1'), ] endif add_project_arguments('-DGSR_VERSION="' + meson.project_version() + '"', language: ['c', 'cpp']) executable('gsr-kms-server', 'kms/server/kms_server.c', dependencies : dependency('libdrm'), c_args : '-fstack-protector-all', install : true) executable('gpu-screen-recorder', src, dependencies : dep, install : true) install_headers('plugin/plugin.h', install_dir : 'include/gsr') install_man('gpu-screen-recorder.1', 'gsr-kms-server.1') install_subdir('scripts', install_dir: 'share/gpu-screen-recorder') if get_option('systemd') == true install_data(files('extra/gpu-screen-recorder.service'), install_dir : 'lib/systemd/user') endif if get_option('capabilities') == true meson.add_install_script('extra/meson_post_install.sh') endif if get_option('nvidia_suspend_fix') == true install_data(files('extra/gsr-nvidia.conf'), install_dir : 'lib/modprobe.d') endif if get_option('plugin_examples') == true shared_library('triangle', 'plugin/examples/hello_triangle/triangle.c', dependencies: [dependency('gl'), m_dep], name_prefix : '', name_suffix: 'so') endif fsdsfdsfdsfdsf-5.13.8/meson_options.txt000066400000000000000000000020241520215207700202400ustar00rootroot00000000000000option('systemd', type : 'boolean', value : true, description : 'Install systemd service file') option('capabilities', type : 'boolean', value : true, description : 'Set binary admin capability on gsr-kms-server binary to remove password prompt when recording monitor (without desktop portal option) on amd/intel or nvidia wayland') option('nvidia_suspend_fix', type : 'boolean', value : true, description : 'Install nvidia modprobe config file to tell nvidia driver to preserve video memory on suspend. This is a workaround for an nvidia driver bug that breaks cuda (and gpu screen recorder) on suspend') option('portal', type : 'boolean', value : true, description : 'Build with support for xdg desktop portal ScreenCast capture (wayland only) (-w portal option). Requires pipewire') option('app_audio', type : 'boolean', value : true, description : 'Build with support for recording a single audio source (-a app: option). Requires pipewire') option('plugin_examples', type : 'boolean', value : false, description : 'Build plugin examples') fsdsfdsfdsfdsf-5.13.8/plugin/000077500000000000000000000000001520215207700161035ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/plugin/examples/000077500000000000000000000000001520215207700177215ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/plugin/examples/hello_triangle/000077500000000000000000000000001520215207700227115ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/plugin/examples/hello_triangle/triangle.c000066400000000000000000000061361520215207700246700ustar00rootroot00000000000000#include #include #include #include #define GL_GLEXT_PROTOTYPES #include const char vertex_shader_source[] = "attribute vec4 vertex_pos; \n" "void main() { \n" " gl_Position = vec4(vertex_pos.x, -vertex_pos.y, vertex_pos.z, vertex_pos.w); \n" "}"; const char fragment_shader_source[] = "precision mediump float; \n" "uniform vec3 color; \n" "void main() { \n" " gl_FragColor = vec4(color, 1.0); \n" "}"; typedef struct { GLuint shader_program; GLuint vao; GLuint vbo; GLint color_uniform; unsigned int counter; } Triangle; static GLuint load_shader(const char *shaderSrc, GLenum type) { GLuint shader = glCreateShader(type); glShaderSource(shader, 1, &shaderSrc, NULL); glCompileShader(shader); return shader; } static void draw(const gsr_plugin_draw_params *params, void *userdata) { Triangle *triangle = userdata; GLfloat glverts[6]; glverts[0] = -0.5f; glverts[1] = -0.5f; glverts[2] = 0.5f; glverts[3] = -0.5f; glverts[4] = 0.0f; glverts[5] = 0.5f; glBindVertexArray(triangle->vao); glBindBuffer(GL_ARRAY_BUFFER, triangle->vbo); glBufferSubData(GL_ARRAY_BUFFER, 0, 6 * sizeof(float), glverts); glUseProgram(triangle->shader_program); const double pp = triangle->counter * 0.05; glUniform3f(triangle->color_uniform, 0.5 + sin(pp)*0.5, 0.5 + cos(pp)*0.5, 0.5 + sin(0.2 + pp)*0.5); glDrawArrays(GL_TRIANGLES, 0, 3); glBindVertexArray(0); glUseProgram(0); ++triangle->counter; } bool gsr_plugin_init(const gsr_plugin_init_params *params, gsr_plugin_init_return *ret) { Triangle *triangle = calloc(1, sizeof(Triangle)); if(!triangle) return false; triangle->shader_program = glCreateProgram(); const GLuint vertex_shader = load_shader(vertex_shader_source, GL_VERTEX_SHADER); const GLuint fragment_shader = load_shader(fragment_shader_source, GL_FRAGMENT_SHADER); glAttachShader(triangle->shader_program, vertex_shader); glAttachShader(triangle->shader_program, fragment_shader); glBindAttribLocation(triangle->shader_program, 0, "vertex_pos"); glLinkProgram(triangle->shader_program); glGenVertexArrays(1, &triangle->vao); glBindVertexArray(triangle->vao); glGenBuffers(1, &triangle->vbo); glBindBuffer(GL_ARRAY_BUFFER, triangle->vbo); glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), NULL, GL_DYNAMIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)0); glBindVertexArray(0); glDeleteShader(vertex_shader); glDeleteShader(fragment_shader); triangle->color_uniform = glGetUniformLocation(triangle->shader_program, "color"); ret->name = "hello_triangle"; ret->version = 1; ret->userdata = triangle; ret->draw = draw; return true; } void gsr_plugin_deinit(void *userdata) { Triangle *triangle = userdata; glDeleteProgram(triangle->shader_program); free(triangle); } fsdsfdsfdsfdsf-5.13.8/plugin/plugin.h000066400000000000000000000030071520215207700175520ustar00rootroot00000000000000#ifndef GSR_PLUGIN_H #define GSR_PLUGIN_H #ifdef __cplusplus extern "C" { #endif #define GSR_PLUGIN_INTERFACE_MAJOR_VERSION 0 #define GSR_PLUGIN_INTERFACE_MINOR_VERSION 1 #define GSR_PLUGIN_INTERFACE_MAKE_VERSION(major, minor) (((major) << 16) | (minor)) #define GSR_PLUGIN_INTERFACE_VERSION GSR_PLUGIN_INTERFACE_MAKE_VERSION(GSR_PLUGIN_INTERFACE_MAJOR_VERSION, GSR_PLUGIN_INTERFACE_MINOR_VERSION) #include typedef enum { GSR_PLUGIN_GRAPHICS_API_EGL_ES, GSR_PLUGIN_GRAPHICS_API_GLX, } gsr_plugin_graphics_api; typedef enum { GSR_PLUGIN_COLOR_DEPTH_8_BITS, GSR_PLUGIN_COLOR_DEPTH_10_BITS, } gsr_plugin_color_depth; typedef struct { unsigned int width; unsigned int height; } gsr_plugin_draw_params; typedef struct { unsigned int width; unsigned int height; unsigned int fps; gsr_plugin_color_depth color_depth; gsr_plugin_graphics_api graphics_api; } gsr_plugin_init_params; typedef struct { const char *name; /* Mandatory */ unsigned int version; /* Mandatory, can't be 0 */ void *userdata; /* Optional */ /* Optional, called when the plugin is expected to draw something to the current framebuffer */ void (*draw)(const gsr_plugin_draw_params *params, void *userdata); } gsr_plugin_init_return; /* The plugin is expected to implement these functions and export them: */ bool gsr_plugin_init(const gsr_plugin_init_params *params, gsr_plugin_init_return *ret); void gsr_plugin_deinit(void *userdata); #ifdef __cplusplus } #endif #endif /* GSR_PLUGIN_H */ fsdsfdsfdsfdsf-5.13.8/project.conf000066400000000000000000000012141520215207700171200ustar00rootroot00000000000000[package] name = "gpu-screen-recorder" type = "executable" version = "5.13.8" platforms = ["posix"] [config] ignore_dirs = ["kms/server", "build", "debug-build", "plugin/examples"] #error_on_warning = "true" [define] GSR_PORTAL = "1" GSR_APP_AUDIO = "1" [dependencies] libavcodec = ">=58" libavformat = ">=58" libavutil = ">=56.2" x11 = ">=1" xcomposite = ">=0.2" xrandr = ">=1" xfixes = ">=2" xdamage = ">=1" libpulse = ">=13" libswresample = ">=3" libavfilter = ">=5" libva = ">=1" libva-drm = ">=1" libcap = ">=2" libdrm = ">=2" wayland-egl = ">=15" wayland-client = ">=1" dbus-1 = ">=1" libpipewire-0.3 = ">=1" libspa-0.2 = ">=0" vulkan = ">=1" fsdsfdsfdsfdsf-5.13.8/protocol/000077500000000000000000000000001520215207700164465ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/protocol/meson.build000066400000000000000000000013261520215207700206120ustar00rootroot00000000000000wayland_scanner = dependency('wayland-scanner', native: true) wayland_scanner_path = wayland_scanner.get_variable(pkgconfig: 'wayland_scanner') wayland_scanner_prog = find_program(wayland_scanner_path, native: true) wayland_scanner_code = generator( wayland_scanner_prog, output: '@BASENAME@-protocol.c', arguments: ['private-code', '@INPUT@', '@OUTPUT@'], ) wayland_scanner_client = generator( wayland_scanner_prog, output: '@BASENAME@-client-protocol.h', arguments: ['client-header', '@INPUT@', '@OUTPUT@'], ) protocols = [ 'xdg-output-unstable-v1.xml', ] protocol_src = [] foreach xml : protocols protocol_src += wayland_scanner_code.process(xml) protocol_src += wayland_scanner_client.process(xml) endforeach fsdsfdsfdsfdsf-5.13.8/protocol/xdg-output-unstable-v1.xml000066400000000000000000000227101520215207700234510ustar00rootroot00000000000000 Copyright © 2017 Red Hat Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. This protocol aims at describing outputs in a way which is more in line with the concept of an output on desktop oriented systems. Some information are more specific to the concept of an output for a desktop oriented system and may not make sense in other applications, such as IVI systems for example. Typically, the global compositor space on a desktop system is made of a contiguous or overlapping set of rectangular regions. The logical_position and logical_size events defined in this protocol might provide information identical to their counterparts already available from wl_output, in which case the information provided by this protocol should be preferred to their equivalent in wl_output. The goal is to move the desktop specific concepts (such as output location within the global compositor space, etc.) out of the core wl_output protocol. Warning! The protocol described in this file is experimental and backward incompatible changes may be made. Backward compatible changes may be added together with the corresponding interface version bump. Backward incompatible changes are done by bumping the version number in the protocol and interface names and resetting the interface version. Once the protocol is to be declared stable, the 'z' prefix and the version number in the protocol and interface names are removed and the interface version number is reset. A global factory interface for xdg_output objects. Using this request a client can tell the server that it is not going to use the xdg_output_manager object anymore. Any objects already created through this instance are not affected. This creates a new xdg_output object for the given wl_output. An xdg_output describes part of the compositor geometry. This typically corresponds to a monitor that displays part of the compositor space. For objects version 3 onwards, after all xdg_output properties have been sent (when the object is created and when properties are updated), a wl_output.done event is sent. This allows changes to the output properties to be seen as atomic, even if they happen via multiple events. Using this request a client can tell the server that it is not going to use the xdg_output object anymore. The position event describes the location of the wl_output within the global compositor space. The logical_position event is sent after creating an xdg_output (see xdg_output_manager.get_xdg_output) and whenever the location of the output changes within the global compositor space. The logical_size event describes the size of the output in the global compositor space. Most regular Wayland clients should not pay attention to the logical size and would rather rely on xdg_shell interfaces. Some clients such as Xwayland, however, need this to configure their surfaces in the global compositor space as the compositor may apply a different scale from what is advertised by the output scaling property (to achieve fractional scaling, for example). For example, for a wl_output mode 3840×2160 and a scale factor 2: - A compositor not scaling the monitor viewport in its compositing space will advertise a logical size of 3840×2160, - A compositor scaling the monitor viewport with scale factor 2 will advertise a logical size of 1920×1080, - A compositor scaling the monitor viewport using a fractional scale of 1.5 will advertise a logical size of 2560×1440. For example, for a wl_output mode 1920×1080 and a 90 degree rotation, the compositor will advertise a logical size of 1080x1920. The logical_size event is sent after creating an xdg_output (see xdg_output_manager.get_xdg_output) and whenever the logical size of the output changes, either as a result of a change in the applied scale or because of a change in the corresponding output mode(see wl_output.mode) or transform (see wl_output.transform). This event is sent after all other properties of an xdg_output have been sent. This allows changes to the xdg_output properties to be seen as atomic, even if they happen via multiple events. For objects version 3 onwards, this event is deprecated. Compositors are not required to send it anymore and must send wl_output.done instead. Many compositors will assign names to their outputs, show them to the user, allow them to be configured by name, etc. The client may wish to know this name as well to offer the user similar behaviors. The naming convention is compositor defined, but limited to alphanumeric characters and dashes (-). Each name is unique among all wl_output globals, but if a wl_output global is destroyed the same name may be reused later. The names will also remain consistent across sessions with the same hardware and software configuration. Examples of names include 'HDMI-A-1', 'WL-1', 'X11-1', etc. However, do not assume that the name is a reflection of an underlying DRM connector, X11 connection, etc. The name event is sent after creating an xdg_output (see xdg_output_manager.get_xdg_output). This event is only sent once per xdg_output, and the name does not change over the lifetime of the wl_output global. This event is deprecated, instead clients should use wl_output.name. Compositors must still support this event. Many compositors can produce human-readable descriptions of their outputs. The client may wish to know this description as well, to communicate the user for various purposes. The description is a UTF-8 string with no convention defined for its contents. Examples might include 'Foocorp 11" Display' or 'Virtual X11 output via :1'. The description event is sent after creating an xdg_output (see xdg_output_manager.get_xdg_output) and whenever the description changes. The description is optional, and may not be sent at all. For objects of version 2 and lower, this event is only sent once per xdg_output, and the description does not change over the lifetime of the wl_output global. This event is deprecated, instead clients should use wl_output.description. Compositors must still support this event. fsdsfdsfdsfdsf-5.13.8/scripts/000077500000000000000000000000001520215207700162745ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/scripts/interactive.sh000077500000000000000000000005221520215207700211470ustar00rootroot00000000000000#!/bin/sh -e echo "Select a window to record" window_id=$(xdotool selectwindow) echo -n "Enter video fps: " read fps echo -n "Enter output file name: " read output_file_name output_dir=$(dirname "$output_file_name") mkdir -p "$output_dir" gpu-screen-recorder -w "$window_id" -c mp4 -f "$fps" -a default_output -o "$output_file_name" fsdsfdsfdsfdsf-5.13.8/scripts/list-sinks.sh000077500000000000000000000001171520215207700207320ustar00rootroot00000000000000#!/bin/sh pactl list | grep -E '(Description: Monitor of)|(Monitor Source: )' fsdsfdsfdsfdsf-5.13.8/scripts/record-application-name.sh000077500000000000000000000005151520215207700233310ustar00rootroot00000000000000#!/bin/sh window=$(xdotool selectwindow) window_name=$(xdotool getwindowname "$window" || xdotool getwindowclassname "$window" || echo "Game") window_name="$(echo "$window_name" | tr '/\\' '_')" gpu-screen-recorder -w "$window" -f 60 -a default_output -o "$HOME/Videos/recording/$window_name/$(date +"Video_%Y-%m-%d_%H-%M-%S.mp4")" fsdsfdsfdsfdsf-5.13.8/scripts/record-save-application-name.sh000077500000000000000000000012211520215207700242600ustar00rootroot00000000000000#!/bin/sh # This script should be passed to gpu-screen-recorder with the -sc option, for example: # gpu-screen-recorder -w screen -f 60 -a default_output -r 60 -sc scripts/record-save-application-name.sh -c mp4 -o "$HOME/Videos" window=$(xdotool getwindowfocus) window_name=$(xdotool getwindowname "$window" || xdotool getwindowclassname "$window" || echo "Game") window_name="$(echo "$window_name" | tr '/\\' '_')" video_dir="$HOME/Videos/Replays/$window_name" mkdir -p "$video_dir" video="$video_dir/$(date +"${window_name}_%Y-%m-%d_%H-%M-%S.mp4")" mv "$1" "$video" sleep 0.5 && notify-send -t 2000 -u low "GPU Screen Recorder" "Replay saved to $video"fsdsfdsfdsfdsf-5.13.8/scripts/replay-application-name.sh000077500000000000000000000005021520215207700233430ustar00rootroot00000000000000#!/bin/sh window=$(xdotool selectwindow) window_name=$(xdotool getwindowname "$window" || xdotool getwindowclassname "$window" || echo "Game") window_name="$(echo "$window_name" | tr '/\\' '_')" gpu-screen-recorder -w "$window" -f 60 -c mkv -a default_output -bm cbr -q 40000 -r 60 -o "$HOME/Videos/Replays/$window_name" fsdsfdsfdsfdsf-5.13.8/scripts/save-recording.sh000077500000000000000000000002021520215207700215350ustar00rootroot00000000000000#!/bin/sh killall -SIGINT gpu-screen-recorder && sleep 0.5 && notify-send -t 1500 -u low "GPU Screen Recorder" "Recording saved" fsdsfdsfdsfdsf-5.13.8/scripts/save-replay.sh000077500000000000000000000002061520215207700210610ustar00rootroot00000000000000#!/bin/sh -e killall -SIGUSR1 gpu-screen-recorder && sleep 0.5 && notify-send -t 1500 -u low -- "GPU Screen Recorder" "Replay saved" fsdsfdsfdsfdsf-5.13.8/scripts/start-recording.sh000077500000000000000000000002601520215207700217400ustar00rootroot00000000000000#!/bin/sh pidof -q gpu-screen-recorder && exit 0 video="$HOME/Videos/$(date +"Video_%Y-%m-%d_%H-%M-%S.mp4")" gpu-screen-recorder -w screen -f 60 -a default_output -o "$video" fsdsfdsfdsfdsf-5.13.8/scripts/start-replay.sh000077500000000000000000000003101520215207700212540ustar00rootroot00000000000000#!/bin/sh pidof -q gpu-screen-recorder && exit 0 video_path="$HOME/Videos" mkdir -p "$video_path" gpu-screen-recorder -w screen -f 60 -a default_output -c mkv -bm cbr -q 40000 -r 30 -o "$video_path" fsdsfdsfdsfdsf-5.13.8/scripts/start-stop-recording.sh000077500000000000000000000007111520215207700227240ustar00rootroot00000000000000#!/bin/sh # Simple script to start recording if it's not recording and stop recording # if it's already recording. This script can be bound to a single hotkey # to start/stop recording with a single hotkey. killall -SIGINT -q gpu-screen-recorder && exit 0 video="$HOME/Videos/$(date +"Video_%Y-%m-%d_%H-%M-%S.mp4")" gpu-screen-recorder -w screen -f 60 -a default_output -o "$video" notify-send -t 2000 -u low "GPU Screen Recorder" "Video saved to $video" fsdsfdsfdsfdsf-5.13.8/scripts/stop-replay.sh000077500000000000000000000000571520215207700211140ustar00rootroot00000000000000#!/bin/sh killall -SIGINT gpu-screen-recorder fsdsfdsfdsfdsf-5.13.8/scripts/toggle-recording-selected.sh000077500000000000000000000007011520215207700236520ustar00rootroot00000000000000#!/bin/sh -e killall -SIGINT gpu-screen-recorder && sleep 0.5 && notify-send -t 1500 -u low 'GPU Screen Recorder' 'Stopped recording' && exit 0; window=$(xdotool selectwindow) active_sink=default_output mkdir -p "$HOME/Videos" video="$HOME/Videos/$(date +"Video_%Y-%m-%d_%H-%M-%S.mp4")" notify-send -t 1500 -u low 'GPU Screen Recorder' "Started recording video to $video" gpu-screen-recorder -w "$window" -c mp4 -f 60 -a "$active_sink" -o "$video" fsdsfdsfdsfdsf-5.13.8/scripts/toggle-recording.sh000077500000000000000000000005471520215207700220740ustar00rootroot00000000000000#!/bin/sh -e killall -SIGINT gpu-screen-recorder && sleep 0.5 && notify-send -t 1500 -u low 'GPU Screen Recorder' 'Stopped recording' && exit 0; video="$HOME/Videos/$(date +"Video_%Y-%m-%d_%H-%M-%S.mp4")" notify-send -t 1500 -u low 'GPU Screen Recorder' "Started recording video to $video" gpu-screen-recorder -w screen -f 60 -a "default_output" -o "$video" fsdsfdsfdsfdsf-5.13.8/scripts/twitch-stream-local-copy.sh000077500000000000000000000005731520215207700234730ustar00rootroot00000000000000#!/bin/sh # Stream on twitch while also saving the video to disk locally [ "$#" -ne 4 ] && echo "usage: twitch-stream-local-copy.sh " && exit 1 active_sink=default_output gpu-screen-recorder -w "$1" -c flv -f "$2" -bm cbr -q 8000 -a "$active_sink" | tee -- "$4" | ffmpeg -i pipe:0 -c copy -f flv -- "rtmp://live.twitch.tv/app/$3" fsdsfdsfdsfdsf-5.13.8/scripts/twitch-stream.sh000077500000000000000000000003631520215207700214300ustar00rootroot00000000000000#!/bin/sh [ "$#" -ne 3 ] && echo "usage: twitch-stream.sh " && exit 1 active_sink=default_output gpu-screen-recorder -w "$1" -c flv -f "$2" -bm cbr -q 8000 -a "$active_sink" -o "rtmp://live.twitch.tv/app/$3" fsdsfdsfdsfdsf-5.13.8/scripts/youtube-hls-stream.sh000077500000000000000000000004561520215207700224110ustar00rootroot00000000000000#!/bin/sh [ "$#" -ne 3 ] && echo "usage: youtube-hls-stream.sh " && exit 1 active_sink=default_output gpu-screen-recorder -w "$1" -c hls -f "$2" -bm cbr -q 8000 -a "$active_sink" -ac aac -o "https://a.upload.youtube.com/http_upload_hls?cid=$3©=0&file=stream.m3u8"fsdsfdsfdsfdsf-5.13.8/src/000077500000000000000000000000001520215207700153745ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/src/args_parser.c000066400000000000000000001050621520215207700200540ustar00rootroot00000000000000#include "../include/args_parser.h" #include "../include/defs.h" #include "../include/egl.h" #include "../include/window/window.h" #include #include #include #include #include #include #include #include #ifndef GSR_VERSION #define GSR_VERSION "unknown" #endif static const ArgEnum video_codec_enums[] = { { .name = "auto", .value = GSR_VIDEO_CODEC_AUTO }, { .name = "h264", .value = GSR_VIDEO_CODEC_H264 }, { .name = "h265", .value = GSR_VIDEO_CODEC_HEVC }, { .name = "hevc", .value = GSR_VIDEO_CODEC_HEVC }, { .name = "hevc_hdr", .value = GSR_VIDEO_CODEC_HEVC_HDR }, { .name = "hevc_10bit", .value = GSR_VIDEO_CODEC_HEVC_10BIT }, { .name = "av1", .value = GSR_VIDEO_CODEC_AV1 }, { .name = "av1_hdr", .value = GSR_VIDEO_CODEC_AV1_HDR }, { .name = "av1_10bit", .value = GSR_VIDEO_CODEC_AV1_10BIT }, { .name = "vp8", .value = GSR_VIDEO_CODEC_VP8 }, { .name = "vp9", .value = GSR_VIDEO_CODEC_VP9 }, { .name = "h264_vulkan", .value = GSR_VIDEO_CODEC_H264_VULKAN }, { .name = "hevc_vulkan", .value = GSR_VIDEO_CODEC_HEVC_VULKAN }, { .name = "hevc_hdr_vulkan", .value = GSR_VIDEO_CODEC_HEVC_HDR_VULKAN }, { .name = "hevc_10bit_vulkan", .value = GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN }, { .name = "av1_vulkan", .value = GSR_VIDEO_CODEC_AV1_VULKAN }, { .name = "av1_hdr_vulkan", .value = GSR_VIDEO_CODEC_AV1_HDR_VULKAN }, { .name = "av1_10bit_vulkan", .value = GSR_VIDEO_CODEC_AV1_10BIT_VULKAN }, }; static const ArgEnum audio_codec_enums[] = { { .name = "opus", .value = GSR_AUDIO_CODEC_OPUS }, { .name = "aac", .value = GSR_AUDIO_CODEC_AAC }, { .name = "flac", .value = GSR_AUDIO_CODEC_FLAC }, }; static const ArgEnum video_encoder_enums[] = { { .name = "gpu", .value = GSR_VIDEO_ENCODER_HW_GPU }, { .name = "cpu", .value = GSR_VIDEO_ENCODER_HW_CPU }, }; static const ArgEnum pixel_format_enums[] = { { .name = "yuv420", .value = GSR_PIXEL_FORMAT_YUV420 }, { .name = "yuv444", .value = GSR_PIXEL_FORMAT_YUV444 }, }; static const ArgEnum framerate_mode_enums[] = { { .name = "vfr", .value = GSR_FRAMERATE_MODE_VARIABLE }, { .name = "cfr", .value = GSR_FRAMERATE_MODE_CONSTANT }, { .name = "content", .value = GSR_FRAMERATE_MODE_CONTENT }, }; static const ArgEnum bitrate_mode_enums[] = { { .name = "auto", .value = GSR_BITRATE_MODE_AUTO }, { .name = "qp", .value = GSR_BITRATE_MODE_QP }, { .name = "cbr", .value = GSR_BITRATE_MODE_CBR }, { .name = "vbr", .value = GSR_BITRATE_MODE_VBR }, }; static const ArgEnum color_range_enums[] = { { .name = "limited", .value = GSR_COLOR_RANGE_LIMITED }, { .name = "full", .value = GSR_COLOR_RANGE_FULL }, }; static const ArgEnum tune_enums[] = { { .name = "performance", .value = GSR_TUNE_PERFORMANCE }, { .name = "quality", .value = GSR_TUNE_QUALITY }, }; static const ArgEnum replay_storage_enums[] = { { .name = "ram", .value = GSR_REPLAY_STORAGE_RAM }, { .name = "disk", .value = GSR_REPLAY_STORAGE_DISK }, }; static void arg_deinit(Arg *arg) { if(arg->values) { free(arg->values); arg->values = NULL; } } static bool arg_append_value(Arg *arg, const char *value) { if(arg->num_values + 1 >= arg->capacity_num_values) { const int new_capacity_num_values = arg->capacity_num_values == 0 ? 4 : arg->capacity_num_values*2; void *new_data = realloc(arg->values, new_capacity_num_values * sizeof(const char*)); if(!new_data) return false; arg->values = new_data; arg->capacity_num_values = new_capacity_num_values; } arg->values[arg->num_values] = value; ++arg->num_values; return true; } static bool arg_get_enum_value_by_name(const Arg *arg, const char *name, int *enum_value) { assert(arg->type == ARG_TYPE_ENUM); assert(arg->enum_values); for(int i = 0; i < arg->num_enum_values; ++i) { if(strcmp(arg->enum_values[i].name, name) == 0) { *enum_value = arg->enum_values[i].value; return true; } } return false; } static void arg_print_expected_enum_names(const Arg *arg) { assert(arg->type == ARG_TYPE_ENUM); assert(arg->enum_values); for(int i = 0; i < arg->num_enum_values; ++i) { if(i > 0) { if(i == arg->num_enum_values -1) fprintf(stderr, " or "); else fprintf(stderr, ", "); } fprintf(stderr, "'%s'", arg->enum_values[i].name); } } static Arg* args_get_by_key(Arg *args, int num_args, const char *key) { for(int i = 0; i < num_args; ++i) { if(strcmp(args[i].key, key) == 0) return &args[i]; } return NULL; } static const char* args_get_value_by_key(Arg *args, int num_args, const char *key) { for(int i = 0; i < num_args; ++i) { if(strcmp(args[i].key, key) == 0) { if(args[i].num_values == 0) return NULL; else return args[i].values[0]; } } return NULL; } static bool args_get_boolean_by_key(Arg *args, int num_args, const char *key, bool default_value) { Arg *arg = args_get_by_key(args, num_args, key); assert(arg); if(arg->num_values == 0) { return default_value; } else { assert(arg->type == ARG_TYPE_BOOLEAN); return arg->typed_value.boolean; } } static int args_get_enum_by_key(Arg *args, int num_args, const char *key, int default_value) { Arg *arg = args_get_by_key(args, num_args, key); assert(arg); if(arg->num_values == 0) { return default_value; } else { assert(arg->type == ARG_TYPE_ENUM); return arg->typed_value.enum_value; } } static int64_t args_get_i64_by_key(Arg *args, int num_args, const char *key, int64_t default_value) { Arg *arg = args_get_by_key(args, num_args, key); assert(arg); if(arg->num_values == 0) { return default_value; } else { assert(arg->type == ARG_TYPE_I64); return arg->typed_value.i64_value; } } static double args_get_double_by_key(Arg *args, int num_args, const char *key, double default_value) { Arg *arg = args_get_by_key(args, num_args, key); assert(arg); if(arg->num_values == 0) { return default_value; } else { assert(arg->type == ARG_TYPE_DOUBLE); return arg->typed_value.d_value; } } static void usage_header(void) { const bool inside_flatpak = getenv("FLATPAK_ID") != NULL; const char *program_name = inside_flatpak ? "flatpak run --command=gpu-screen-recorder com.dec05eba.gpu_screen_recorder" : "gpu-screen-recorder"; printf("usage: %s -w [-c ] [-s WxH] [-region WxH+X+Y] [-f ] [-a ] " "[-q ] [-r ] [-replay-storage ram|disk] [-restart-replay-on-save yes|no] " "[-k h264|hevc|av1|vp8|vp9|hevc_hdr|av1_hdr|hevc_10bit|av1_10bit] [-ac aac|opus|flac] [-ab ] [-fm cfr|vfr|content] " "[-bm auto|qp|vbr|cbr] [-cr limited|full] [-tune performance|quality] [-df yes|no] [-sc ] [-p ] " "[-cursor yes|no] [-keyint ] [-restore-portal-session yes|no] [-portal-session-token-filepath filepath] [-encoder gpu|cpu] " "[-fallback-cpu-encoding yes|no] [-o ] [-ro ] [-ffmpeg-opts ] [--list-capture-options [card_path]] " "[--list-monitors] [--list-audio-devices] [--list-application-audio] [--list-v4l2-devices] [-write-first-frame-ts yes|no] [-low-power yes|no] " "[-v yes|no] [-gl-debug yes|no] [--version] [-h|--help]\n", program_name); fflush(stdout); } static void usage_full(void) { const bool inside_flatpak = getenv("FLATPAK_ID") != NULL; usage_header(); printf("\n"); printf("NOTES:\n"); if(inside_flatpak) printf(" Run \"man /var/lib/flatpak/app/com.dec05eba.gpu_screen_recorder/current/active/files/share/man/man1/gpu-screen-recorder.1\" to open the man page for GPU Screen Recorder to see an explanation for each option and examples\n"); else printf(" Run \"man gpu-screen-recorder.1\" to open the man page for GPU Screen Recorder to see an explanation for each option and examples\n"); fflush(stdout); } static void usage(void) { usage_header(); } // TODO: Does this match all livestreaming cases? static bool is_livestream_path(const char *str) { const int len = strlen(str); if((len >= 7 && memcmp(str, "http://", 7) == 0) || (len >= 8 && memcmp(str, "https://", 8) == 0)) return true; else if((len >= 7 && memcmp(str, "rtmp://", 7) == 0) || (len >= 8 && memcmp(str, "rtmps://", 8) == 0)) return true; else if((len >= 7 && memcmp(str, "rtsp://", 7) == 0)) return true; else if((len >= 6 && memcmp(str, "srt://", 6) == 0)) return true; else if((len >= 6 && memcmp(str, "tcp://", 6) == 0)) return true; else if((len >= 6 && memcmp(str, "udp://", 6) == 0)) return true; else return false; } static bool file_is_pipe_or_char_device(const char *filepath) { struct stat st; if(stat(filepath, &st) == -1) return false; return S_ISFIFO(st.st_mode) || S_ISCHR(st.st_mode); } static bool args_parser_set_values(args_parser *self) { self->video_encoder = (gsr_video_encoder_hardware)args_get_enum_by_key(self->args, NUM_ARGS, "-encoder", GSR_VIDEO_ENCODER_HW_GPU); self->pixel_format = (gsr_pixel_format)args_get_enum_by_key(self->args, NUM_ARGS, "-pixfmt", GSR_PIXEL_FORMAT_YUV420); self->framerate_mode = (gsr_framerate_mode)args_get_enum_by_key(self->args, NUM_ARGS, "-fm", GSR_FRAMERATE_MODE_VARIABLE); self->color_range = (gsr_color_range)args_get_enum_by_key(self->args, NUM_ARGS, "-cr", GSR_COLOR_RANGE_LIMITED); self->tune = (gsr_tune)args_get_enum_by_key(self->args, NUM_ARGS, "-tune", GSR_TUNE_PERFORMANCE); self->video_codec = (gsr_video_codec)args_get_enum_by_key(self->args, NUM_ARGS, "-k", GSR_VIDEO_CODEC_AUTO); self->audio_codec = (gsr_audio_codec)args_get_enum_by_key(self->args, NUM_ARGS, "-ac", GSR_AUDIO_CODEC_OPUS); self->bitrate_mode = (gsr_bitrate_mode)args_get_enum_by_key(self->args, NUM_ARGS, "-bm", GSR_BITRATE_MODE_AUTO); self->replay_storage = (gsr_replay_storage)args_get_enum_by_key(self->args, NUM_ARGS, "-replay-storage", GSR_REPLAY_STORAGE_RAM); self->capture_source = args_get_value_by_key(self->args, NUM_ARGS, "-w"); self->verbose = args_get_boolean_by_key(self->args, NUM_ARGS, "-v", true); self->gl_debug = args_get_boolean_by_key(self->args, NUM_ARGS, "-gl-debug", false); self->record_cursor = args_get_boolean_by_key(self->args, NUM_ARGS, "-cursor", true); self->date_folders = args_get_boolean_by_key(self->args, NUM_ARGS, "-df", false); self->restore_portal_session = args_get_boolean_by_key(self->args, NUM_ARGS, "-restore-portal-session", false); self->restart_replay_on_save = args_get_boolean_by_key(self->args, NUM_ARGS, "-restart-replay-on-save", false); const bool overclock = args_get_boolean_by_key(self->args, NUM_ARGS, "-oc", false); self->fallback_cpu_encoding = args_get_boolean_by_key(self->args, NUM_ARGS, "-fallback-cpu-encoding", false); self->write_first_frame_ts = args_get_boolean_by_key(self->args, NUM_ARGS, "-write-first-frame-ts", false); self->low_power = args_get_boolean_by_key(self->args, NUM_ARGS, "-low-power", false); self->audio_bitrate = args_get_i64_by_key(self->args, NUM_ARGS, "-ab", 0); self->audio_bitrate *= 1000LL; self->keyint = args_get_double_by_key(self->args, NUM_ARGS, "-keyint", 2.0); if(overclock) { fprintf(stderr, "gsr info: the overclock option (-oc) is deprecated and no longer has any effect as it's no longer needed (on GPUs that are 12 years old or younger)\n"); } if(self->audio_codec == GSR_AUDIO_CODEC_FLAC) { fprintf(stderr, "gsr warning: flac audio codec is temporary disabled, using opus audio codec instead\n"); self->audio_codec = GSR_AUDIO_CODEC_OPUS; } self->portal_session_token_filepath = args_get_value_by_key(self->args, NUM_ARGS, "-portal-session-token-filepath"); if(self->portal_session_token_filepath) { int len = strlen(self->portal_session_token_filepath); if(len > 0 && self->portal_session_token_filepath[len - 1] == '/') { fprintf(stderr, "gsr error: -portal-session-token-filepath should be a path to a file but it ends with a /: %s\n", self->portal_session_token_filepath); return false; } } self->recording_saved_script = args_get_value_by_key(self->args, NUM_ARGS, "-sc"); if(self->recording_saved_script) { struct stat buf; if(stat(self->recording_saved_script, &buf) == -1 || !S_ISREG(buf.st_mode)) { fprintf(stderr, "gsr error: Script \"%s\" either doesn't exist or it's not a file\n", self->recording_saved_script); usage(); return false; } if(!(buf.st_mode & S_IXUSR)) { fprintf(stderr, "gsr error: Script \"%s\" is not executable\n", self->recording_saved_script); usage(); return false; } } const char *quality_str = args_get_value_by_key(self->args, NUM_ARGS, "-q"); self->video_quality = GSR_VIDEO_QUALITY_VERY_HIGH; self->video_bitrate = 0; if(self->bitrate_mode == GSR_BITRATE_MODE_CBR) { if(!quality_str) { fprintf(stderr, "gsr error: option '-q' is required when using '-bm cbr' option\n"); usage(); return false; } if(sscanf(quality_str, "%" PRIi64, &self->video_bitrate) != 1) { fprintf(stderr, "gsr error: -q argument \"%s\" is not an integer value. When using '-bm cbr' option '-q' is expected to be an integer value\n", quality_str); usage(); return false; } if(self->video_bitrate < 0) { fprintf(stderr, "gsr error: -q is expected to be 0 or larger, got %" PRIi64 "\n", self->video_bitrate); usage(); return false; } self->video_bitrate *= 1000LL; } else { if(!quality_str) quality_str = "very_high"; if(strcmp(quality_str, "medium") == 0) { self->video_quality = GSR_VIDEO_QUALITY_MEDIUM; } else if(strcmp(quality_str, "high") == 0) { self->video_quality = GSR_VIDEO_QUALITY_HIGH; } else if(strcmp(quality_str, "very_high") == 0) { self->video_quality = GSR_VIDEO_QUALITY_VERY_HIGH; } else if(strcmp(quality_str, "ultra") == 0) { self->video_quality = GSR_VIDEO_QUALITY_ULTRA; } else { fprintf(stderr, "gsr error: -q should either be 'medium', 'high', 'very_high' or 'ultra', got: '%s'\n", quality_str); usage(); return false; } } self->output_resolution = (vec2i){0, 0}; const char *output_resolution_str = args_get_value_by_key(self->args, NUM_ARGS, "-s"); if(output_resolution_str) { if(sscanf(output_resolution_str, "%dx%d", &self->output_resolution.x, &self->output_resolution.y) != 2) { fprintf(stderr, "gsr error: invalid value for option -s '%s', expected a value in format WxH\n", output_resolution_str); usage(); return false; } if(self->output_resolution.x < 0 || self->output_resolution.y < 0) { fprintf(stderr, "gsr error: invalid value for option -s '%s', expected width and height to be greater or equal to 0\n", output_resolution_str); usage(); return false; } } self->region_size = (vec2i){0, 0}; self->region_position = (vec2i){0, 0}; const char *region_str = args_get_value_by_key(self->args, NUM_ARGS, "-region"); if(region_str) { if(sscanf(region_str, "%dx%d+%d+%d", &self->region_size.x, &self->region_size.y, &self->region_position.x, &self->region_position.y) != 4) { fprintf(stderr, "gsr error: invalid value for option -region '%s', expected a value in format WxH+X+Y\n", region_str); usage(); return false; } if(self->region_size.x < 0 || self->region_size.y < 0) { fprintf(stderr, "gsr error: invalid value for option -region '%s', expected width and height to be greater or equal to 0\n", region_str); usage(); return false; } } self->fps = args_get_i64_by_key(self->args, NUM_ARGS, "-f", 60); self->replay_buffer_size_secs = args_get_i64_by_key(self->args, NUM_ARGS, "-r", -1); if(self->replay_buffer_size_secs != -1) self->replay_buffer_size_secs += (int64_t)(self->keyint + 0.5); // Add a few seconds to account of lost packets because of non-keyframe packets skipped self->container_format = args_get_value_by_key(self->args, NUM_ARGS, "-c"); if(self->container_format && strcmp(self->container_format, "mkv") == 0) self->container_format = "matroska"; const bool is_replaying = self->replay_buffer_size_secs != -1; self->is_livestream = false; self->filename = args_get_value_by_key(self->args, NUM_ARGS, "-o"); if(self->filename) { self->is_livestream = is_livestream_path(self->filename); if(self->is_livestream) { if(is_replaying) { fprintf(stderr, "gsr error: replay mode is not applicable to live streaming\n"); return false; } } else { if(!is_replaying) { char directory_buf[PATH_MAX]; snprintf(directory_buf, sizeof(directory_buf), "%s", self->filename); char *directory = dirname(directory_buf); if(strcmp(directory, ".") != 0 && strcmp(directory, "/") != 0) { if(create_directory_recursive(directory) != 0) { fprintf(stderr, "gsr error: failed to create directory for output file: %s\n", self->filename); return false; } } } else { if(!self->container_format) { fprintf(stderr, "gsr error: option -c is required when using option -r\n"); usage(); return false; } struct stat buf; if(stat(self->filename, &buf) != -1 && !S_ISDIR(buf.st_mode)) { fprintf(stderr, "gsr error: File \"%s\" exists but it's not a directory\n", self->filename); usage(); return false; } } } } else { if(!is_replaying) { self->filename = "/dev/stdout"; } else { fprintf(stderr, "gsr error: Option -o is required when using option -r\n"); usage(); return false; } if(!self->container_format) { fprintf(stderr, "gsr error: option -c is required when not using option -o\n"); usage(); return false; } } self->is_output_piped = file_is_pipe_or_char_device(self->filename); self->low_latency_recording = self->is_livestream || self->is_output_piped; if(self->write_first_frame_ts && (self->is_livestream || self->is_output_piped)) { fprintf(stderr, "gsr warning: -write-first-frame-ts is ignored for livestreaming or when output is piped\n"); self->write_first_frame_ts = false; } self->replay_recording_directory = args_get_value_by_key(self->args, NUM_ARGS, "-ro"); if(self->is_livestream && self->recording_saved_script) { fprintf(stderr, "gsr warning: live stream detected, -sc script is ignored\n"); self->recording_saved_script = NULL; } self->ffmpeg_opts = args_get_value_by_key(self->args, NUM_ARGS, "-ffmpeg-opts"); self->ffmpeg_video_opts = args_get_value_by_key(self->args, NUM_ARGS, "-ffmpeg-video-opts"); self->ffmpeg_audio_opts = args_get_value_by_key(self->args, NUM_ARGS, "-ffmpeg-audio-opts"); return true; } bool args_parser_parse(args_parser *self, int argc, char **argv, const args_handlers *arg_handlers, void *userdata) { assert(arg_handlers); memset(self, 0, sizeof(*self)); if(argc <= 1) { usage_full(); return false; } if(argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)) { usage_full(); return false; } if(argc == 2 && strcmp(argv[1], "--info") == 0) { arg_handlers->info(userdata); return true; } if(argc == 2 && strcmp(argv[1], "--list-audio-devices") == 0) { arg_handlers->list_audio_devices(userdata); return true; } if(argc == 2 && strcmp(argv[1], "--list-application-audio") == 0) { arg_handlers->list_application_audio(userdata); return true; } if(argc == 2 && strcmp(argv[1], "--list-v4l2-devices") == 0) { arg_handlers->list_v4l2_devices(userdata); return true; } if(strcmp(argv[1], "--list-capture-options") == 0) { if(argc == 2) { arg_handlers->list_capture_options(NULL, userdata); return true; } else if(argc == 3 || argc == 4) { const char *card_path = argv[2]; arg_handlers->list_capture_options(card_path, userdata); return true; } else { fprintf(stderr, "gsr error: expected --list-capture-options to be called with either no extra arguments or 1 extra argument (card path)\n"); return false; } } if(strcmp(argv[1], "--list-monitors") == 0) { arg_handlers->list_monitors(userdata); return true; } if(argc == 2 && strcmp(argv[1], "--version") == 0) { arg_handlers->version(userdata); return true; } int arg_index = 0; self->args[arg_index++] = (Arg){ .key = "-w", .optional = false, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-c", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-f", .optional = true, .list = false, .type = ARG_TYPE_I64, .integer_value_min = 1, .integer_value_max = 1000 }; self->args[arg_index++] = (Arg){ .key = "-s", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-region", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-a", .optional = true, .list = true, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-q", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-o", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-ro", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-r", .optional = true, .list = false, .type = ARG_TYPE_I64, .integer_value_min = 2, .integer_value_max = 86400 }; self->args[arg_index++] = (Arg){ .key = "-restart-replay-on-save", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-k", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = video_codec_enums, .num_enum_values = sizeof(video_codec_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-ac", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = audio_codec_enums, .num_enum_values = sizeof(audio_codec_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-ab", .optional = true, .list = false, .type = ARG_TYPE_I64, .integer_value_min = 0, .integer_value_max = 50000 }; self->args[arg_index++] = (Arg){ .key = "-oc", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-fm", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = framerate_mode_enums, .num_enum_values = sizeof(framerate_mode_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-bm", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = bitrate_mode_enums, .num_enum_values = sizeof(bitrate_mode_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-pixfmt", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = pixel_format_enums, .num_enum_values = sizeof(pixel_format_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-v", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-gl-debug", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-df", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-sc", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-cr", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = color_range_enums, .num_enum_values = sizeof(color_range_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-tune", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = tune_enums, .num_enum_values = sizeof(tune_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-cursor", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-keyint", .optional = true, .list = false, .type = ARG_TYPE_DOUBLE, .integer_value_min = 0, .integer_value_max = 500 }; self->args[arg_index++] = (Arg){ .key = "-restore-portal-session", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-portal-session-token-filepath", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-encoder", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = video_encoder_enums, .num_enum_values = sizeof(video_encoder_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-fallback-cpu-encoding", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-replay-storage", .optional = true, .list = false, .type = ARG_TYPE_ENUM, .enum_values = replay_storage_enums, .num_enum_values = sizeof(replay_storage_enums)/sizeof(ArgEnum) }; self->args[arg_index++] = (Arg){ .key = "-p", .optional = true, .list = true, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-ffmpeg-opts", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-ffmpeg-video-opts", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-ffmpeg-audio-opts", .optional = true, .list = false, .type = ARG_TYPE_STRING }; self->args[arg_index++] = (Arg){ .key = "-write-first-frame-ts", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; self->args[arg_index++] = (Arg){ .key = "-low-power", .optional = true, .list = false, .type = ARG_TYPE_BOOLEAN }; assert(arg_index == NUM_ARGS); for(int i = 1; i < argc; i += 2) { const char *arg_name = argv[i]; Arg *arg = args_get_by_key(self->args, NUM_ARGS, arg_name); if(!arg) { fprintf(stderr, "gsr error: invalid argument '%s'\n", arg_name); usage(); return false; } if(arg->num_values > 0 && !arg->list) { fprintf(stderr, "gsr error: expected argument '%s' to only be specified once\n", arg_name); usage(); return false; } if(i + 1 >= argc) { fprintf(stderr, "gsr error: missing value for argument '%s'\n", arg_name); usage(); return false; } const char *arg_value = argv[i + 1]; switch(arg->type) { case ARG_TYPE_STRING: { break; } case ARG_TYPE_BOOLEAN: { if(strcmp(arg_value, "yes") == 0) { arg->typed_value.boolean = true; } else if(strcmp(arg_value, "no") == 0) { arg->typed_value.boolean = false; } else { fprintf(stderr, "gsr error: %s should either be 'yes' or 'no', got: '%s'\n", arg_name, arg_value); usage(); return false; } break; } case ARG_TYPE_ENUM: { if(!arg_get_enum_value_by_name(arg, arg_value, &arg->typed_value.enum_value)) { fprintf(stderr, "gsr error: %s should either be ", arg_name); arg_print_expected_enum_names(arg); fprintf(stderr, ", got: '%s'\n", arg_value); usage(); return false; } break; } case ARG_TYPE_I64: { if(sscanf(arg_value, "%" PRIi64, &arg->typed_value.i64_value) != 1) { fprintf(stderr, "gsr error: %s argument \"%s\" is not an integer\n", arg_name, arg_value); usage(); return false; } if(arg->typed_value.i64_value < arg->integer_value_min) { fprintf(stderr, "gsr error: %s argument is expected to be larger than %" PRIi64 ", got %" PRIi64 "\n", arg_name, arg->integer_value_min, arg->typed_value.i64_value); usage(); return false; } if(arg->typed_value.i64_value > arg->integer_value_max) { fprintf(stderr, "gsr error: %s argument is expected to be less than %" PRIi64 ", got %" PRIi64 "\n", arg_name, arg->integer_value_max, arg->typed_value.i64_value); usage(); return false; } break; } case ARG_TYPE_DOUBLE: { if(sscanf(arg_value, "%lf", &arg->typed_value.d_value) != 1) { fprintf(stderr, "gsr error: %s argument \"%s\" is not an floating-point number\n", arg_name, arg_value); usage(); return false; } if(arg->typed_value.d_value < arg->integer_value_min) { fprintf(stderr, "gsr error: %s argument is expected to be larger than %" PRIi64 ", got %lf\n", arg_name, arg->integer_value_min, arg->typed_value.d_value); usage(); return false; } if(arg->typed_value.d_value > arg->integer_value_max) { fprintf(stderr, "gsr error: %s argument is expected to be less than %" PRIi64 ", got %lf\n", arg_name, arg->integer_value_max, arg->typed_value.d_value); usage(); return false; } break; } } if(!arg_append_value(arg, arg_value)) { fprintf(stderr, "gsr error: failed to append argument, out of memory\n"); return false; } } for(int i = 0; i < NUM_ARGS; ++i) { const Arg *arg = &self->args[i]; if(!arg->optional && arg->num_values == 0) { fprintf(stderr, "gsr error: missing argument '%s'\n", arg->key); usage(); return false; } } return args_parser_set_values(self); } void args_parser_deinit(args_parser *self) { for(int i = 0; i < NUM_ARGS; ++i) { arg_deinit(&self->args[i]); } } bool args_parser_validate_with_gl_info(args_parser *self, gsr_egl *egl) { const bool wayland = gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_WAYLAND; if(self->bitrate_mode == (gsr_bitrate_mode)GSR_BITRATE_MODE_AUTO) { // QP is broken on steam deck, see https://github.com/ValveSoftware/SteamOS/issues/1609 self->bitrate_mode = egl->gpu_info.is_steam_deck ? GSR_BITRATE_MODE_VBR : GSR_BITRATE_MODE_QP; } if(egl->gpu_info.is_steam_deck && self->bitrate_mode == GSR_BITRATE_MODE_QP) { fprintf(stderr, "gsr warning: qp bitrate mode is not supported on Steam Deck because of Steam Deck driver bugs. Using vbr instead\n"); self->bitrate_mode = GSR_BITRATE_MODE_VBR; } if(self->video_encoder == GSR_VIDEO_ENCODER_HW_CPU && self->bitrate_mode == GSR_BITRATE_MODE_VBR) { fprintf(stderr, "gsr warning: bitrate mode has been forcefully set to qp because software encoding option doesn't support vbr option\n"); self->bitrate_mode = GSR_BITRATE_MODE_QP; } if(egl->gpu_info.is_steam_deck) { fprintf(stderr, "gsr warning: steam deck has multiple driver issues. One of them has been reported here: https://github.com/ValveSoftware/SteamOS/issues/1609\n" "If you have issues with GPU Screen Recorder on steam deck that you don't have on a desktop computer then report the issue to Valve and/or AMD.\n"); } self->very_old_gpu = false; if(egl->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA && egl->gpu_info.gpu_version != 0 && egl->gpu_info.gpu_version < 900) { fprintf(stderr, "gsr info: your gpu appears to be very old (older than maxwell architecture). Switching to lower preset\n"); self->very_old_gpu = true; } if(video_codec_is_hdr(self->video_codec) && !wayland) { fprintf(stderr, "gsr error: hdr video codec option %s is not available on X11\n", video_codec_to_string(self->video_codec)); usage(); return false; } return true; } void args_parser_print_usage(void) { usage(); } Arg* args_parser_get_arg(args_parser *self, const char *arg_name) { return args_get_by_key(self->args, NUM_ARGS, arg_name); } fsdsfdsfdsfdsf-5.13.8/src/capture/000077500000000000000000000000001520215207700170375ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/src/capture/capture.c000066400000000000000000000026731520215207700206560ustar00rootroot00000000000000#include "../../include/capture/capture.h" #include int gsr_capture_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) { assert(!cap->started); int res = cap->start(cap, capture_metadata); if(res == 0) cap->started = true; return res; } void gsr_capture_tick(gsr_capture *cap) { assert(cap->started); if(cap->tick) cap->tick(cap); } void gsr_capture_on_event(gsr_capture *cap, gsr_egl *egl) { if(cap->on_event) cap->on_event(cap, egl); } bool gsr_capture_should_stop(gsr_capture *cap, bool *err) { assert(cap->started); if(cap->should_stop) return cap->should_stop(cap, err); else return false; } int gsr_capture_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { assert(cap->started); return cap->capture(cap, capture_metadata, color_conversion); } bool gsr_capture_uses_external_image(gsr_capture *cap) { if(cap->uses_external_image) return cap->uses_external_image(cap); else return false; } bool gsr_capture_set_hdr_metadata(gsr_capture *cap, AVMasteringDisplayMetadata *mastering_display_metadata, AVContentLightMetadata *light_metadata) { if(cap->set_hdr_metadata) return cap->set_hdr_metadata(cap, mastering_display_metadata, light_metadata); else return false; } void gsr_capture_destroy(gsr_capture *cap) { cap->destroy(cap); } fsdsfdsfdsfdsf-5.13.8/src/capture/kms.c000066400000000000000000000755561520215207700200170ustar00rootroot00000000000000#include "../../include/capture/kms.h" #include "../../include/utils.h" #include "../../include/color_conversion.h" #include "../../include/cursor.h" #include "../../include/window/window.h" #include #include #include #include #include #include #include #include #define FIND_CRTC_BY_NAME_TIMEOUT_SECONDS 2.0 #define HDMI_STATIC_METADATA_TYPE1 0 #define HDMI_EOTF_SMPTE_ST2084 2 #define MAX_CONNECTOR_IDS 32 typedef struct { uint32_t connector_ids[MAX_CONNECTOR_IDS]; int num_connector_ids; } MonitorId; typedef struct { gsr_capture_kms_params params; vec2i capture_pos; vec2i capture_size; MonitorId monitor_id; gsr_monitor_rotation display_server_monitor_rotation; gsr_monitor_rotation final_monitor_rotation; unsigned int input_texture_id; unsigned int external_input_texture_id; unsigned int cursor_texture_id; bool no_modifiers_fallback; bool external_texture_fallback; struct hdr_output_metadata hdr_metadata; bool hdr_metadata_set; bool is_x11; //int drm_fd; //uint64_t prev_sequence; //bool damaged; vec2i prev_target_pos; vec2i prev_plane_size; double last_time_monitor_check; bool capture_is_combined_plane; gsr_kms_response_item *drm_fd; vec2i output_size; vec2i target_pos; } gsr_capture_kms; static void gsr_capture_kms_stop(gsr_capture_kms *self) { if(self->input_texture_id) { self->params.egl->glDeleteTextures(1, &self->input_texture_id); self->input_texture_id = 0; } if(self->external_input_texture_id) { self->params.egl->glDeleteTextures(1, &self->external_input_texture_id); self->external_input_texture_id = 0; } if(self->cursor_texture_id) { self->params.egl->glDeleteTextures(1, &self->cursor_texture_id); self->cursor_texture_id = 0; } // if(self->drm_fd > 0) { // close(self->drm_fd); // self->drm_fd = -1; // } } static int max_int(int a, int b) { return a > b ? a : b; } static void gsr_capture_kms_create_input_texture_ids(gsr_capture_kms *self) { self->params.egl->glGenTextures(1, &self->input_texture_id); self->params.egl->glBindTexture(GL_TEXTURE_2D, self->input_texture_id); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); self->params.egl->glGenTextures(1, &self->external_input_texture_id); self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->external_input_texture_id); self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0); const bool cursor_texture_id_is_external = self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA; const int cursor_texture_id_target = cursor_texture_id_is_external ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; self->params.egl->glGenTextures(1, &self->cursor_texture_id); self->params.egl->glBindTexture(cursor_texture_id_target, self->cursor_texture_id); self->params.egl->glTexParameteri(cursor_texture_id_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->params.egl->glTexParameteri(cursor_texture_id_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->params.egl->glBindTexture(cursor_texture_id_target, 0); } /* TODO: On monitor reconfiguration, find monitor x, y, width and height again. Do the same for nvfbc. */ typedef struct { MonitorId *monitor_id; const char *monitor_to_capture; int monitor_to_capture_len; int num_monitors; } MonitorCallbackUserdata; static void monitor_callback(const gsr_monitor *monitor, void *userdata) { MonitorCallbackUserdata *monitor_callback_userdata = userdata; ++monitor_callback_userdata->num_monitors; if(monitor_callback_userdata->monitor_to_capture_len != monitor->name_len || memcmp(monitor_callback_userdata->monitor_to_capture, monitor->name, monitor->name_len) != 0) return; if(monitor_callback_userdata->monitor_id->num_connector_ids < MAX_CONNECTOR_IDS) { monitor_callback_userdata->monitor_id->connector_ids[monitor_callback_userdata->monitor_id->num_connector_ids] = monitor->connector_id; ++monitor_callback_userdata->monitor_id->num_connector_ids; } if(monitor_callback_userdata->monitor_id->num_connector_ids == MAX_CONNECTOR_IDS) fprintf(stderr, "gsr warning: reached max connector ids\n"); } static vec2i rotate_capture_size_if_rotated(gsr_capture_kms *self, vec2i capture_size, gsr_monitor_rotation rotation) { if(rotation == GSR_MONITOR_ROT_90 || rotation == GSR_MONITOR_ROT_270) { int tmp_x = capture_size.x; capture_size.x = capture_size.y; capture_size.y = tmp_x; } return capture_size; } static int gsr_capture_kms_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) { gsr_capture_kms *self = cap->priv; gsr_capture_kms_create_input_texture_ids(self); gsr_monitor monitor; self->monitor_id.num_connector_ids = 0; self->is_x11 = gsr_window_get_display_server(self->params.egl->window) == GSR_DISPLAY_SERVER_X11; const gsr_connection_type connection_type = self->is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM; MonitorCallbackUserdata monitor_callback_userdata = { &self->monitor_id, self->params.display_to_capture, strlen(self->params.display_to_capture), 0, }; for_each_active_monitor_output(self->params.egl->window, self->params.egl->card_path, connection_type, monitor_callback, &monitor_callback_userdata); if(!get_monitor_by_name(self->params.egl, connection_type, self->params.display_to_capture, &monitor)) { fprintf(stderr, "gsr error: gsr_capture_kms_start: failed to find monitor by name \"%s\"\n", self->params.display_to_capture); gsr_capture_kms_stop(self); return -1; } monitor.name = self->params.display_to_capture; vec2i monitor_position = {0, 0}; drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->display_server_monitor_rotation, &monitor_position); self->capture_pos = monitor.pos; /* Monitor size is already rotated on x11 when the monitor is rotated, no need to apply it ourselves */ if(self->is_x11) self->capture_size = monitor.size; else self->capture_size = rotate_capture_size_if_rotated(self, monitor.size, self->display_server_monitor_rotation); if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) { self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution); capture_metadata->video_size = self->params.output_resolution; } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) { capture_metadata->video_size = self->params.region_size; } else { capture_metadata->video_size = self->capture_size; } self->last_time_monitor_check = clock_get_monotonic_seconds(); return 0; } // TODO: This is disabled for now because we want to be able to record at a framerate higher than the monitor framerate // static void gsr_capture_kms_tick(gsr_capture *cap) { // gsr_capture_kms *self = cap->priv; // if(self->drm_fd <= 0) // self->drm_fd = open(self->params.egl->card_path, O_RDONLY); // if(self->drm_fd <= 0) // return; // uint64_t sequence = 0; // uint64_t ns = 0; // if(drmCrtcGetSequence(self->drm_fd, 79, &sequence, &ns) != 0) // return; // if(sequence != self->prev_sequence) { // self->prev_sequence = sequence; // self->damaged = true; // } // } static gsr_kms_response_item* find_drm_by_connector_id(gsr_kms_response *kms_response, uint32_t connector_id) { for(int i = 0; i < kms_response->num_items; ++i) { if(kms_response->items[i].connector_id == connector_id && !kms_response->items[i].is_cursor) return &kms_response->items[i]; } return NULL; } static gsr_kms_response_item* find_largest_drm(gsr_kms_response *kms_response) { if(kms_response->num_items == 0) return NULL; int64_t largest_size = 0; gsr_kms_response_item *largest_drm = &kms_response->items[0]; for(int i = 0; i < kms_response->num_items; ++i) { const int64_t size = (int64_t)kms_response->items[i].width * (int64_t)kms_response->items[i].height; if(size > largest_size && !kms_response->items[i].is_cursor) { largest_size = size; largest_drm = &kms_response->items[i]; } } return largest_drm; } static gsr_kms_response_item* find_cursor_drm(gsr_kms_response *kms_response, uint32_t connector_id) { gsr_kms_response_item *cursor_drm = NULL; for(int i = 0; i < kms_response->num_items; ++i) { if(kms_response->items[i].is_cursor) { cursor_drm = &kms_response->items[i]; if(kms_response->items[i].connector_id == connector_id) break; } } return cursor_drm; } static bool hdr_metadata_is_supported_format(const struct hdr_output_metadata *hdr_metadata) { return hdr_metadata->metadata_type == HDMI_STATIC_METADATA_TYPE1 && hdr_metadata->hdmi_metadata_type1.metadata_type == HDMI_STATIC_METADATA_TYPE1 && hdr_metadata->hdmi_metadata_type1.eotf == HDMI_EOTF_SMPTE_ST2084; } // TODO: Check if this hdr data can be changed after the call to av_packet_side_data_add static void gsr_kms_set_hdr_metadata(gsr_capture_kms *self, const gsr_kms_response_item *drm_fd) { if(self->hdr_metadata_set) return; self->hdr_metadata_set = true; self->hdr_metadata = drm_fd->hdr_metadata; } static vec2i swap_vec2i(vec2i value) { int tmp = value.x; value.x = value.y; value.y = tmp; return value; } static EGLImage gsr_capture_kms_create_egl_image(gsr_capture_kms *self, const gsr_kms_response_item *drm_fd, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, bool use_modifiers) { intptr_t img_attr[44]; setup_dma_buf_attrs(img_attr, drm_fd->pixel_format, drm_fd->width, drm_fd->height, fds, offsets, pitches, modifiers, drm_fd->num_dma_bufs, use_modifiers); while(self->params.egl->eglGetError() != EGL_SUCCESS){} EGLImage image = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, img_attr); if(!image || self->params.egl->eglGetError() != EGL_SUCCESS) { if(image) self->params.egl->eglDestroyImage(self->params.egl->egl_display, image); return NULL; } return image; } static EGLImage gsr_capture_kms_create_egl_image_with_fallback(gsr_capture_kms *self, const gsr_kms_response_item *drm_fd) { // TODO: This causes a crash sometimes on steam deck, why? is it a driver bug? a vaapi pure version doesn't cause a crash. // Even ffmpeg kmsgrab causes this crash. The error is: // amdgpu: Failed to allocate a buffer: // amdgpu: size : 28508160 bytes // amdgpu: alignment : 2097152 bytes // amdgpu: domains : 4 // amdgpu: flags : 4 // amdgpu: Failed to allocate a buffer: // amdgpu: size : 28508160 bytes // amdgpu: alignment : 2097152 bytes // amdgpu: domains : 4 // amdgpu: flags : 4 // EE ../jupiter-mesa/src/gallium/drivers/radeonsi/radeon_vcn_enc.c:516 radeon_create_encoder UVD - Can't create CPB buffer. // [hevc_vaapi @ 0x55ea72b09840] Failed to upload encode parameters: 2 (resource allocation failed). // [hevc_vaapi @ 0x55ea72b09840] Encode failed: -5. // Error: avcodec_send_frame failed, error: Input/output error // Assertion pic->display_order == pic->encode_order failed at libavcodec/vaapi_encode_h265.c:765 // kms server info: kms client shutdown, shutting down the server int fds[GSR_KMS_MAX_DMA_BUFS]; uint32_t offsets[GSR_KMS_MAX_DMA_BUFS]; uint32_t pitches[GSR_KMS_MAX_DMA_BUFS]; uint64_t modifiers[GSR_KMS_MAX_DMA_BUFS]; for(int i = 0; i < drm_fd->num_dma_bufs; ++i) { fds[i] = drm_fd->dma_buf[i].fd; offsets[i] = drm_fd->dma_buf[i].offset; pitches[i] = drm_fd->dma_buf[i].pitch; modifiers[i] = drm_fd->modifier; } EGLImage image = NULL; if(self->no_modifiers_fallback) { image = gsr_capture_kms_create_egl_image(self, drm_fd, fds, offsets, pitches, modifiers, false); } else { image = gsr_capture_kms_create_egl_image(self, drm_fd, fds, offsets, pitches, modifiers, true); if(!image) { fprintf(stderr, "gsr error: gsr_capture_kms_create_egl_image_with_fallback: failed to create egl image with modifiers, trying without modifiers\n"); self->no_modifiers_fallback = true; image = gsr_capture_kms_create_egl_image(self, drm_fd, fds, offsets, pitches, modifiers, false); } } return image; } static bool gsr_capture_kms_bind_image_to_texture(gsr_capture_kms *self, EGLImage image, unsigned int texture_id, bool external_texture) { const int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; while(self->params.egl->glGetError() != 0){} self->params.egl->glBindTexture(texture_target, texture_id); self->params.egl->glEGLImageTargetTexture2DOES(texture_target, image); const bool success = self->params.egl->glGetError() == 0; self->params.egl->glBindTexture(texture_target, 0); return success; } static void gsr_capture_kms_bind_image_to_input_texture_with_fallback(gsr_capture_kms *self, EGLImage image) { if(self->external_texture_fallback) { gsr_capture_kms_bind_image_to_texture(self, image, self->external_input_texture_id, true); } else { if(!gsr_capture_kms_bind_image_to_texture(self, image, self->input_texture_id, false)) { fprintf(stderr, "gsr error: gsr_capture_kms_capture: failed to bind image to texture, trying with external texture\n"); self->external_texture_fallback = true; gsr_capture_kms_bind_image_to_texture(self, image, self->external_input_texture_id, true); } } } static gsr_kms_response_item* find_monitor_drm(gsr_capture_kms *self, bool *capture_is_combined_plane) { *capture_is_combined_plane = false; gsr_kms_response_item *drm_fd = NULL; for(int i = 0; i < self->monitor_id.num_connector_ids; ++i) { drm_fd = find_drm_by_connector_id(self->params.kms_response, self->monitor_id.connector_ids[i]); if(drm_fd) break; } // Will never happen on wayland unless the target monitor has been disconnected if(!drm_fd && self->is_x11) { drm_fd = find_largest_drm(self->params.kms_response); *capture_is_combined_plane = true; } return drm_fd; } static gsr_kms_response_item* find_cursor_drm_if_on_monitor(gsr_capture_kms *self, uint32_t monitor_connector_id, bool capture_is_combined_plane) { gsr_kms_response_item *cursor_drm_fd = find_cursor_drm(self->params.kms_response, monitor_connector_id); if(!capture_is_combined_plane && cursor_drm_fd && cursor_drm_fd->connector_id != monitor_connector_id) cursor_drm_fd = NULL; return cursor_drm_fd; } static gsr_monitor_rotation kms_rotation_to_gsr_monitor_rotation(gsr_kms_rotation rotation) { // Right now both enums have the same values return (gsr_monitor_rotation)rotation; } static int remainder_int(int a, int b) { return a - (a / b) * b; } static gsr_monitor_rotation sub_rotations(gsr_monitor_rotation rot1, gsr_monitor_rotation rot2) { return remainder_int(rot1 - rot2, 4); } static void render_drm_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, gsr_capture_metadata *capture_metadata, const gsr_kms_response_item *cursor_drm_fd, vec2i target_pos, vec2i output_size, vec2i framebuffer_size) { const vec2d scale = { self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x, self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y }; const bool cursor_texture_id_is_external = self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA; const vec2i cursor_size = {cursor_drm_fd->width, cursor_drm_fd->height}; const gsr_monitor_rotation cursor_plane_rotation = kms_rotation_to_gsr_monitor_rotation(cursor_drm_fd->rotation); const gsr_monitor_rotation rotation = sub_rotations(self->display_server_monitor_rotation, cursor_plane_rotation); vec2i cursor_pos = {cursor_drm_fd->x, cursor_drm_fd->y}; switch(rotation) { case GSR_MONITOR_ROT_0: break; case GSR_MONITOR_ROT_90: cursor_pos = swap_vec2i(cursor_pos); cursor_pos.x = framebuffer_size.x - cursor_pos.x; // TODO: Remove this horrible hack cursor_pos.x -= cursor_size.x; break; case GSR_MONITOR_ROT_180: cursor_pos.x = framebuffer_size.x - cursor_pos.x; cursor_pos.y = framebuffer_size.y - cursor_pos.y; // TODO: Remove this horrible hack cursor_pos.x -= cursor_size.x; cursor_pos.y -= cursor_size.y; break; case GSR_MONITOR_ROT_270: cursor_pos = swap_vec2i(cursor_pos); cursor_pos.y = framebuffer_size.y - cursor_pos.y; // TODO: Remove this horrible hack cursor_pos.y -= cursor_size.y; break; } cursor_pos.x -= self->params.region_position.x; cursor_pos.y -= self->params.region_position.y; cursor_pos.x *= scale.x; cursor_pos.y *= scale.y; cursor_pos.x += target_pos.x; cursor_pos.y += target_pos.y; int fds[GSR_KMS_MAX_DMA_BUFS]; uint32_t offsets[GSR_KMS_MAX_DMA_BUFS]; uint32_t pitches[GSR_KMS_MAX_DMA_BUFS]; uint64_t modifiers[GSR_KMS_MAX_DMA_BUFS]; for(int i = 0; i < cursor_drm_fd->num_dma_bufs; ++i) { fds[i] = cursor_drm_fd->dma_buf[i].fd; offsets[i] = cursor_drm_fd->dma_buf[i].offset; pitches[i] = cursor_drm_fd->dma_buf[i].pitch; modifiers[i] = cursor_drm_fd->modifier; } intptr_t img_attr_cursor[44]; setup_dma_buf_attrs(img_attr_cursor, cursor_drm_fd->pixel_format, cursor_drm_fd->width, cursor_drm_fd->height, fds, offsets, pitches, modifiers, cursor_drm_fd->num_dma_bufs, true); EGLImage cursor_image = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, img_attr_cursor); const int target = cursor_texture_id_is_external ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; self->params.egl->glBindTexture(target, self->cursor_texture_id); self->params.egl->glEGLImageTargetTexture2DOES(target, cursor_image); self->params.egl->glBindTexture(target, 0); if(cursor_image) self->params.egl->eglDestroyImage(self->params.egl->egl_display, cursor_image); self->params.egl->glEnable(GL_SCISSOR_TEST); self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y); gsr_color_conversion_draw(color_conversion, self->cursor_texture_id, cursor_pos, (vec2i){cursor_size.x * scale.x, cursor_size.y * scale.y}, (vec2i){0, 0}, cursor_size, cursor_size, gsr_monitor_rotation_to_rotation(rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, cursor_texture_id_is_external); self->params.egl->glDisable(GL_SCISSOR_TEST); } static void render_x11_cursor(gsr_capture_kms *self, gsr_color_conversion *color_conversion, gsr_capture_metadata *capture_metadata, vec2i capture_pos, vec2i target_pos, vec2i output_size) { if(!self->params.x11_cursor->visible) return; const vec2d scale = { self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x, self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y }; const vec2i cursor_pos = { target_pos.x + (self->params.x11_cursor->position.x - self->params.x11_cursor->hotspot.x - capture_pos.x) * scale.x, target_pos.y + (self->params.x11_cursor->position.y - self->params.x11_cursor->hotspot.y - capture_pos.y) * scale.y }; self->params.egl->glEnable(GL_SCISSOR_TEST); self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y); gsr_color_conversion_draw(color_conversion, self->params.x11_cursor->texture_id, cursor_pos, (vec2i){self->params.x11_cursor->size.x * scale.x, self->params.x11_cursor->size.y * scale.y}, (vec2i){0, 0}, self->params.x11_cursor->size, self->params.x11_cursor->size, GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false); self->params.egl->glDisable(GL_SCISSOR_TEST); } static void gsr_capture_kms_update_capture_size_change(gsr_capture_kms *self, gsr_color_conversion *color_conversion, vec2i target_pos, const gsr_kms_response_item *drm_fd) { if(target_pos.x != self->prev_target_pos.x || target_pos.y != self->prev_target_pos.y || drm_fd->src_w != self->prev_plane_size.x || drm_fd->src_h != self->prev_plane_size.y) { self->prev_target_pos = target_pos; self->prev_plane_size = self->capture_size; color_conversion->schedule_clear = true; } } static void gsr_capture_kms_update_connector_ids(gsr_capture_kms *self) { const double now = clock_get_monotonic_seconds(); if(now - self->last_time_monitor_check < FIND_CRTC_BY_NAME_TIMEOUT_SECONDS) return; self->last_time_monitor_check = now; /* TODO: Assume for now that there is only 1 framebuffer for all monitors and it doesn't change */ if(self->is_x11) return; self->monitor_id.num_connector_ids = 0; const gsr_connection_type connection_type = self->is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM; // MonitorCallbackUserdata monitor_callback_userdata = { // &self->monitor_id, // self->params.display_to_capture, strlen(self->params.display_to_capture), // 0, // }; // for_each_active_monitor_output(self->params.egl->window, self->params.egl->card_path, connection_type, monitor_callback, &monitor_callback_userdata); gsr_monitor monitor; if(!get_monitor_by_name(self->params.egl, connection_type, self->params.display_to_capture, &monitor)) { fprintf(stderr, "gsr error: gsr_capture_kms_update_connector_ids: failed to find monitor by name \"%s\"\n", self->params.display_to_capture); return; } self->monitor_id.num_connector_ids = 1; self->monitor_id.connector_ids[0] = monitor.connector_id; monitor.name = self->params.display_to_capture; vec2i monitor_position = {0, 0}; // TODO: This is cached. We need it updated. drm_monitor_get_display_server_data(self->params.egl->window, &monitor, &self->display_server_monitor_rotation, &monitor_position); self->capture_pos = monitor.pos; /* Monitor size is already rotated on x11 when the monitor is rotated, no need to apply it ourselves */ if(self->is_x11) self->capture_size = monitor.size; else self->capture_size = rotate_capture_size_if_rotated(self, monitor.size, self->display_server_monitor_rotation); } static void gsr_capture_kms_pre_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { gsr_capture_kms *self = cap->priv; if(self->params.kms_response->num_items == 0) { static bool error_shown = false; if(!error_shown) { error_shown = true; fprintf(stderr, "gsr error: gsr_capture_kms_pre_capture: no drm found, capture will fail\n"); } return; } gsr_capture_kms_update_connector_ids(self); self->capture_is_combined_plane = false; self->drm_fd = find_monitor_drm(self, &self->capture_is_combined_plane); if(!self->drm_fd) return; if(self->drm_fd->has_hdr_metadata && self->params.hdr && hdr_metadata_is_supported_format(&self->drm_fd->hdr_metadata)) gsr_kms_set_hdr_metadata(self, self->drm_fd); const gsr_monitor_rotation plane_rotation = kms_rotation_to_gsr_monitor_rotation(self->drm_fd->rotation); self->final_monitor_rotation = self->capture_is_combined_plane ? GSR_MONITOR_ROT_0 : sub_rotations(self->display_server_monitor_rotation, plane_rotation); self->capture_size = rotate_capture_size_if_rotated(self, (vec2i){ self->drm_fd->src_w, self->drm_fd->src_h }, self->final_monitor_rotation); if(self->params.region_size.x > 0 && self->params.region_size.y > 0) self->capture_size = self->params.region_size; self->output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size); self->target_pos = gsr_capture_get_target_position(self->output_size, capture_metadata); gsr_capture_kms_update_capture_size_change(self, color_conversion, self->target_pos, self->drm_fd); } static int gsr_capture_kms_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { (void)capture_metadata; gsr_capture_kms *self = cap->priv; if(!self->drm_fd || self->params.kms_response->num_items == 0) return -1; vec2i capture_pos = self->capture_pos; if(!self->capture_is_combined_plane) capture_pos = (vec2i){self->drm_fd->x, self->drm_fd->y}; capture_pos.x += self->params.region_position.x; capture_pos.y += self->params.region_position.y; //self->params.egl->glFlush(); //self->params.egl->glFinish(); EGLImage image = gsr_capture_kms_create_egl_image_with_fallback(self, self->drm_fd); if(image) { gsr_capture_kms_bind_image_to_input_texture_with_fallback(self, image); self->params.egl->eglDestroyImage(self->params.egl->egl_display, image); } gsr_color_conversion_draw(color_conversion, self->external_texture_fallback ? self->external_input_texture_id : self->input_texture_id, self->target_pos, self->output_size, capture_pos, self->capture_size, (vec2i){ self->drm_fd->width, self->drm_fd->height }, gsr_monitor_rotation_to_rotation(self->final_monitor_rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, self->external_texture_fallback); if(self->params.record_cursor) { gsr_kms_response_item *cursor_drm_fd = find_cursor_drm_if_on_monitor(self, self->drm_fd->connector_id, self->capture_is_combined_plane); // The cursor is handled by x11 on x11 instead of using the cursor drm plane because on prime systems with a dedicated nvidia gpu // the cursor plane is not available when the cursor is on the monitor controlled by the nvidia device. // TODO: This doesn't work properly with software cursor on x11 since it will draw the x11 cursor on top of the cursor already in the framebuffer. // Detect if software cursor is used on x11 somehow. if(self->is_x11) { vec2i cursor_monitor_offset = self->capture_pos; cursor_monitor_offset.x += self->params.region_position.x; cursor_monitor_offset.y += self->params.region_position.y; render_x11_cursor(self, color_conversion, capture_metadata, cursor_monitor_offset, self->target_pos, self->output_size); } else if(cursor_drm_fd) { const vec2i framebuffer_size = rotate_capture_size_if_rotated(self, (vec2i){ self->drm_fd->src_w, self->drm_fd->src_h }, self->final_monitor_rotation); render_drm_cursor(self, color_conversion, capture_metadata, cursor_drm_fd, self->target_pos, self->output_size, framebuffer_size); } } //self->params.egl->glFlush(); //self->params.egl->glFinish(); return 0; } static bool gsr_capture_kms_should_stop(gsr_capture *cap, bool *err) { (void)cap; if(err) *err = false; return false; } static bool gsr_capture_kms_uses_external_image(gsr_capture *cap) { (void)cap; return true; } static bool gsr_capture_kms_set_hdr_metadata(gsr_capture *cap, AVMasteringDisplayMetadata *mastering_display_metadata, AVContentLightMetadata *light_metadata) { gsr_capture_kms *self = cap->priv; if(!self->hdr_metadata_set) return false; light_metadata->MaxCLL = self->hdr_metadata.hdmi_metadata_type1.max_cll; light_metadata->MaxFALL = self->hdr_metadata.hdmi_metadata_type1.max_fall; for(int i = 0; i < 3; ++i) { mastering_display_metadata->display_primaries[i][0] = av_make_q(self->hdr_metadata.hdmi_metadata_type1.display_primaries[i].x, 50000); mastering_display_metadata->display_primaries[i][1] = av_make_q(self->hdr_metadata.hdmi_metadata_type1.display_primaries[i].y, 50000); } mastering_display_metadata->white_point[0] = av_make_q(self->hdr_metadata.hdmi_metadata_type1.white_point.x, 50000); mastering_display_metadata->white_point[1] = av_make_q(self->hdr_metadata.hdmi_metadata_type1.white_point.y, 50000); mastering_display_metadata->min_luminance = av_make_q(self->hdr_metadata.hdmi_metadata_type1.min_display_mastering_luminance, 10000); mastering_display_metadata->max_luminance = av_make_q(self->hdr_metadata.hdmi_metadata_type1.max_display_mastering_luminance, 1); mastering_display_metadata->has_primaries = true; mastering_display_metadata->has_luminance = true; return true; } // static bool gsr_capture_kms_is_damaged(gsr_capture *cap) { // gsr_capture_kms *self = cap->priv; // return self->damaged; // } // static void gsr_capture_kms_clear_damage(gsr_capture *cap) { // gsr_capture_kms *self = cap->priv; // self->damaged = false; // } static void gsr_capture_kms_destroy(gsr_capture *cap) { gsr_capture_kms *self = cap->priv; if(cap->priv) { gsr_capture_kms_stop(self); free((void*)self->params.display_to_capture); self->params.display_to_capture = NULL; free(cap->priv); cap->priv = NULL; } free(cap); } gsr_capture* gsr_capture_kms_create(const gsr_capture_kms_params *params) { if(!params) { fprintf(stderr, "gsr error: gsr_capture_kms_create params is NULL\n"); return NULL; } gsr_capture *cap = calloc(1, sizeof(gsr_capture)); if(!cap) return NULL; gsr_capture_kms *cap_kms = calloc(1, sizeof(gsr_capture_kms)); if(!cap_kms) { free(cap); return NULL; } const char *display_to_capture = strdup(params->display_to_capture); if(!display_to_capture) { free(cap); free(cap_kms); return NULL; } cap_kms->params = *params; cap_kms->params.display_to_capture = display_to_capture; *cap = (gsr_capture) { .start = gsr_capture_kms_start, //.tick = gsr_capture_kms_tick, .should_stop = gsr_capture_kms_should_stop, .pre_capture = gsr_capture_kms_pre_capture, .capture = gsr_capture_kms_capture, .uses_external_image = gsr_capture_kms_uses_external_image, .set_hdr_metadata = gsr_capture_kms_set_hdr_metadata, //.is_damaged = gsr_capture_kms_is_damaged, //.clear_damage = gsr_capture_kms_clear_damage, .destroy = gsr_capture_kms_destroy, .priv = cap_kms }; return cap; } fsdsfdsfdsfdsf-5.13.8/src/capture/nvfbc.c000066400000000000000000000437721520215207700203160ustar00rootroot00000000000000#include "../../include/capture/nvfbc.h" #include "../../external/NvFBC.h" #include "../../include/egl.h" #include "../../include/utils.h" #include "../../include/color_conversion.h" #include "../../include/window/window.h" #include #include #include #include #include #include #include #include typedef struct { gsr_capture_nvfbc_params params; void *library; NVFBC_SESSION_HANDLE nv_fbc_handle; PNVFBCCREATEINSTANCE nv_fbc_create_instance; NVFBC_API_FUNCTION_LIST nv_fbc_function_list; bool fbc_handle_created; bool capture_session_created; NVFBC_TOGL_SETUP_PARAMS setup_params; bool supports_direct_cursor; uint32_t width, height; NVFBC_TRACKING_TYPE tracking_type; uint32_t output_id; uint32_t tracking_width, tracking_height; bool nvfbc_needs_recreate; double nvfbc_dead_start; } gsr_capture_nvfbc; static int max_int(int a, int b) { return a > b ? a : b; } /* Returns 0 on failure */ static uint32_t get_output_id_from_display_name(NVFBC_RANDR_OUTPUT_INFO *outputs, uint32_t num_outputs, const char *display_name, uint32_t *width, uint32_t *height) { if(!outputs) return 0; for(uint32_t i = 0; i < num_outputs; ++i) { if(strcmp(outputs[i].name, display_name) == 0) { *width = outputs[i].trackedBox.w; *height = outputs[i].trackedBox.h; return outputs[i].dwId; } } return 0; } static bool version_at_least(int major, int minor, int expected_major, int expected_minor) { return major > expected_major || (major == expected_major && minor >= expected_minor); } static bool version_less_than(int major, int minor, int expected_major, int expected_minor) { return major < expected_major || (major == expected_major && minor < expected_minor); } static void set_func_ptr(void **dst, void *src) { *dst = src; } static bool gsr_capture_nvfbc_load_library(gsr_capture *cap) { gsr_capture_nvfbc *self = cap->priv; dlerror(); /* clear */ void *lib = dlopen("libnvidia-fbc.so.1", RTLD_LAZY); if(!lib) { fprintf(stderr, "gsr error: failed to load libnvidia-fbc.so.1, error: %s\n", dlerror()); return false; } set_func_ptr((void**)&self->nv_fbc_create_instance, dlsym(lib, "NvFBCCreateInstance")); if(!self->nv_fbc_create_instance) { fprintf(stderr, "gsr error: unable to resolve symbol 'NvFBCCreateInstance'\n"); dlclose(lib); return false; } memset(&self->nv_fbc_function_list, 0, sizeof(self->nv_fbc_function_list)); self->nv_fbc_function_list.dwVersion = NVFBC_VERSION; NVFBCSTATUS status = self->nv_fbc_create_instance(&self->nv_fbc_function_list); if(status != NVFBC_SUCCESS) { fprintf(stderr, "gsr error: failed to create NvFBC instance (status: %d)\n", status); dlclose(lib); return false; } self->library = lib; return true; } static void gsr_capture_nvfbc_destroy_session(gsr_capture_nvfbc *self) { if(self->fbc_handle_created && self->capture_session_created) { NVFBC_DESTROY_CAPTURE_SESSION_PARAMS destroy_capture_params; memset(&destroy_capture_params, 0, sizeof(destroy_capture_params)); destroy_capture_params.dwVersion = NVFBC_DESTROY_CAPTURE_SESSION_PARAMS_VER; self->nv_fbc_function_list.nvFBCDestroyCaptureSession(self->nv_fbc_handle, &destroy_capture_params); self->capture_session_created = false; } } static void gsr_capture_nvfbc_destroy_handle(gsr_capture_nvfbc *self) { if(self->fbc_handle_created) { NVFBC_DESTROY_HANDLE_PARAMS destroy_params; memset(&destroy_params, 0, sizeof(destroy_params)); destroy_params.dwVersion = NVFBC_DESTROY_HANDLE_PARAMS_VER; self->nv_fbc_function_list.nvFBCDestroyHandle(self->nv_fbc_handle, &destroy_params); self->fbc_handle_created = false; self->nv_fbc_handle = 0; } } static void gsr_capture_nvfbc_destroy_session_and_handle(gsr_capture_nvfbc *self) { gsr_capture_nvfbc_destroy_session(self); gsr_capture_nvfbc_destroy_handle(self); } static int gsr_capture_nvfbc_setup_handle(gsr_capture_nvfbc *self) { NVFBCSTATUS status; NVFBC_CREATE_HANDLE_PARAMS create_params; memset(&create_params, 0, sizeof(create_params)); create_params.dwVersion = NVFBC_CREATE_HANDLE_PARAMS_VER; create_params.bExternallyManagedContext = NVFBC_TRUE; create_params.glxCtx = self->params.egl->glx_context; create_params.glxFBConfig = self->params.egl->glx_fb_config; status = self->nv_fbc_function_list.nvFBCCreateHandle(&self->nv_fbc_handle, &create_params); if(status != NVFBC_SUCCESS) { // Reverse engineering for interoperability const uint8_t enable_key[] = { 0xac, 0x10, 0xc9, 0x2e, 0xa5, 0xe6, 0x87, 0x4f, 0x8f, 0x4b, 0xf4, 0x61, 0xf8, 0x56, 0x27, 0xe9 }; create_params.privateData = enable_key; create_params.privateDataSize = 16; status = self->nv_fbc_function_list.nvFBCCreateHandle(&self->nv_fbc_handle, &create_params); if(status != NVFBC_SUCCESS) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: %s\n", self->nv_fbc_function_list.nvFBCGetLastErrorStr(self->nv_fbc_handle)); goto error_cleanup; } } self->fbc_handle_created = true; NVFBC_GET_STATUS_PARAMS status_params; memset(&status_params, 0, sizeof(status_params)); status_params.dwVersion = NVFBC_GET_STATUS_PARAMS_VER; status = self->nv_fbc_function_list.nvFBCGetStatus(self->nv_fbc_handle, &status_params); if(status != NVFBC_SUCCESS) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: %s\n", self->nv_fbc_function_list.nvFBCGetLastErrorStr(self->nv_fbc_handle)); goto error_cleanup; } if(status_params.bCanCreateNow == NVFBC_FALSE) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: it's not possible to create a capture session on this system\n"); goto error_cleanup; } assert(gsr_window_get_display_server(self->params.egl->window) == GSR_DISPLAY_SERVER_X11); Display *display = gsr_window_get_display(self->params.egl->window); self->tracking_width = XWidthOfScreen(DefaultScreenOfDisplay(display)); self->tracking_height = XHeightOfScreen(DefaultScreenOfDisplay(display)); self->tracking_type = strcmp(self->params.display_to_capture, "screen") == 0 ? NVFBC_TRACKING_SCREEN : NVFBC_TRACKING_OUTPUT; if(self->tracking_type == NVFBC_TRACKING_OUTPUT) { if(!status_params.bXRandRAvailable) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: the xrandr extension is not available\n"); goto error_cleanup; } if(status_params.bInModeset) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: the x server is in modeset, unable to record\n"); goto error_cleanup; } self->output_id = get_output_id_from_display_name(status_params.outputs, status_params.dwOutputNum, self->params.display_to_capture, &self->tracking_width, &self->tracking_height); if(self->output_id == 0) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: display '%s' not found\n", self->params.display_to_capture); goto error_cleanup; } } self->width = self->tracking_width; self->height = self->tracking_height; return 0; error_cleanup: gsr_capture_nvfbc_destroy_session_and_handle(self); return -1; } static int gsr_capture_nvfbc_setup_session(gsr_capture_nvfbc *self) { NVFBC_CREATE_CAPTURE_SESSION_PARAMS create_capture_params; memset(&create_capture_params, 0, sizeof(create_capture_params)); create_capture_params.dwVersion = NVFBC_CREATE_CAPTURE_SESSION_PARAMS_VER; create_capture_params.eCaptureType = NVFBC_CAPTURE_TO_GL; create_capture_params.bWithCursor = (!self->params.direct_capture || self->supports_direct_cursor) ? NVFBC_TRUE : NVFBC_FALSE; if(!self->params.record_cursor) create_capture_params.bWithCursor = false; create_capture_params.eTrackingType = self->tracking_type; create_capture_params.dwSamplingRateMs = (uint32_t)ceilf(1000.0f / (float)self->params.fps); create_capture_params.bAllowDirectCapture = self->params.direct_capture ? NVFBC_TRUE : NVFBC_FALSE; create_capture_params.bPushModel = self->params.direct_capture ? NVFBC_TRUE : NVFBC_FALSE; create_capture_params.bDisableAutoModesetRecovery = true; if(self->tracking_type == NVFBC_TRACKING_OUTPUT) create_capture_params.dwOutputId = self->output_id; NVFBCSTATUS status = self->nv_fbc_function_list.nvFBCCreateCaptureSession(self->nv_fbc_handle, &create_capture_params); if(status != NVFBC_SUCCESS) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: %s\n", self->nv_fbc_function_list.nvFBCGetLastErrorStr(self->nv_fbc_handle)); return -1; } self->capture_session_created = true; memset(&self->setup_params, 0, sizeof(self->setup_params)); self->setup_params.dwVersion = NVFBC_TOGL_SETUP_PARAMS_VER; self->setup_params.eBufferFormat = NVFBC_BUFFER_FORMAT_BGRA; status = self->nv_fbc_function_list.nvFBCToGLSetUp(self->nv_fbc_handle, &self->setup_params); if(status != NVFBC_SUCCESS) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_start failed: %s\n", self->nv_fbc_function_list.nvFBCGetLastErrorStr(self->nv_fbc_handle)); gsr_capture_nvfbc_destroy_session(self); return -1; } return 0; } static void gsr_capture_nvfbc_stop(gsr_capture_nvfbc *self) { gsr_capture_nvfbc_destroy_session_and_handle(self); if(self->library) { dlclose(self->library); self->library = NULL; } if(self->params.display_to_capture) { free((void*)self->params.display_to_capture); self->params.display_to_capture = NULL; } } static int gsr_capture_nvfbc_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) { gsr_capture_nvfbc *self = cap->priv; if(!gsr_capture_nvfbc_load_library(cap)) return -1; self->supports_direct_cursor = false; int driver_major_version = 0; int driver_minor_version = 0; if(self->params.direct_capture && get_nvidia_driver_version(&driver_major_version, &driver_minor_version)) { fprintf(stderr, "gsr info: detected nvidia version: %d.%d\n", driver_major_version, driver_minor_version); // TODO: if(version_at_least(driver_major_version, driver_minor_version, 515, 57) && version_less_than(driver_major_version, driver_minor_version, 520, 56)) { self->params.direct_capture = false; fprintf(stderr, "gsr warning: \"screen-direct\" has temporary been disabled as it causes stuttering with driver versions >= 515.57 and < 520.56. Please update your driver if possible. Capturing \"screen\" instead.\n"); } // TODO: // Cursor capture disabled because moving the cursor doesn't update capture rate to monitor hz and instead captures at 10-30 hz /* if(direct_capture) { if(version_at_least(driver_major_version, driver_minor_version, 515, 57)) self->supports_direct_cursor = true; else fprintf(stderr, "gsr info: capturing \"screen-direct\" but driver version appears to be less than 515.57. Disabling capture of cursor. Please update your driver if you want to capture your cursor or record \"screen\" instead.\n"); } */ } if(gsr_capture_nvfbc_setup_handle(self) != 0) { goto error_cleanup; } if(gsr_capture_nvfbc_setup_session(self) != 0) { goto error_cleanup; } capture_metadata->video_size.x = self->tracking_width; capture_metadata->video_size.y = self->tracking_height; if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) { self->params.output_resolution = scale_keep_aspect_ratio(capture_metadata->video_size, self->params.output_resolution); capture_metadata->video_size = self->params.output_resolution; } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) { capture_metadata->video_size = self->params.region_size; } return 0; error_cleanup: gsr_capture_nvfbc_stop(self); return -1; } static bool gsr_capture_nvfbc_is_capture_monitor_connected(gsr_capture_nvfbc *self) { Display *dpy = gsr_window_get_display(self->params.egl->window); int num_monitors = 0; XRRMonitorInfo *monitors = XRRGetMonitors(dpy, DefaultRootWindow(dpy), True, &num_monitors); if(!monitors) return false; bool capture_monitor_connected = false; if(strcmp(self->params.display_to_capture, "screen") == 0) { capture_monitor_connected = num_monitors > 0; } else { for(int i = 0; i < num_monitors; ++i) { char *monitor_name = XGetAtomName(dpy, monitors[i].name); if(!monitor_name) continue; if(strcmp(monitor_name, self->params.display_to_capture) == 0) { capture_monitor_connected = true; XFree(monitor_name); break; } XFree(monitor_name); } } XRRFreeMonitors(monitors); return capture_monitor_connected; } static int gsr_capture_nvfbc_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { gsr_capture_nvfbc *self = cap->priv; const double nvfbc_recreate_retry_time_seconds = 1.0; if(self->nvfbc_needs_recreate) { const double now = clock_get_monotonic_seconds(); if(now - self->nvfbc_dead_start >= nvfbc_recreate_retry_time_seconds) { self->nvfbc_dead_start = now; /* Do not attempt to recreate the nvfbc session if the monitor isn't turned on/connected. This is to predict if the nvfbc session create below will fail since if it fails it leaks an x11 display (a bug in the nvidia driver). */ if(!gsr_capture_nvfbc_is_capture_monitor_connected(self)) return 0; gsr_capture_nvfbc_destroy_session_and_handle(self); if(gsr_capture_nvfbc_setup_handle(self) != 0) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_capture failed to recreate nvfbc handle, trying again in %f second(s)\n", nvfbc_recreate_retry_time_seconds); return -1; } if(gsr_capture_nvfbc_setup_session(self) != 0) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_capture failed to recreate nvfbc session, trying again in %f second(s)\n", nvfbc_recreate_retry_time_seconds); return -1; } fprintf(stderr, "gsr info: gsr_capture_nvfbc_capture: recreated nvfbc session after modeset recovery\n"); self->nvfbc_needs_recreate = false; } else { return 0; } } vec2i frame_size = (vec2i){self->width, self->height}; const vec2i original_frame_size = frame_size; if(self->params.region_size.x > 0 && self->params.region_size.y > 0) frame_size = self->params.region_size; const vec2i output_size = scale_keep_aspect_ratio(frame_size, capture_metadata->recording_size); const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata); NVFBC_FRAME_GRAB_INFO frame_info; memset(&frame_info, 0, sizeof(frame_info)); NVFBC_TOGL_GRAB_FRAME_PARAMS grab_params; memset(&grab_params, 0, sizeof(grab_params)); grab_params.dwVersion = NVFBC_TOGL_GRAB_FRAME_PARAMS_VER; grab_params.dwFlags = NVFBC_TOGL_GRAB_FLAGS_NOWAIT | NVFBC_TOGL_GRAB_FLAGS_FORCE_REFRESH; // TODO: Remove NVFBC_TOGL_GRAB_FLAGS_FORCE_REFRESH grab_params.pFrameGrabInfo = &frame_info; grab_params.dwTimeoutMs = 0; NVFBCSTATUS status = self->nv_fbc_function_list.nvFBCToGLGrabFrame(self->nv_fbc_handle, &grab_params); if(status != NVFBC_SUCCESS) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_capture failed: %s (%d), recreating session after %f second(s)\n", self->nv_fbc_function_list.nvFBCGetLastErrorStr(self->nv_fbc_handle), status, nvfbc_recreate_retry_time_seconds); self->nvfbc_needs_recreate = true; self->nvfbc_dead_start = clock_get_monotonic_seconds(); return 0; } //self->params.egl->glFlush(); //self->params.egl->glFinish(); gsr_color_conversion_draw(color_conversion, self->setup_params.dwTextures[grab_params.dwTextureIndex], target_pos, (vec2i){output_size.x, output_size.y}, self->params.region_position, frame_size, original_frame_size, GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_BGR, false); //self->params.egl->glFlush(); //self->params.egl->glFinish(); return 0; } static void gsr_capture_nvfbc_destroy(gsr_capture *cap) { gsr_capture_nvfbc *self = cap->priv; gsr_capture_nvfbc_stop(self); free(cap->priv); free(cap); } gsr_capture* gsr_capture_nvfbc_create(const gsr_capture_nvfbc_params *params) { if(!params) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_create params is NULL\n"); return NULL; } if(!params->display_to_capture) { fprintf(stderr, "gsr error: gsr_capture_nvfbc_create params.display_to_capture is NULL\n"); return NULL; } gsr_capture *cap = calloc(1, sizeof(gsr_capture)); if(!cap) return NULL; gsr_capture_nvfbc *cap_nvfbc = calloc(1, sizeof(gsr_capture_nvfbc)); if(!cap_nvfbc) { free(cap); return NULL; } const char *display_to_capture = strdup(params->display_to_capture); if(!display_to_capture) { free(cap); free(cap_nvfbc); return NULL; } cap_nvfbc->params = *params; cap_nvfbc->params.display_to_capture = display_to_capture; cap_nvfbc->params.fps = max_int(cap_nvfbc->params.fps, 1); *cap = (gsr_capture) { .start = gsr_capture_nvfbc_start, .tick = NULL, .should_stop = NULL, .capture = gsr_capture_nvfbc_capture, .uses_external_image = NULL, .destroy = gsr_capture_nvfbc_destroy, .priv = cap_nvfbc }; return cap; } fsdsfdsfdsfdsf-5.13.8/src/capture/portal.c000066400000000000000000000461651520215207700205200ustar00rootroot00000000000000#include "../../include/capture/portal.h" #include "../../include/color_conversion.h" #include "../../include/egl.h" #include "../../include/utils.h" #include "../../include/dbus.h" #include "../../include/pipewire_video.h" #include #include #include #include #include #define PORTAL_CAPTURE_CANCELED_BY_USER_EXIT_CODE 60 typedef enum { PORTAL_CAPTURE_SETUP_IDLE, PORTAL_CAPTURE_SETUP_IN_PROGRESS, PORTAL_CAPTURE_SETUP_FINISHED, PORTAL_CAPTURE_SETUP_FAILED } gsr_portal_capture_setup_state; typedef struct { gsr_capture_portal_params params; gsr_texture_map texture_map; gsr_dbus dbus; char *session_handle; gsr_pipewire_video pipewire; vec2i capture_size; gsr_map_texture_output pipewire_data; bool should_stop; bool stop_is_error; bool do_capture; } gsr_capture_portal; static void gsr_capture_portal_cleanup_plane_fds(gsr_capture_portal *self) { for(int i = 0; i < self->pipewire_data.num_dmabuf_data; ++i) { if(self->pipewire_data.dmabuf_data[i].fd > 0) { close(self->pipewire_data.dmabuf_data[i].fd); self->pipewire_data.dmabuf_data[i].fd = 0; } } self->pipewire_data.num_dmabuf_data = 0; } static void gsr_capture_portal_stop(gsr_capture_portal *self) { if(self->texture_map.texture_id) { self->params.egl->glDeleteTextures(1, &self->texture_map.texture_id); self->texture_map.texture_id = 0; } if(self->texture_map.external_texture_id) { self->params.egl->glDeleteTextures(1, &self->texture_map.external_texture_id); self->texture_map.external_texture_id = 0; } if(self->texture_map.cursor_texture_id) { self->params.egl->glDeleteTextures(1, &self->texture_map.cursor_texture_id); self->texture_map.cursor_texture_id = 0; } gsr_capture_portal_cleanup_plane_fds(self); gsr_pipewire_video_deinit(&self->pipewire); gsr_dbus_deinit(&self->dbus); } static void gsr_capture_portal_create_input_textures(gsr_capture_portal *self) { self->params.egl->glGenTextures(1, &self->texture_map.texture_id); self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_map.texture_id); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); self->params.egl->glGenTextures(1, &self->texture_map.external_texture_id); self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->texture_map.external_texture_id); self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0); self->params.egl->glGenTextures(1, &self->texture_map.cursor_texture_id); self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_map.cursor_texture_id); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); } static void get_default_gpu_screen_recorder_restore_token_path(char *buffer, size_t buffer_size) { const char *xdg_config_home = getenv("XDG_CONFIG_HOME"); if(xdg_config_home) { snprintf(buffer, buffer_size, "%s/gpu-screen-recorder/restore_token", xdg_config_home); } else { const char *home = getenv("HOME"); if(!home) home = "/tmp"; snprintf(buffer, buffer_size, "%s/.config/gpu-screen-recorder/restore_token", home); } } static bool create_directory_to_file(const char *filepath) { char dir[PATH_MAX]; dir[0] = '\0'; const char *split = strrchr(filepath, '/'); if(!split) /* Assuming it's the current directory (for example if filepath is "restore_token"), which doesn't need to be created */ return true; snprintf(dir, sizeof(dir), "%.*s", (int)(split - filepath), filepath); if(create_directory_recursive(dir) != 0) { fprintf(stderr, "gsr warning: gsr_capture_portal_save_restore_token: failed to create directory (%s) for restore token\n", dir); return false; } return true; } static void gsr_capture_portal_save_restore_token(const char *restore_token, const char *portal_session_token_filepath) { char restore_token_path[PATH_MAX]; restore_token_path[0] = '\0'; if(portal_session_token_filepath) snprintf(restore_token_path, sizeof(restore_token_path), "%s", portal_session_token_filepath); else get_default_gpu_screen_recorder_restore_token_path(restore_token_path, sizeof(restore_token_path)); if(!create_directory_to_file(restore_token_path)) return; FILE *f = fopen(restore_token_path, "wb"); if(!f) { fprintf(stderr, "gsr warning: gsr_capture_portal_save_restore_token: failed to create restore token file (%s)\n", restore_token_path); return; } const int restore_token_len = strlen(restore_token); if((long)fwrite(restore_token, 1, restore_token_len, f) != restore_token_len) { fprintf(stderr, "gsr warning: gsr_capture_portal_save_restore_token: failed to write restore token to file (%s)\n", restore_token_path); fclose(f); return; } fprintf(stderr, "gsr info: gsr_capture_portal_save_restore_token: saved restore token to cache (%s)\n", restore_token); fclose(f); } static void gsr_capture_portal_get_restore_token_from_cache(char *buffer, size_t buffer_size, const char *portal_session_token_filepath) { assert(buffer_size > 0); buffer[0] = '\0'; char restore_token_path[PATH_MAX]; restore_token_path[0] = '\0'; if(portal_session_token_filepath) snprintf(restore_token_path, sizeof(restore_token_path), "%s", portal_session_token_filepath); else get_default_gpu_screen_recorder_restore_token_path(restore_token_path, sizeof(restore_token_path)); FILE *f = fopen(restore_token_path, "rb"); if(!f) { fprintf(stderr, "gsr info: gsr_capture_portal_get_restore_token_from_cache: no restore token found in cache or failed to load (%s)\n", restore_token_path); return; } fseek(f, 0, SEEK_END); long file_size = ftell(f); fseek(f, 0, SEEK_SET); if(file_size > 0 && file_size < 1024 && file_size < (long)buffer_size && (long)fread(buffer, 1, file_size, f) != file_size) { buffer[0] = '\0'; fprintf(stderr, "gsr warning: gsr_capture_portal_get_restore_token_from_cache: failed to read restore token (%s)\n", restore_token_path); fclose(f); return; } if(file_size > 0 && file_size < (long)buffer_size) buffer[file_size] = '\0'; fprintf(stderr, "gsr info: gsr_capture_portal_get_restore_token_from_cache: read cached restore token (%s)\n", buffer); fclose(f); } static int gsr_capture_portal_setup_dbus(gsr_capture_portal *self, int *pipewire_fd, uint32_t *pipewire_node) { *pipewire_fd = 0; *pipewire_node = 0; int response_status = 0; char restore_token[1024]; restore_token[0] = '\0'; if(self->params.restore_portal_session) gsr_capture_portal_get_restore_token_from_cache(restore_token, sizeof(restore_token), self->params.portal_session_token_filepath); if(!gsr_dbus_init(&self->dbus, restore_token)) return -1; fprintf(stderr, "gsr info: gsr_capture_portal_setup_dbus: CreateSession\n"); response_status = gsr_dbus_screencast_create_session(&self->dbus, &self->session_handle); if(response_status != 0) { fprintf(stderr, "gsr error: gsr_capture_portal_setup_dbus: CreateSession failed\n"); return response_status; } fprintf(stderr, "gsr info: gsr_capture_portal_setup_dbus: SelectSources\n"); response_status = gsr_dbus_screencast_select_sources(&self->dbus, self->session_handle, GSR_PORTAL_CAPTURE_TYPE_ALL, self->params.record_cursor ? GSR_PORTAL_CURSOR_MODE_EMBEDDED : GSR_PORTAL_CURSOR_MODE_HIDDEN); if(response_status != 0) { fprintf(stderr, "gsr error: gsr_capture_portal_setup_dbus: SelectSources failed\n"); return response_status; } fprintf(stderr, "gsr info: gsr_capture_portal_setup_dbus: Start\n"); response_status = gsr_dbus_screencast_start(&self->dbus, self->session_handle, pipewire_node); if(response_status != 0) { fprintf(stderr, "gsr error: gsr_capture_portal_setup_dbus: Start failed\n"); return response_status; } const char *screencast_restore_token = gsr_dbus_screencast_get_restore_token(&self->dbus); if(screencast_restore_token) gsr_capture_portal_save_restore_token(screencast_restore_token, self->params.portal_session_token_filepath); fprintf(stderr, "gsr info: gsr_capture_portal_setup_dbus: OpenPipeWireRemote\n"); if(!gsr_dbus_screencast_open_pipewire_remote(&self->dbus, self->session_handle, pipewire_fd)) { fprintf(stderr, "gsr error: gsr_capture_portal_setup_dbus: OpenPipeWireRemote failed\n"); return -1; } fprintf(stderr, "gsr info: gsr_capture_portal_setup_dbus: desktop portal setup finished\n"); return 0; } static bool gsr_capture_portal_get_frame_dimensions(gsr_capture_portal *self) { fprintf(stderr, "gsr info: gsr_capture_portal_start: waiting for pipewire negotiation\n"); const double start_time = clock_get_monotonic_seconds(); while(clock_get_monotonic_seconds() - start_time < 5.0) { if(gsr_pipewire_video_map_texture(&self->pipewire, self->texture_map, &self->pipewire_data)) { self->capture_size.x = self->pipewire_data.region.width; self->capture_size.y = self->pipewire_data.region.height; fprintf(stderr, "gsr info: gsr_capture_portal_start: pipewire negotiation finished\n"); return true; } usleep(30 * 1000); /* 30 milliseconds */ } fprintf(stderr, "gsr info: gsr_capture_portal_start: timed out waiting for pipewire negotiation (5 seconds)\n"); return false; } static int gsr_capture_portal_setup(gsr_capture_portal *self, int fps) { gsr_capture_portal_create_input_textures(self); int pipewire_fd = 0; uint32_t pipewire_node = 0; const int response_status = gsr_capture_portal_setup_dbus(self, &pipewire_fd, &pipewire_node); if(response_status != 0) { // Response status values: // 0: Success, the request is carried out // 1: The user cancelled the interaction // 2: The user interaction was ended in some other way // Response status value 2 happens usually if there was some kind of error in the desktop portal on the system if(response_status == 2) { fprintf(stderr, "gsr error: gsr_capture_portal_setup: desktop portal capture failed. Either you Wayland compositor doesn't support desktop portal capture or it's incorrectly setup on your system\n"); return 50; } else if(response_status == 1) { fprintf(stderr, "gsr error: gsr_capture_portal_setup: desktop portal capture failed. It seems like desktop portal capture was canceled by the user.\n"); return PORTAL_CAPTURE_CANCELED_BY_USER_EXIT_CODE; } else { return -1; } } fprintf(stderr, "gsr info: gsr_capture_portal_setup: setting up pipewire\n"); /* TODO: support hdr when pipewire supports it */ /* gsr_pipewire closes the pipewire fd, even on failure */ if(!gsr_pipewire_video_init(&self->pipewire, pipewire_fd, pipewire_node, fps, self->params.record_cursor, self->params.egl)) { fprintf(stderr, "gsr error: gsr_capture_portal_setup: failed to setup pipewire with fd: %d, node: %" PRIu32 "\n", pipewire_fd, pipewire_node); return -1; } fprintf(stderr, "gsr info: gsr_capture_portal_setup: pipewire setup finished\n"); if(!gsr_capture_portal_get_frame_dimensions(self)) return -1; return 0; } static int gsr_capture_portal_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) { gsr_capture_portal *self = cap->priv; const int result = gsr_capture_portal_setup(self, capture_metadata->fps); if(result != 0) { gsr_capture_portal_stop(self); return result; } if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) { capture_metadata->video_size = self->capture_size; } else { self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution); capture_metadata->video_size = self->params.output_resolution; } return 0; } static int max_int(int a, int b) { return a > b ? a : b; } static bool gsr_capture_portal_capture_has_synchronous_task(gsr_capture *cap) { gsr_capture_portal *self = cap->priv; return gsr_pipewire_video_should_restart(&self->pipewire); } static bool fourcc_has_alpha(uint32_t fourcc) { const uint8_t *p = (const uint8_t*)&fourcc; for(int i = 0; i < 4; ++i) { if(p[i] == 'A') return true; } return false; } static void gsr_capture_portal_pre_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { gsr_capture_portal *self = cap->priv; self->do_capture = false; if(self->should_stop) return; if(gsr_pipewire_video_should_restart(&self->pipewire)) { fprintf(stderr, "gsr info: gsr_capture_portal_pre_capture: pipewire capture was paused, trying to start capture again\n"); gsr_capture_portal_stop(self); const int result = gsr_capture_portal_setup(self, capture_metadata->fps); if(result != 0) { self->stop_is_error = result != PORTAL_CAPTURE_CANCELED_BY_USER_EXIT_CODE; self->should_stop = true; } return; } /* TODO: Handle formats other than RGB(A) */ if(self->pipewire_data.num_dmabuf_data == 0) { if(gsr_pipewire_video_map_texture(&self->pipewire, self->texture_map, &self->pipewire_data)) { if(self->pipewire_data.region.width != self->capture_size.x || self->pipewire_data.region.height != self->capture_size.y) { self->capture_size.x = self->pipewire_data.region.width; self->capture_size.y = self->pipewire_data.region.height; color_conversion->schedule_clear = true; } } else { return; } } const bool fourcc_alpha = fourcc_has_alpha(self->pipewire_data.fourcc); if(fourcc_alpha) color_conversion->schedule_clear = true; self->do_capture = true; } static int gsr_capture_portal_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { (void)color_conversion; gsr_capture_portal *self = cap->priv; if(self->should_stop || !self->do_capture) return -1; const vec2i output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size); const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata); const vec2i actual_texture_size = {self->pipewire_data.texture_width, self->pipewire_data.texture_height}; //self->params.egl->glFlush(); //self->params.egl->glFinish(); // TODO: Handle region crop gsr_color_conversion_draw(color_conversion, self->pipewire_data.using_external_image ? self->texture_map.external_texture_id : self->texture_map.texture_id, target_pos, output_size, (vec2i){self->pipewire_data.region.x, self->pipewire_data.region.y}, (vec2i){self->pipewire_data.region.width, self->pipewire_data.region.height}, actual_texture_size, gsr_monitor_rotation_to_rotation(self->pipewire_data.rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, self->pipewire_data.using_external_image); if(self->params.record_cursor && self->texture_map.cursor_texture_id > 0 && self->pipewire_data.cursor_region.width > 0) { const vec2d scale = { self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x, self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y }; const vec2i cursor_pos = { target_pos.x + (self->pipewire_data.cursor_region.x * scale.x), target_pos.y + (self->pipewire_data.cursor_region.y * scale.y) }; self->params.egl->glEnable(GL_SCISSOR_TEST); self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y); gsr_color_conversion_draw(color_conversion, self->texture_map.cursor_texture_id, (vec2i){cursor_pos.x, cursor_pos.y}, (vec2i){self->pipewire_data.cursor_region.width * scale.x, self->pipewire_data.cursor_region.height * scale.y}, (vec2i){0, 0}, (vec2i){self->pipewire_data.cursor_region.width, self->pipewire_data.cursor_region.height}, (vec2i){self->pipewire_data.cursor_region.width, self->pipewire_data.cursor_region.height}, gsr_monitor_rotation_to_rotation(self->pipewire_data.rotation), capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false); self->params.egl->glDisable(GL_SCISSOR_TEST); } //self->params.egl->glFlush(); //self->params.egl->glFinish(); gsr_capture_portal_cleanup_plane_fds(self); return 0; } static bool gsr_capture_portal_uses_external_image(gsr_capture *cap) { (void)cap; return true; } static bool gsr_capture_portal_should_stop(gsr_capture *cap, bool *err) { gsr_capture_portal *self = cap->priv; if(err) *err = self->stop_is_error; return self->should_stop; } static bool gsr_capture_portal_is_damaged(gsr_capture *cap) { gsr_capture_portal *self = cap->priv; return gsr_pipewire_video_is_damaged(&self->pipewire); } static void gsr_capture_portal_clear_damage(gsr_capture *cap) { gsr_capture_portal *self = cap->priv; gsr_pipewire_video_clear_damage(&self->pipewire); } static void gsr_capture_portal_destroy(gsr_capture *cap) { gsr_capture_portal *self = cap->priv; if(cap->priv) { gsr_capture_portal_stop(self); free(cap->priv); cap->priv = NULL; } free(cap); } gsr_capture* gsr_capture_portal_create(const gsr_capture_portal_params *params) { if(!params) { fprintf(stderr, "gsr error: gsr_capture_portal_create params is NULL\n"); return NULL; } gsr_capture *cap = calloc(1, sizeof(gsr_capture)); if(!cap) return NULL; gsr_capture_portal *cap_portal = calloc(1, sizeof(gsr_capture_portal)); if(!cap_portal) { free(cap); return NULL; } cap_portal->params = *params; *cap = (gsr_capture) { .start = gsr_capture_portal_start, .tick = NULL, .should_stop = gsr_capture_portal_should_stop, .capture_has_synchronous_task = gsr_capture_portal_capture_has_synchronous_task, .pre_capture = gsr_capture_portal_pre_capture, .capture = gsr_capture_portal_capture, .uses_external_image = gsr_capture_portal_uses_external_image, .is_damaged = gsr_capture_portal_is_damaged, .clear_damage = gsr_capture_portal_clear_damage, .destroy = gsr_capture_portal_destroy, .priv = cap_portal }; return cap; } fsdsfdsfdsfdsf-5.13.8/src/capture/v4l2.c000066400000000000000000001074621520215207700200040ustar00rootroot00000000000000#include "../../include/capture/v4l2.h" #include "../../include/color_conversion.h" #include "../../include/egl.h" #include "../../include/utils.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define TJPF_RGB 0 #define TJPF_RGBA 7 #define TJFLAG_FASTDCT 2048 #define NUM_BUFFERS 2 #define NUM_PBOS 2 typedef void* tjhandle; typedef tjhandle (*FUNC_tjInitDecompress)(void); typedef int (*FUNC_tjDestroy)(tjhandle handle); typedef int (*FUNC_tjDecompressHeader2)(tjhandle handle, unsigned char *jpegBuf, unsigned long jpegSize, int *width, int *height, int *jpegSubsamp); typedef int (*FUNC_tjDecompress2)(tjhandle handle, const unsigned char *jpegBuf, unsigned long jpegSize, unsigned char *dstBuf, int width, int pitch, int height, int pixelFormat, int flags); typedef char* (*FUNC_tjGetErrorStr2)(tjhandle handle); typedef enum { V4L2_BUFFER_TYPE_DMABUF, V4L2_BUFFER_TYPE_MMAP } v4l2_buffer_type; typedef struct { bool yuyv; bool mjpeg; } gsr_capture_v4l2_supported_pixfmts; typedef struct { gsr_capture_v4l2_params params; vec2i capture_size; bool should_stop; bool stop_is_error; int fd; int dmabuf_fd[NUM_BUFFERS]; EGLImage dma_image[NUM_BUFFERS]; unsigned int texture_id[NUM_BUFFERS]; unsigned int prev_texture_index; bool got_first_frame; void *dmabuf_map[NUM_BUFFERS]; size_t dmabuf_size[NUM_BUFFERS]; unsigned int pbos[NUM_PBOS]; unsigned int pbo_index; v4l2_buffer_type buffer_type; void *libturbojpeg_lib; FUNC_tjInitDecompress tjInitDecompress; FUNC_tjDestroy tjDestroy; FUNC_tjDecompressHeader2 tjDecompressHeader2; FUNC_tjDecompress2 tjDecompress2; FUNC_tjGetErrorStr2 tjGetErrorStr2; tjhandle jpeg_decompressor; double capture_start_time; bool yuyv_conversion_fallback; } gsr_capture_v4l2; static int xioctl(int fd, unsigned long request, void *arg) { int r; do { r = ioctl(fd, request, arg); } while (-1 == r && EINTR == errno); return r; } static void gsr_capture_v4l2_stop(gsr_capture_v4l2 *self) { self->params.egl->glDeleteBuffers(NUM_PBOS, self->pbos); for(int i = 0; i < NUM_PBOS; ++i) { self->pbos[i] = 0; } self->params.egl->glDeleteTextures(NUM_BUFFERS, self->texture_id); for(int i = 0; i < NUM_BUFFERS; ++i) { self->texture_id[i] = 0; } for(int i = 0; i < NUM_BUFFERS; ++i) { if(self->dmabuf_map[i]) { munmap(self->dmabuf_map[i], self->dmabuf_size[i]); self->dmabuf_map[i] = NULL; } if(self->dma_image[i]) { self->params.egl->eglDestroyImage(self->params.egl->egl_display, self->dma_image[i]); self->dma_image[i] = NULL; } if(self->dmabuf_fd[i] > 0) { close(self->dmabuf_fd[i]); self->dmabuf_fd[i] = 0; } } if(self->fd > 0) { xioctl(self->fd, VIDIOC_STREAMOFF, &(enum v4l2_buf_type){V4L2_BUF_TYPE_VIDEO_CAPTURE}); close(self->fd); self->fd = 0; } if(self->jpeg_decompressor) { self->tjDestroy(self->jpeg_decompressor); self->jpeg_decompressor = NULL; } if(self->libturbojpeg_lib) { dlclose(self->libturbojpeg_lib); self->libturbojpeg_lib = NULL; } } static void gsr_capture_v4l2_reset_cropping(gsr_capture_v4l2 *self) { struct v4l2_cropcap cropcap = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE }; if(xioctl(self->fd, VIDIOC_CROPCAP, &cropcap) == 0) { struct v4l2_crop crop = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .c = cropcap.defrect /* reset to default */ }; if(xioctl(self->fd, VIDIOC_S_CROP, &crop) == -1) { switch (errno) { case EINVAL: /* Cropping not supported. */ break; default: /* Errors ignored. */ break; } } } else { /* Errors ignored. */ } } static uint32_t gsr_pixfmt_to_v4l2_pixfmt(gsr_capture_v4l2_pixfmt pixfmt) { switch(pixfmt) { case GSR_CAPTURE_V4L2_PIXFMT_AUTO: assert(false); break; case GSR_CAPTURE_V4L2_PIXFMT_YUYV: return V4L2_PIX_FMT_YUYV; case GSR_CAPTURE_V4L2_PIXFMT_MJPEG: return V4L2_PIX_FMT_MJPEG; } assert(false); return V4L2_PIX_FMT_YUYV; } const char* gsr_capture_v4l2_pixfmt_to_string(gsr_capture_v4l2_pixfmt pixfmt) { switch(pixfmt) { case GSR_CAPTURE_V4L2_PIXFMT_AUTO: assert(false); break; case GSR_CAPTURE_V4L2_PIXFMT_YUYV: return "yuyv"; case GSR_CAPTURE_V4L2_PIXFMT_MJPEG: return "mjpeg"; } assert(false); return ""; } static gsr_capture_v4l2_supported_pixfmts gsr_capture_v4l2_get_supported_pixfmts(int fd) { gsr_capture_v4l2_supported_pixfmts result = {0}; struct v4l2_fmtdesc fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE }; while(xioctl(fd, VIDIOC_ENUM_FMT, &fmt) == 0) { //fprintf(stderr, "fmt: %d, desc: %s, flags: %d\n", fmt.pixelformat, fmt.description, fmt.flags); switch(fmt.pixelformat) { case V4L2_PIX_FMT_YUYV: result.yuyv = true; break; case V4L2_PIX_FMT_MJPEG: result.mjpeg = true; break; } ++fmt.index; } return result; } /* Returns the number of resolutions added */ static size_t gsr_capture_v4l2_get_supported_resolutions(int fd, gsr_capture_v4l2_pixfmt pixfmt, gsr_capture_v4l2_resolution *resolutions, size_t max_resolutions) { size_t resolution_index = 0; struct v4l2_frmsizeenum fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .pixel_format = gsr_pixfmt_to_v4l2_pixfmt(pixfmt), }; while(xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &fmt) == 0) { if(fmt.type == V4L2_FRMSIZE_TYPE_DISCRETE && resolution_index < max_resolutions) { // Skip unsupported resolutions for now (those that eglCreateImage cant import because of pitch hardware limitation). // TODO: Find a fix for this. if(pixfmt == GSR_CAPTURE_V4L2_PIXFMT_YUYV && (fmt.discrete.width % 128 != 0)) { ++fmt.index; continue; } resolutions[resolution_index] = (gsr_capture_v4l2_resolution){ .width = fmt.discrete.width, .height = fmt.discrete.height, }; ++resolution_index; } ++fmt.index; } return resolution_index; } /* Returns the number of framerates added */ static size_t gsr_capture_v4l2_get_supported_framerates(int fd, gsr_capture_v4l2_pixfmt pixfmt, gsr_capture_v4l2_resolution resolution, gsr_capture_v4l2_framerate *framerates, size_t max_framerates) { size_t framerate_index = 0; struct v4l2_frmivalenum fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .pixel_format = gsr_pixfmt_to_v4l2_pixfmt(pixfmt), .width = resolution.width, .height = resolution.height, }; while(xioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &fmt) == 0) { if(fmt.type == V4L2_FRMIVAL_TYPE_DISCRETE && fmt.discrete.denominator > 0 && fmt.discrete.numerator > 0 && framerate_index < max_framerates) { framerates[framerate_index] = (gsr_capture_v4l2_framerate){ .denominator = fmt.discrete.denominator, .numerator = fmt.discrete.numerator, }; ++framerate_index; } ++fmt.index; } return framerate_index; } /* Returns the number of setups added */ static size_t gsr_capture_v4l2_get_supported_setups(int fd, gsr_capture_v4l2_supported_setup *supported_setups, size_t max_supported_setups, bool has_libturbojpeg_lib) { const gsr_capture_v4l2_supported_pixfmts supported_pixfmts = gsr_capture_v4l2_get_supported_pixfmts(fd); size_t num_pixfmts = 0; gsr_capture_v4l2_pixfmt pixfmts[2]; if(supported_pixfmts.yuyv) pixfmts[num_pixfmts++] = GSR_CAPTURE_V4L2_PIXFMT_YUYV; if(supported_pixfmts.mjpeg && has_libturbojpeg_lib) pixfmts[num_pixfmts++] = GSR_CAPTURE_V4L2_PIXFMT_MJPEG; gsr_capture_v4l2_resolution resolutions[32]; gsr_capture_v4l2_framerate framerates[32]; size_t supported_setup_index = 0; for(size_t pixfmt_index = 0; pixfmt_index < num_pixfmts; ++pixfmt_index) { const gsr_capture_v4l2_pixfmt pixfmt = pixfmts[pixfmt_index]; const size_t num_resolutions = gsr_capture_v4l2_get_supported_resolutions(fd, pixfmt, resolutions, 32); for(size_t resolution_index = 0; resolution_index < num_resolutions; ++resolution_index) { const gsr_capture_v4l2_resolution resolution = resolutions[resolution_index]; const size_t num_framerates = gsr_capture_v4l2_get_supported_framerates(fd, pixfmt, resolution, framerates, 32); for(size_t framerate_index = 0; framerate_index < num_framerates; ++framerate_index) { const gsr_capture_v4l2_framerate framerate = framerates[framerate_index]; if(supported_setup_index < max_supported_setups) { supported_setups[supported_setup_index] = (gsr_capture_v4l2_supported_setup){ .pixfmt = pixfmt, .resolution = resolution, .framerate = framerate, }; ++supported_setup_index; } } } } return supported_setup_index; } uint32_t gsr_capture_v4l2_framerate_to_number(gsr_capture_v4l2_framerate framerate) { return (uint32_t)((double)framerate.denominator / (double)framerate.numerator); } // TODO: Select the resolution closest to |camera_resolution|, if it's not 0, 0 static bool gsr_capture_v4l2_get_best_matching_setup( const gsr_capture_v4l2_supported_setup *supported_setups, size_t num_supported_setups, gsr_capture_v4l2_pixfmt pixfmt, uint32_t camera_fps, gsr_capture_v4l2_resolution camera_resolution, gsr_capture_v4l2_supported_setup *best_supported_setup) { memset(best_supported_setup, 0, sizeof(*best_supported_setup)); int best_match_index = -1; uint64_t best_match_score = 0; for(size_t i = 0; i < num_supported_setups; ++i) { const gsr_capture_v4l2_supported_setup *setup = &supported_setups[i]; if(pixfmt != GSR_CAPTURE_V4L2_PIXFMT_AUTO && pixfmt != setup->pixfmt) continue; uint64_t setup_resolution_width = (uint64_t)setup->resolution.width; uint64_t setup_resolution_height = (uint64_t)setup->resolution.height; uint64_t setup_framerate = gsr_capture_v4l2_framerate_to_number(setup->framerate); if(setup_resolution_width == camera_resolution.width && setup_resolution_height == camera_resolution.height) { setup_resolution_width = 50000; setup_resolution_height = 50000; } if(setup_framerate == camera_fps) { setup_framerate = 50000; } const uint64_t match_score = setup_resolution_width * setup_resolution_height * setup_framerate + (pixfmt == GSR_CAPTURE_V4L2_PIXFMT_YUYV ? 5 : 0); if(match_score > best_match_score) { best_match_score = match_score; best_match_index = i; } //fprintf(stderr, "supported setup[%d]: pixfmt: %d, size: %ux%u, fps: %u/%u\n", (int)i, setup->pixfmt, setup->resolution.width, setup->resolution.height, setup->framerate.denominator, setup->framerate.numerator); } if(best_match_index == -1) return false; //fprintf(stderr, "best match index: %d\n", best_match_index); *best_supported_setup = supported_setups[best_match_index]; return true; } /* Seems like some cameras need this? */ static void gsr_capture_v4l2_update_params(int fd) { struct v4l2_streamparm streamparm = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, }; if(xioctl(fd, VIDIOC_G_PARM, &streamparm) == -1) { fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_G_PARM failed, error: %s\n", strerror(errno)); return; } if(xioctl(fd, VIDIOC_S_PARM, &streamparm) == -1) { fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_S_PARM failed, error: %s\n", strerror(errno)); return; } } static void gsr_capture_v4l2_set_framerate(int fd, gsr_capture_v4l2_framerate framerate) { struct v4l2_streamparm streamparm = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, }; if(xioctl(fd, VIDIOC_G_PARM, &streamparm) == -1) { fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_G_PARM failed, error: %s\n", strerror(errno)); return; } streamparm.parm.capture.timeperframe.denominator = framerate.denominator; streamparm.parm.capture.timeperframe.numerator = framerate.numerator; if(xioctl(fd, VIDIOC_S_PARM, &streamparm) == -1) { fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_S_PARM failed, error: %s\n", strerror(errno)); return; } if(streamparm.parm.capture.timeperframe.denominator == 0 || streamparm.parm.capture.timeperframe.numerator == 0) { fprintf(stderr, "gsr error: gsr_capture_v4l2_set_framerate: VIDIOC_S_PARM failed, error: invalid framerate: %u/%u\n", framerate.denominator, framerate.numerator);; return; } } static bool gsr_capture_v4l2_validate_pixfmt(const gsr_capture_v4l2 *self, const gsr_capture_v4l2_supported_pixfmts supported_pixfmts) { switch(self->params.pixfmt) { case GSR_CAPTURE_V4L2_PIXFMT_AUTO: { if(!supported_pixfmts.yuyv && !supported_pixfmts.mjpeg) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support yuyv nor mjpeg. GPU Screen Recorder supports only yuyv and mjpeg at the moment. Report this as an issue, see: https://git.dec05eba.com/?p=about\n", self->params.device_path); return false; } break; } case GSR_CAPTURE_V4L2_PIXFMT_YUYV: { if(!supported_pixfmts.yuyv) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support yuyv. Try recording with pixfmt=mjpeg or pixfmt=auto instead\n", self->params.device_path); return false; } break; } case GSR_CAPTURE_V4L2_PIXFMT_MJPEG: { if(!supported_pixfmts.mjpeg) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support mjpeg. Try recording with pixfmt=yuyv or pixfmt=auto instead\n", self->params.device_path); return false; } break; } } return true; } static bool gsr_capture_v4l2_create_pbos(gsr_capture_v4l2 *self, int width, int height) { self->pbo_index = 0; self->params.egl->glGenBuffers(NUM_PBOS, self->pbos); for(int i = 0; i < NUM_PBOS; ++i) { if(self->pbos[i] == 0) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create_pbos: failed to create pixel buffer objects\n"); return false; } self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, self->pbos[i]); self->params.egl->glBufferData(GL_PIXEL_UNPACK_BUFFER, width * height * 4, 0, GL_DYNAMIC_DRAW); } self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); return true; } static bool gsr_capture_v4l2_map_buffer(gsr_capture_v4l2 *self, const struct v4l2_format *fmt) { switch(self->params.pixfmt) { case GSR_CAPTURE_V4L2_PIXFMT_AUTO: { assert(false); return false; } case GSR_CAPTURE_V4L2_PIXFMT_YUYV: { self->params.egl->glGenTextures(NUM_BUFFERS, self->texture_id); for(int i = 0; i < NUM_BUFFERS; ++i) { self->dma_image[i] = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, (intptr_t[]) { EGL_WIDTH, fmt->fmt.pix.width, EGL_HEIGHT, fmt->fmt.pix.height, EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_YUYV, EGL_DMA_BUF_PLANE0_FD_EXT, self->dmabuf_fd[i], EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0, EGL_DMA_BUF_PLANE0_PITCH_EXT, fmt->fmt.pix.bytesperline, EGL_NONE }); if(!self->dma_image[i]) { self->yuyv_conversion_fallback = true; self->dma_image[i] = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, (intptr_t[]) { EGL_WIDTH, fmt->fmt.pix.width, EGL_HEIGHT, fmt->fmt.pix.height, EGL_LINUX_DRM_FOURCC_EXT, DRM_FORMAT_RG88, EGL_DMA_BUF_PLANE0_FD_EXT, self->dmabuf_fd[i], EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0, EGL_DMA_BUF_PLANE0_PITCH_EXT, fmt->fmt.pix.bytesperline, EGL_NONE }); if(!self->dma_image[i]) { fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: eglCreateImage failed, error: %d\n", self->params.egl->eglGetError()); return false; } } self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->texture_id[i]); self->params.egl->glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, self->dma_image[i]); self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->params.egl->glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0); if(self->texture_id[i] == 0) { fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: failed to create texture\n"); return false; } } self->buffer_type = V4L2_BUFFER_TYPE_DMABUF; break; } case GSR_CAPTURE_V4L2_PIXFMT_MJPEG: { for(int i = 0; i < NUM_BUFFERS; ++i) { self->dmabuf_size[i] = fmt->fmt.pix.sizeimage; self->dmabuf_map[i] = mmap(NULL, fmt->fmt.pix.sizeimage, PROT_READ, MAP_SHARED, self->dmabuf_fd[i], 0); if(self->dmabuf_map[i] == MAP_FAILED) { fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: mmap failed, error: %s\n", strerror(errno)); return false; } // GL_RGBA is intentionally used here instead of GL_RGB, because the performance is much better when using glTexSubImage2D (22% cpu usage compared to 38% cpu usage) self->texture_id[i] = gl_create_texture(self->params.egl, fmt->fmt.pix.width, fmt->fmt.pix.height, GL_RGBA8, GL_RGBA, GL_LINEAR); if(self->texture_id[i] == 0) { fprintf(stderr, "gsr error: gsr_capture_v4l2_map_buffer: failed to create texture\n"); return false; } } if(!gsr_capture_v4l2_create_pbos(self, fmt->fmt.pix.width, fmt->fmt.pix.height)) return false; self->buffer_type = V4L2_BUFFER_TYPE_MMAP; break; } } return true; } static bool is_libturbojpeg_library_available(void) { void *libturbojpeg_lib = dlopen("libturbojpeg.so.0", RTLD_LAZY); const bool has_libturbojpeg_lib = libturbojpeg_lib != NULL; if(libturbojpeg_lib) dlclose(libturbojpeg_lib); return has_libturbojpeg_lib; } static int gsr_capture_v4l2_setup(gsr_capture_v4l2 *self) { self->fd = open(self->params.device_path, O_RDWR | O_NONBLOCK); if(self->fd < 0) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: failed to open %s, error: %s\n", self->params.device_path, strerror(errno)); return -1; } struct v4l2_capability cap = {0}; if(xioctl(self->fd, VIDIOC_QUERYCAP, &cap) == -1) { if(EINVAL == errno) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s isn't a v4l2 device\n", self->params.device_path); return -1; } else { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_QUERYCAP failed, error: %s\n", strerror(errno)); return -1; } } if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s isn't a video capture device\n", self->params.device_path); return -1; } if(!(cap.capabilities & V4L2_CAP_STREAMING)) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't support streaming i/o\n", self->params.device_path); return -1; } gsr_capture_v4l2_reset_cropping(self); const bool has_libturbojpeg_lib = is_libturbojpeg_library_available(); if(!has_libturbojpeg_lib && self->params.pixfmt == GSR_CAPTURE_V4L2_PIXFMT_AUTO) { fprintf(stderr, "gsr warning: gsr_capture_v4l2_create: libturbojpeg.so.0 isn't available on the system, yuyv camera capture will be used\n"); self->params.pixfmt = GSR_CAPTURE_V4L2_PIXFMT_YUYV; } const gsr_capture_v4l2_supported_pixfmts supported_pixfmts = gsr_capture_v4l2_get_supported_pixfmts(self->fd); if(!gsr_capture_v4l2_validate_pixfmt(self, supported_pixfmts)) return -1; gsr_capture_v4l2_supported_setup supported_setups[128]; const size_t num_supported_setups = gsr_capture_v4l2_get_supported_setups(self->fd, supported_setups, 128, has_libturbojpeg_lib); gsr_capture_v4l2_supported_setup best_supported_setup = {0}; if(!gsr_capture_v4l2_get_best_matching_setup(supported_setups, num_supported_setups, self->params.pixfmt, self->params.camera_fps, self->params.camera_resolution, &best_supported_setup)) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: %s doesn't report any frame resolutions and framerates\n", self->params.device_path); return -1; } fprintf(stderr, "gsr info: gsr_capture_v4l2_create: capturing %s at %ux%u@%dhz, pixfmt: %s\n", self->params.device_path, best_supported_setup.resolution.width, best_supported_setup.resolution.height, gsr_capture_v4l2_framerate_to_number(best_supported_setup.framerate), gsr_capture_v4l2_pixfmt_to_string(best_supported_setup.pixfmt)); gsr_capture_v4l2_update_params(self->fd); self->params.pixfmt = best_supported_setup.pixfmt; if(self->params.pixfmt == GSR_CAPTURE_V4L2_PIXFMT_MJPEG) { dlerror(); /* clear */ self->libturbojpeg_lib = dlopen("libturbojpeg.so.0", RTLD_LAZY); if(!self->libturbojpeg_lib) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: failed to load libturbojpeg.so.0 which is required for camera mjpeg capture, error: %s\n", dlerror()); return -1; } self->tjInitDecompress = (FUNC_tjInitDecompress)dlsym(self->libturbojpeg_lib, "tjInitDecompress"); self->tjDestroy = (FUNC_tjDestroy)dlsym(self->libturbojpeg_lib, "tjDestroy"); self->tjDecompressHeader2 = (FUNC_tjDecompressHeader2)dlsym(self->libturbojpeg_lib, "tjDecompressHeader2"); self->tjDecompress2 = (FUNC_tjDecompress2)dlsym(self->libturbojpeg_lib, "tjDecompress2"); self->tjGetErrorStr2 = (FUNC_tjGetErrorStr2)dlsym(self->libturbojpeg_lib, "tjGetErrorStr2"); if(!self->tjInitDecompress || !self->tjDestroy || !self->tjDecompressHeader2 || !self->tjDecompress2 || !self->tjGetErrorStr2) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: libturbojpeg.so.0 is missing functions. The libturbojpeg version installed on your system might be outdated\n"); return -1; } self->jpeg_decompressor = self->tjInitDecompress(); if(!self->jpeg_decompressor) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: failed to create jpeg decompressor\n"); return -1; } } const uint32_t v4l2_pixfmt = gsr_pixfmt_to_v4l2_pixfmt(self->params.pixfmt); struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .fmt.pix.pixelformat = v4l2_pixfmt, .fmt.pix.width = best_supported_setup.resolution.width, .fmt.pix.height = best_supported_setup.resolution.height, }; if(xioctl(self->fd, VIDIOC_S_FMT, &fmt) == -1) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_S_FMT failed, error: %s\n", strerror(errno)); return -1; } if(fmt.fmt.pix.pixelformat != v4l2_pixfmt) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: pixel format isn't as requested (got pixel format: %u, requested: %u), error: %s\n", fmt.fmt.pix.pixelformat, v4l2_pixfmt, strerror(errno)); return -1; } self->capture_size.x = fmt.fmt.pix.width; self->capture_size.y = fmt.fmt.pix.height; gsr_capture_v4l2_set_framerate(self->fd, best_supported_setup.framerate); struct v4l2_requestbuffers reqbuf = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .memory = V4L2_MEMORY_MMAP, .count = NUM_BUFFERS }; if(xioctl(self->fd, VIDIOC_REQBUFS, &reqbuf) == -1) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_REQBUFS failed, error: %s\n", strerror(errno)); return -1; } for(int i = 0; i < NUM_BUFFERS; ++i) { struct v4l2_exportbuffer expbuf = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .index = i, .flags = O_RDONLY }; if(xioctl(self->fd, VIDIOC_EXPBUF, &expbuf) == -1) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_EXPBUF failed, error: %s\n", strerror(errno)); return -1; } self->dmabuf_fd[i] = expbuf.fd; } if(!gsr_capture_v4l2_map_buffer(self, &fmt)) return -1; for(int i = 0; i < NUM_BUFFERS; ++i) { struct v4l2_buffer buf = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .index = i, .memory = V4L2_MEMORY_MMAP }; xioctl(self->fd, VIDIOC_QBUF, &buf); } if(xioctl(self->fd, VIDIOC_STREAMON, &(enum v4l2_buf_type){V4L2_BUF_TYPE_VIDEO_CAPTURE})) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create: VIDIOC_STREAMON failed, error: %s\n", strerror(errno)); return -1; } fprintf(stderr, "gsr info: gsr_capture_v4l2_create: waiting for camera %s to be ready\n", self->params.device_path); return 0; } static int gsr_capture_v4l2_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) { gsr_capture_v4l2 *self = cap->priv; const int result = gsr_capture_v4l2_setup(self); if(result != 0) { gsr_capture_v4l2_stop(self); return result; } if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) { capture_metadata->video_size = self->capture_size; } else { self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution); capture_metadata->video_size = self->params.output_resolution; } self->capture_start_time = clock_get_monotonic_seconds(); return 0; } static void gsr_capture_v4l2_tick(gsr_capture *cap) { gsr_capture_v4l2 *self = cap->priv; if(!self->got_first_frame && !self->should_stop) { const double timeout_sec = 5.0; if(clock_get_monotonic_seconds() - self->capture_start_time >= timeout_sec) { fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: didn't receive camera data in %f seconds\n", timeout_sec); self->should_stop = true; self->stop_is_error = true; } } } static void gsr_capture_v4l2_decode_jpeg_to_texture(gsr_capture_v4l2 *self, const struct v4l2_buffer *buf) { int jpeg_subsamp = 0; int jpeg_width = 0; int jpeg_height = 0; if(self->tjDecompressHeader2(self->jpeg_decompressor, self->dmabuf_map[buf->index], buf->bytesused, &jpeg_width, &jpeg_height, &jpeg_subsamp) != 0) { fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: failed to decompress camera jpeg header data, error: %s\n", self->tjGetErrorStr2(self->jpeg_decompressor)); return; } if(jpeg_width != self->capture_size.x || jpeg_height != self->capture_size.y) { fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: got jpeg data of incorrect dimensions. Expected %dx%d, got %dx%d\n", self->capture_size.x, self->capture_size.y, jpeg_width, jpeg_height); return; } self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_id[buf->index]); self->pbo_index = (self->pbo_index + 1) % NUM_PBOS; const unsigned int next_pbo_index = (self->pbo_index + 1) % NUM_PBOS; self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, self->pbos[self->pbo_index]); self->params.egl->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, self->capture_size.x, self->capture_size.y, GL_RGBA, GL_UNSIGNED_BYTE, NULL); self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, self->pbos[next_pbo_index]); self->params.egl->glBufferData(GL_PIXEL_UNPACK_BUFFER, self->capture_size.x * self->capture_size.y * 4, 0, GL_DYNAMIC_DRAW); void *mapped_buffer = self->params.egl->glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, self->capture_size.x * self->capture_size.y * 4, GL_MAP_WRITE_BIT); if(mapped_buffer) { if(self->tjDecompress2(self->jpeg_decompressor, self->dmabuf_map[buf->index], buf->bytesused, mapped_buffer, jpeg_width, 0, jpeg_height, TJPF_RGBA, TJFLAG_FASTDCT) != 0) fprintf(stderr, "gsr error: gsr_capture_v4l2_capture: failed to decompress camera jpeg data, error: %s\n", self->tjGetErrorStr2(self->jpeg_decompressor)); self->params.egl->glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER); } self->params.egl->glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); } static int gsr_capture_v4l2_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { (void)color_conversion; gsr_capture_v4l2 *self = cap->priv; struct v4l2_buffer buf = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, .memory = V4L2_MEMORY_MMAP }; xioctl(self->fd, VIDIOC_DQBUF, &buf); unsigned int texture_index = buf.index; if(buf.bytesused > 0 && !(buf.flags & V4L2_BUF_FLAG_ERROR)) { if(!self->got_first_frame) fprintf(stderr, "gsr info: gsr_capture_v4l2_capture: camera %s is now ready\n", self->params.device_path); self->got_first_frame = true; switch(self->buffer_type) { case V4L2_BUFFER_TYPE_DMABUF: { //self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, self->texture_id); //self->params.egl->glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, self->dma_image[buf.index]); //self->params.egl->glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0); break; } case V4L2_BUFFER_TYPE_MMAP: { //xioctl(self->dmabuf_fd[buf.index], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync){ .flags = DMA_BUF_SYNC_START }); gsr_capture_v4l2_decode_jpeg_to_texture(self, &buf); //xioctl(self->dmabuf_fd[buf.index], DMA_BUF_IOCTL_SYNC, &(struct dma_buf_sync){ .flags = DMA_BUF_SYNC_END }); break; } } self->prev_texture_index = buf.index; } else { texture_index = self->prev_texture_index; } xioctl(self->fd, VIDIOC_QBUF, &buf); const vec2i output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size); const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata); self->params.egl->glFlush(); // TODO: Use the minimal barrier required self->params.egl->glMemoryBarrier(GL_ALL_BARRIER_BITS); // TODO: Remove this? if(self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) self->params.egl->glFinish(); if(self->buffer_type == V4L2_BUFFER_TYPE_DMABUF) { gsr_color_conversion_draw(color_conversion, self->texture_id[texture_index], target_pos, output_size, (vec2i){0, 0}, self->capture_size, self->capture_size, GSR_ROT_0, capture_metadata->flip, self->yuyv_conversion_fallback ? GSR_SOURCE_COLOR_YUYV : GSR_SOURCE_COLOR_RGB, true); } else { gsr_color_conversion_draw(color_conversion, self->texture_id[texture_index], target_pos, output_size, (vec2i){0, 0}, self->capture_size, self->capture_size, GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false); } return self->got_first_frame ? 0 : -1; } static bool gsr_capture_v4l2_uses_external_image(gsr_capture *cap) { (void)cap; return true; } static bool gsr_capture_v4l2_should_stop(gsr_capture *cap, bool *err) { gsr_capture_v4l2 *self = cap->priv; if(err) *err = self->stop_is_error; return self->should_stop; } static bool gsr_capture_v4l2_is_damaged(gsr_capture *cap) { gsr_capture_v4l2 *self = cap->priv; struct pollfd poll_data = { .fd = self->fd, .events = POLLIN, .revents = 0 }; return poll(&poll_data, 1, 0) > 0 && (poll_data.revents & POLLIN); } static void gsr_capture_v4l2_clear_damage(gsr_capture *cap) { gsr_capture_v4l2 *self = cap->priv; (void)self; } static void gsr_capture_v4l2_destroy(gsr_capture *cap) { gsr_capture_v4l2 *self = cap->priv; if(cap->priv) { gsr_capture_v4l2_stop(self); free(cap->priv); cap->priv = NULL; } free(cap); } gsr_capture* gsr_capture_v4l2_create(const gsr_capture_v4l2_params *params) { if(!params) { fprintf(stderr, "gsr error: gsr_capture_v4l2_create params is NULL\n"); return NULL; } gsr_capture *cap = calloc(1, sizeof(gsr_capture)); if(!cap) return NULL; gsr_capture_v4l2 *cap_camera = calloc(1, sizeof(gsr_capture_v4l2)); if(!cap_camera) { free(cap); return NULL; } cap_camera->params = *params; *cap = (gsr_capture) { .start = gsr_capture_v4l2_start, .tick = gsr_capture_v4l2_tick, .should_stop = gsr_capture_v4l2_should_stop, .capture = gsr_capture_v4l2_capture, .uses_external_image = gsr_capture_v4l2_uses_external_image, .is_damaged = gsr_capture_v4l2_is_damaged, .clear_damage = gsr_capture_v4l2_clear_damage, .destroy = gsr_capture_v4l2_destroy, .priv = cap_camera }; return cap; } void gsr_capture_v4l2_list_devices(v4l2_devices_query_callback callback, void *userdata) { const bool has_libturbojpeg_lib = is_libturbojpeg_library_available(); char v4l2_device_path[128]; gsr_capture_v4l2_supported_setup supported_setups[128]; for(int i = 0; i < 8; ++i) { snprintf(v4l2_device_path, sizeof(v4l2_device_path), "/dev/video%d", i); const int fd = open(v4l2_device_path, O_RDWR | O_NONBLOCK); if(fd < 0) continue; struct v4l2_capability cap = {0}; if(xioctl(fd, VIDIOC_QUERYCAP, &cap) == -1) goto next; if(!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) goto next; if(!(cap.capabilities & V4L2_CAP_STREAMING)) goto next; struct v4l2_format fmt = { .type = V4L2_BUF_TYPE_VIDEO_CAPTURE }; if(xioctl(fd, VIDIOC_G_FMT, &fmt) == -1) goto next; const size_t num_supported_setups = gsr_capture_v4l2_get_supported_setups(fd, supported_setups, 128, has_libturbojpeg_lib); if(num_supported_setups == 0) continue; for(size_t j = 0; j < num_supported_setups; ++j) { const gsr_capture_v4l2_supported_setup *setup = &supported_setups[j]; callback(v4l2_device_path, setup, userdata); } next: close(fd); } } fsdsfdsfdsfdsf-5.13.8/src/capture/xcomposite.c000066400000000000000000000272661520215207700214120ustar00rootroot00000000000000#include "../../include/capture/xcomposite.h" #include "../../include/window_texture.h" #include "../../include/utils.h" #include "../../include/cursor.h" #include "../../include/color_conversion.h" #include "../../include/window/window.h" #include #include #include #include #include typedef struct { gsr_capture_xcomposite_params params; Display *display; bool should_stop; bool stop_is_error; bool window_resized; bool follow_focused_initialized; bool init_new_window; Window window; vec2i window_pos; vec2i window_size; vec2i texture_size; double window_resize_timer; WindowTexture window_texture; Atom net_active_window_atom; bool clear_background; } gsr_capture_xcomposite; static void gsr_capture_xcomposite_stop(gsr_capture_xcomposite *self) { window_texture_deinit(&self->window_texture); } static int max_int(int a, int b) { return a > b ? a : b; } static Window get_focused_window(Display *display, Atom net_active_window_atom) { Atom type; int format = 0; unsigned long num_items = 0; unsigned long bytes_after = 0; unsigned char *properties = NULL; if(XGetWindowProperty(display, DefaultRootWindow(display), net_active_window_atom, 0, 1024, False, AnyPropertyType, &type, &format, &num_items, &bytes_after, &properties) == Success && properties) { Window focused_window = *(unsigned long*)properties; XFree(properties); return focused_window; } return None; } static int gsr_capture_xcomposite_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) { gsr_capture_xcomposite *self = cap->priv; if(self->params.follow_focused) { self->net_active_window_atom = XInternAtom(self->display, "_NET_ACTIVE_WINDOW", False); if(!self->net_active_window_atom) { fprintf(stderr, "gsr error: gsr_capture_xcomposite_start failed: failed to get _NET_ACTIVE_WINDOW atom\n"); return -1; } self->window = get_focused_window(self->display, self->net_active_window_atom); } else { self->window = self->params.window; } /* TODO: Do these in tick, and allow error if follow_focused */ XWindowAttributes attr; if(!XGetWindowAttributes(self->display, self->window, &attr) && !self->params.follow_focused) { fprintf(stderr, "gsr error: gsr_capture_xcomposite_start failed: invalid window id: %lu\n", self->window); return -1; } self->window_pos.x = attr.x; self->window_pos.y = attr.y; self->window_size.x = max_int(attr.width, 0); self->window_size.y = max_int(attr.height, 0); // TODO: Get select and add these on top of it and then restore at the end. Also do the same in other xcomposite XSelectInput(self->display, self->window, StructureNotifyMask | ExposureMask); if(window_texture_init(&self->window_texture, self->display, self->window, self->params.egl) != 0 && !self->params.follow_focused) { fprintf(stderr, "gsr error: gsr_capture_xcomposite_start: failed to get window texture for window %ld\n", (long)self->window); return -1; } self->texture_size.x = self->window_texture.window_width; self->texture_size.y = self->window_texture.window_height; if(self->params.output_resolution.x == 0 && self->params.output_resolution.y == 0) { capture_metadata->video_size = self->texture_size; } else { capture_metadata->video_size = self->params.output_resolution; } self->window_resize_timer = clock_get_monotonic_seconds(); return 0; } static void gsr_capture_xcomposite_tick(gsr_capture *cap) { gsr_capture_xcomposite *self = cap->priv; if(self->params.follow_focused && !self->follow_focused_initialized) { self->init_new_window = true; } if(self->init_new_window) { self->init_new_window = false; Window focused_window = get_focused_window(self->display, self->net_active_window_atom); if(focused_window != self->window || !self->follow_focused_initialized) { self->follow_focused_initialized = true; XSelectInput(self->display, self->window, 0); self->window = focused_window; XSelectInput(self->display, self->window, StructureNotifyMask | ExposureMask); XWindowAttributes attr; attr.width = 0; attr.height = 0; if(!XGetWindowAttributes(self->display, self->window, &attr)) fprintf(stderr, "gsr error: gsr_capture_xcomposite_tick failed: invalid window id: %lu\n", self->window); self->window_pos.x = attr.x; self->window_pos.y = attr.y; self->window_size.x = max_int(attr.width, 0); self->window_size.y = max_int(attr.height, 0); window_texture_deinit(&self->window_texture); window_texture_init(&self->window_texture, self->display, self->window, self->params.egl); // TODO: Do not do the below window_texture_on_resize after this self->texture_size.x = self->window_texture.window_width; self->texture_size.y = self->window_texture.window_height; self->window_resized = false; self->clear_background = true; } } const double window_resize_timeout = 1.0; // 1 second if(self->window_resized && clock_get_monotonic_seconds() - self->window_resize_timer >= window_resize_timeout) { self->window_resized = false; if(window_texture_on_resize(&self->window_texture) != 0) { fprintf(stderr, "gsr error: gsr_capture_xcomposite_tick: window_texture_on_resize failed\n"); //self->should_stop = true; //self->stop_is_error = true; return; } self->texture_size.x = self->window_texture.window_width; self->texture_size.y = self->window_texture.window_height; self->clear_background = true; } } static void gsr_capture_xcomposite_on_event(gsr_capture *cap, gsr_egl *egl) { gsr_capture_xcomposite *self = cap->priv; XEvent *xev = gsr_window_get_event_data(egl->window); switch(xev->type) { case DestroyNotify: { /* Window died (when not following focused window), so we stop recording */ if(!self->params.follow_focused && xev->xdestroywindow.window == self->window) { self->should_stop = true; self->stop_is_error = false; } break; } case Expose: { /* Requires window texture recreate */ if(xev->xexpose.count == 0 && xev->xexpose.window == self->window) { self->window_resize_timer = clock_get_monotonic_seconds(); self->window_resized = true; } break; } case ConfigureNotify: { // TODO: Use PresentConfigureNotify instead self->window_pos.x = xev->xconfigure.x; self->window_pos.y = xev->xconfigure.y; /* Window resized */ if(xev->xconfigure.window == self->window && (xev->xconfigure.width != self->window_size.x || xev->xconfigure.height != self->window_size.y)) { self->window_size.x = max_int(xev->xconfigure.width, 0); self->window_size.y = max_int(xev->xconfigure.height, 0); self->window_resize_timer = clock_get_monotonic_seconds(); self->window_resized = true; } break; } case PropertyNotify: { /* Focused window changed */ if(self->params.follow_focused && xev->xproperty.atom == self->net_active_window_atom) { self->init_new_window = true; } break; } } } static bool gsr_capture_xcomposite_should_stop(gsr_capture *cap, bool *err) { gsr_capture_xcomposite *self = cap->priv; if(self->should_stop) { if(err) *err = self->stop_is_error; return true; } if(err) *err = false; return false; } static void gsr_capture_xcomposite_pre_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { (void)capture_metadata; gsr_capture_xcomposite *self = cap->priv; if(self->clear_background) { self->clear_background = false; color_conversion->schedule_clear = true; } } static int gsr_capture_xcomposite_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { gsr_capture_xcomposite *self = cap->priv; const vec2i output_size = scale_keep_aspect_ratio(self->texture_size, capture_metadata->recording_size); const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata); //self->params.egl->glFlush(); //self->params.egl->glFinish(); gsr_color_conversion_draw(color_conversion, window_texture_get_opengl_texture_id(&self->window_texture), target_pos, output_size, (vec2i){0, 0}, self->texture_size, self->texture_size, GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false); if(self->params.record_cursor && self->params.cursor->visible) { const vec2d scale = { self->texture_size.x == 0 ? 0 : (double)output_size.x / (double)self->texture_size.x, self->texture_size.y == 0 ? 0 : (double)output_size.y / (double)self->texture_size.y }; const vec2i cursor_pos = { target_pos.x + (self->params.cursor->position.x - self->params.cursor->hotspot.x - self->window_pos.x) * scale.x, target_pos.y + (self->params.cursor->position.y - self->params.cursor->hotspot.y - self->window_pos.y) * scale.y }; self->params.egl->glEnable(GL_SCISSOR_TEST); self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y); gsr_color_conversion_draw(color_conversion, self->params.cursor->texture_id, cursor_pos, (vec2i){self->params.cursor->size.x * scale.x, self->params.cursor->size.y * scale.y}, (vec2i){0, 0}, self->params.cursor->size, self->params.cursor->size, GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false); self->params.egl->glDisable(GL_SCISSOR_TEST); } //self->params.egl->glFlush(); //self->params.egl->glFinish(); return 0; } static uint64_t gsr_capture_xcomposite_get_window_id(gsr_capture *cap) { gsr_capture_xcomposite *self = cap->priv; return self->window; } static void gsr_capture_xcomposite_destroy(gsr_capture *cap) { if(cap->priv) { gsr_capture_xcomposite_stop(cap->priv); free(cap->priv); cap->priv = NULL; } free(cap); } gsr_capture* gsr_capture_xcomposite_create(const gsr_capture_xcomposite_params *params) { if(!params) { fprintf(stderr, "gsr error: gsr_capture_xcomposite_create params is NULL\n"); return NULL; } gsr_capture *cap = calloc(1, sizeof(gsr_capture)); if(!cap) return NULL; gsr_capture_xcomposite *cap_xcomp = calloc(1, sizeof(gsr_capture_xcomposite)); if(!cap_xcomp) { free(cap); return NULL; } cap_xcomp->params = *params; cap_xcomp->display = gsr_window_get_display(params->egl->window); *cap = (gsr_capture) { .start = gsr_capture_xcomposite_start, .on_event = gsr_capture_xcomposite_on_event, .tick = gsr_capture_xcomposite_tick, .should_stop = gsr_capture_xcomposite_should_stop, .pre_capture = gsr_capture_xcomposite_pre_capture, .capture = gsr_capture_xcomposite_capture, .uses_external_image = NULL, .get_window_id = gsr_capture_xcomposite_get_window_id, .destroy = gsr_capture_xcomposite_destroy, .priv = cap_xcomp }; return cap; } fsdsfdsfdsfdsf-5.13.8/src/capture/ximage.c000066400000000000000000000200451520215207700204560ustar00rootroot00000000000000#include "../../include/capture/ximage.h" #include "../../include/utils.h" #include "../../include/cursor.h" #include "../../include/color_conversion.h" #include "../../include/window/window.h" #include #include #include #include #include /* TODO: update when monitors are reconfigured */ typedef struct { gsr_capture_ximage_params params; Display *display; gsr_monitor monitor; vec2i capture_pos; vec2i capture_size; unsigned int texture_id; Window root_window; } gsr_capture_ximage; static void gsr_capture_ximage_stop(gsr_capture_ximage *self) { if(self->texture_id) { self->params.egl->glDeleteTextures(1, &self->texture_id); self->texture_id = 0; } } static int max_int(int a, int b) { return a > b ? a : b; } static int gsr_capture_ximage_start(gsr_capture *cap, gsr_capture_metadata *capture_metadata) { gsr_capture_ximage *self = cap->priv; self->root_window = DefaultRootWindow(self->display); if(!get_monitor_by_name(self->params.egl, GSR_CONNECTION_X11, self->params.display_to_capture, &self->monitor)) { fprintf(stderr, "gsr error: gsr_capture_ximage_start: failed to find monitor by name \"%s\"\n", self->params.display_to_capture); gsr_capture_ximage_stop(self); return -1; } self->capture_pos = self->monitor.pos; self->capture_size = self->monitor.size; if(self->params.region_size.x > 0 && self->params.region_size.y > 0) self->capture_size = self->params.region_size; if(self->params.output_resolution.x > 0 && self->params.output_resolution.y > 0) { self->params.output_resolution = scale_keep_aspect_ratio(self->capture_size, self->params.output_resolution); capture_metadata->video_size = self->params.output_resolution; } else if(self->params.region_size.x > 0 && self->params.region_size.y > 0) { capture_metadata->video_size = self->params.region_size; } else { capture_metadata->video_size = self->capture_size; } self->texture_id = gl_create_texture(self->params.egl, self->capture_size.x, self->capture_size.y, GL_RGB8, GL_RGB, GL_LINEAR); if(self->texture_id == 0) { fprintf(stderr, "gsr error: gsr_capture_ximage_start: failed to create texture\n"); gsr_capture_ximage_stop(self); return -1; } return 0; } static bool gsr_capture_ximage_upload_to_texture(gsr_capture_ximage *self, int x, int y, int width, int height) { const int max_width = XWidthOfScreen(DefaultScreenOfDisplay(self->display)); const int max_height = XHeightOfScreen(DefaultScreenOfDisplay(self->display)); if(x < 0) x = 0; else if(x >= max_width) x = max_width - 1; if(y < 0) y = 0; else if(y >= max_height) y = max_height - 1; if(width < 0) width = 0; else if(x + width >= max_width) width = max_width - x; if(height < 0) height = 0; else if(y + height >= max_height) height = max_height - y; XImage *image = XGetImage(self->display, self->root_window, x, y, width, height, AllPlanes, ZPixmap); if(!image) { fprintf(stderr, "gsr error: gsr_capture_ximage_upload_to_texture: XGetImage failed\n"); return false; } bool success = false; uint8_t *image_data = malloc(image->width * image->height * 3); if(!image_data) { fprintf(stderr, "gsr error: gsr_capture_ximage_upload_to_texture: failed to allocate image data\n"); goto done; } for(int y = 0; y < image->height; ++y) { for(int x = 0; x < image->width; ++x) { unsigned long pixel = XGetPixel(image, x, y); unsigned char red = (pixel & image->red_mask) >> 16; unsigned char green = (pixel & image->green_mask) >> 8; unsigned char blue = pixel & image->blue_mask; const size_t texture_data_index = (x + y * image->width) * 3; image_data[texture_data_index + 0] = red; image_data[texture_data_index + 1] = green; image_data[texture_data_index + 2] = blue; } } self->params.egl->glBindTexture(GL_TEXTURE_2D, self->texture_id); // TODO: Change to GL_RGBA for better performance? image_data needs alpha then as well self->params.egl->glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image->width, image->height, GL_RGB, GL_UNSIGNED_BYTE, image_data); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); success = true; done: free(image_data); XDestroyImage(image); return success; } static int gsr_capture_ximage_capture(gsr_capture *cap, gsr_capture_metadata *capture_metadata, gsr_color_conversion *color_conversion) { gsr_capture_ximage *self = cap->priv; const vec2i output_size = scale_keep_aspect_ratio(self->capture_size, capture_metadata->recording_size); const vec2i target_pos = gsr_capture_get_target_position(output_size, capture_metadata); gsr_capture_ximage_upload_to_texture(self, self->capture_pos.x + self->params.region_position.x, self->capture_pos.y + self->params.region_position.y, self->capture_size.x, self->capture_size.y); gsr_color_conversion_draw(color_conversion, self->texture_id, target_pos, output_size, (vec2i){0, 0}, self->capture_size, self->capture_size, GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false); if(self->params.record_cursor && self->params.cursor->visible) { const vec2d scale = { self->capture_size.x == 0 ? 0 : (double)output_size.x / (double)self->capture_size.x, self->capture_size.y == 0 ? 0 : (double)output_size.y / (double)self->capture_size.y }; const vec2i cursor_pos = { target_pos.x + (self->params.cursor->position.x - self->params.cursor->hotspot.x) * scale.x - self->capture_pos.x - self->params.region_position.x, target_pos.y + (self->params.cursor->position.y - self->params.cursor->hotspot.y) * scale.y - self->capture_pos.y - self->params.region_position.y }; self->params.egl->glEnable(GL_SCISSOR_TEST); self->params.egl->glScissor(target_pos.x, target_pos.y, output_size.x, output_size.y); gsr_color_conversion_draw(color_conversion, self->params.cursor->texture_id, cursor_pos, (vec2i){self->params.cursor->size.x * scale.x, self->params.cursor->size.y * scale.y}, (vec2i){0, 0}, self->params.cursor->size, self->params.cursor->size, GSR_ROT_0, capture_metadata->flip, GSR_SOURCE_COLOR_RGB, false); self->params.egl->glDisable(GL_SCISSOR_TEST); } self->params.egl->glFlush(); self->params.egl->glFinish(); return 0; } static void gsr_capture_ximage_destroy(gsr_capture *cap) { gsr_capture_ximage *self = cap->priv; if(cap->priv) { gsr_capture_ximage_stop(self); free((void*)self->params.display_to_capture); self->params.display_to_capture = NULL; free(self); cap->priv = NULL; } free(cap); } gsr_capture* gsr_capture_ximage_create(const gsr_capture_ximage_params *params) { if(!params) { fprintf(stderr, "gsr error: gsr_capture_ximage_create params is NULL\n"); return NULL; } gsr_capture *cap = calloc(1, sizeof(gsr_capture)); if(!cap) return NULL; gsr_capture_ximage *cap_ximage = calloc(1, sizeof(gsr_capture_ximage)); if(!cap_ximage) { free(cap); return NULL; } const char *display_to_capture = strdup(params->display_to_capture); if(!display_to_capture) { free(cap); free(cap_ximage); return NULL; } cap_ximage->params = *params; cap_ximage->display = gsr_window_get_display(params->egl->window); cap_ximage->params.display_to_capture = display_to_capture; *cap = (gsr_capture) { .start = gsr_capture_ximage_start, .tick = NULL, .should_stop = NULL, .capture = gsr_capture_ximage_capture, .uses_external_image = NULL, .get_window_id = NULL, .destroy = gsr_capture_ximage_destroy, .priv = cap_ximage }; return cap; } fsdsfdsfdsfdsf-5.13.8/src/codec_query/000077500000000000000000000000001520215207700176765ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/src/codec_query/nvenc.c000066400000000000000000000241361520215207700211610ustar00rootroot00000000000000#include "../../include/codec_query/nvenc.h" #include "../../include/cuda.h" #include "../../external/nvEncodeAPI.h" #include #include #include #define NVENCAPI_MAJOR_VERSION_470 11 #define NVENCAPI_MINOR_VERSION_470 1 #define NVENCAPI_VERSION_470 (NVENCAPI_MAJOR_VERSION_470 | (NVENCAPI_MINOR_VERSION_470 << 24)) #define NVENCAPI_STRUCT_VERSION_CUSTOM(nvenc_api_version, struct_version) ((uint32_t)(nvenc_api_version) | ((struct_version)<<16) | (0x7 << 28)) static void* open_nvenc_library(void) { dlerror(); /* clear */ void *lib = dlopen("libnvidia-encode.so.1", RTLD_LAZY); if(!lib) { lib = dlopen("libnvidia-encode.so", RTLD_LAZY); if(!lib) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc failed: failed to load libnvidia-encode.so/libnvidia-encode.so.1, error: %s\n", dlerror()); return NULL; } } return lib; } static bool profile_is_h264(const GUID *profile_guid) { const GUID *h264_guids[] = { &NV_ENC_H264_PROFILE_BASELINE_GUID, &NV_ENC_H264_PROFILE_MAIN_GUID, &NV_ENC_H264_PROFILE_HIGH_GUID, &NV_ENC_H264_PROFILE_PROGRESSIVE_HIGH_GUID, &NV_ENC_H264_PROFILE_CONSTRAINED_HIGH_GUID }; for(int i = 0; i < 5; ++i) { if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0) return true; } return false; } static bool profile_is_hevc(const GUID *profile_guid) { const GUID *h264_guids[] = { &NV_ENC_HEVC_PROFILE_MAIN_GUID, }; for(int i = 0; i < 1; ++i) { if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0) return true; } return false; } static bool profile_is_hevc_10bit(const GUID *profile_guid) { const GUID *h264_guids[] = { &NV_ENC_HEVC_PROFILE_MAIN10_GUID, }; for(int i = 0; i < 1; ++i) { if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0) return true; } return false; } static bool profile_is_av1(const GUID *profile_guid) { const GUID *h264_guids[] = { &NV_ENC_AV1_PROFILE_MAIN_GUID, }; for(int i = 0; i < 1; ++i) { if(memcmp(profile_guid, h264_guids[i], sizeof(GUID)) == 0) return true; } return false; } /* Returns 0 on error */ static int nvenc_get_encoding_capability(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encode_guid, uint32_t nvenc_api_version, NV_ENC_CAPS cap) { NV_ENC_CAPS_PARAM param = { .version = NVENCAPI_STRUCT_VERSION_CUSTOM(nvenc_api_version, 1), .capsToQuery = cap }; int value = 0; if(function_list->nvEncGetEncodeCaps(nvenc_encoder, *encode_guid, ¶m, &value) != NV_ENC_SUCCESS) return 0; return value; } static vec2i encoder_get_max_resolution(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encode_guid, uint32_t nvenc_api_version) { return (vec2i){ .x = nvenc_get_encoding_capability(function_list, nvenc_encoder, encode_guid, nvenc_api_version, NV_ENC_CAPS_WIDTH_MAX), .y = nvenc_get_encoding_capability(function_list, nvenc_encoder, encode_guid, nvenc_api_version, NV_ENC_CAPS_HEIGHT_MAX), }; } static bool encoder_get_supported_profiles(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, const GUID *encoder_guid, gsr_supported_video_codecs *supported_video_codecs, uint32_t nvenc_api_version) { bool success = false; GUID *profile_guids = NULL; uint32_t profile_guid_count = 0; if(function_list->nvEncGetEncodeProfileGUIDCount(nvenc_encoder, *encoder_guid, &profile_guid_count) != NV_ENC_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeProfileGUIDCount failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder)); goto fail; } if(profile_guid_count == 0) goto fail; profile_guids = calloc(profile_guid_count, sizeof(GUID)); if(!profile_guids) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to allocate %d guids\n", (int)profile_guid_count); goto fail; } if(function_list->nvEncGetEncodeProfileGUIDs(nvenc_encoder, *encoder_guid, profile_guids, profile_guid_count, &profile_guid_count) != NV_ENC_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeProfileGUIDs failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder)); goto fail; } const vec2i max_resolution = encoder_get_max_resolution(function_list, nvenc_encoder, encoder_guid, nvenc_api_version); for(uint32_t i = 0; i < profile_guid_count; ++i) { if(profile_is_h264(&profile_guids[i])) { supported_video_codecs->h264 = (gsr_supported_video_codec){ true, false, max_resolution }; } else if(profile_is_hevc(&profile_guids[i])) { supported_video_codecs->hevc = (gsr_supported_video_codec){ true, false, max_resolution }; } else if(profile_is_hevc_10bit(&profile_guids[i])) { supported_video_codecs->hevc_hdr = (gsr_supported_video_codec){ true, false, max_resolution }; supported_video_codecs->hevc_10bit = (gsr_supported_video_codec){ true, false, max_resolution }; } else if(profile_is_av1(&profile_guids[i])) { supported_video_codecs->av1 = (gsr_supported_video_codec){ true, false, max_resolution }; supported_video_codecs->av1_hdr = (gsr_supported_video_codec){ true, false, max_resolution }; supported_video_codecs->av1_10bit = (gsr_supported_video_codec){ true, false, max_resolution }; } } success = true; fail: if(profile_guids) free(profile_guids); return success; } static bool get_supported_video_codecs(const NV_ENCODE_API_FUNCTION_LIST *function_list, void *nvenc_encoder, gsr_supported_video_codecs *supported_video_codecs, uint32_t nvenc_api_version) { bool success = false; GUID *encoder_guids = NULL; *supported_video_codecs = (gsr_supported_video_codecs){0}; uint32_t encode_guid_count = 0; if(function_list->nvEncGetEncodeGUIDCount(nvenc_encoder, &encode_guid_count) != NV_ENC_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeGUIDCount failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder)); goto fail; } if(encode_guid_count == 0) goto fail; encoder_guids = calloc(encode_guid_count, sizeof(GUID)); if(!encoder_guids) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to allocate %d guids\n", (int)encode_guid_count); goto fail; } if(function_list->nvEncGetEncodeGUIDs(nvenc_encoder, encoder_guids, encode_guid_count, &encode_guid_count) != NV_ENC_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncGetEncodeGUIDs failed, error: %s\n", function_list->nvEncGetLastErrorString(nvenc_encoder)); goto fail; } for(uint32_t i = 0; i < encode_guid_count; ++i) { encoder_get_supported_profiles(function_list, nvenc_encoder, &encoder_guids[i], supported_video_codecs, nvenc_api_version); } success = true; fail: if(encoder_guids) free(encoder_guids); return success; } bool gsr_get_supported_video_codecs_nvenc(gsr_supported_video_codecs *video_codecs, bool cleanup) { memset(video_codecs, 0, sizeof(*video_codecs)); bool success = false; void *nvenc_lib = NULL; void *nvenc_encoder = NULL; gsr_cuda cuda; memset(&cuda, 0, sizeof(cuda)); if(!gsr_cuda_load(&cuda)) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to load cuda\n"); goto done; } nvenc_lib = open_nvenc_library(); if(!nvenc_lib) goto done; typedef NVENCSTATUS NVENCAPI (*FUNC_NvEncodeAPICreateInstance)(NV_ENCODE_API_FUNCTION_LIST *functionList); FUNC_NvEncodeAPICreateInstance nvEncodeAPICreateInstance = (FUNC_NvEncodeAPICreateInstance)dlsym(nvenc_lib, "NvEncodeAPICreateInstance"); if(!nvEncodeAPICreateInstance) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: failed to find NvEncodeAPICreateInstance in libnvidia-encode.so\n"); goto done; } NV_ENCODE_API_FUNCTION_LIST function_list; memset(&function_list, 0, sizeof(function_list)); function_list.version = NVENCAPI_STRUCT_VERSION(2); if(nvEncodeAPICreateInstance(&function_list) != NV_ENC_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncodeAPICreateInstance failed\n"); goto done; } NV_ENC_OPEN_ENCODE_SESSION_EX_PARAMS params; memset(¶ms, 0, sizeof(params)); params.version = NVENCAPI_STRUCT_VERSION(1); params.deviceType = NV_ENC_DEVICE_TYPE_CUDA; params.device = cuda.cu_ctx; params.apiVersion = NVENCAPI_VERSION; if(function_list.nvEncOpenEncodeSessionEx(¶ms, &nvenc_encoder) != NV_ENC_SUCCESS) { // Old nvidia gpus dont support the new nvenc api (which is required for av1). // In such cases fallback to old api version if possible and try again. function_list.version = NVENCAPI_STRUCT_VERSION_CUSTOM(NVENCAPI_VERSION_470, 2); if(nvEncodeAPICreateInstance(&function_list) != NV_ENC_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncodeAPICreateInstance (retry) failed\n"); goto done; } params.version = NVENCAPI_STRUCT_VERSION_CUSTOM(NVENCAPI_VERSION_470, 1); params.apiVersion = NVENCAPI_VERSION_470; if(function_list.nvEncOpenEncodeSessionEx(¶ms, &nvenc_encoder) != NV_ENC_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_nvenc: nvEncOpenEncodeSessionEx (retry) failed\n"); goto done; } } success = get_supported_video_codecs(&function_list, nvenc_encoder, video_codecs, params.apiVersion); done: if(cleanup) { if(nvenc_encoder) function_list.nvEncDestroyEncoder(nvenc_encoder); if(nvenc_lib) dlclose(nvenc_lib); gsr_cuda_unload(&cuda); } return success; } fsdsfdsfdsfdsf-5.13.8/src/codec_query/vaapi.c000066400000000000000000000217261520215207700211520ustar00rootroot00000000000000#include "../../include/codec_query/vaapi.h" #include "../../include/utils.h" #include #include #include #include #include #include #include static bool profile_is_h264(VAProfile profile) { switch(profile) { case 5: // VAProfileH264Baseline case VAProfileH264Main: case VAProfileH264High: case VAProfileH264ConstrainedBaseline: return true; default: return false; } } static bool profile_is_hevc_8bit(VAProfile profile) { switch(profile) { case VAProfileHEVCMain: return true; default: return false; } } static bool profile_is_hevc_10bit(VAProfile profile) { switch(profile) { case VAProfileHEVCMain10: //case VAProfileHEVCMain12: //case VAProfileHEVCMain422_10: //case VAProfileHEVCMain422_12: //case VAProfileHEVCMain444: //case VAProfileHEVCMain444_10: //case VAProfileHEVCMain444_12: return true; default: return false; } } static bool profile_is_av1(VAProfile profile) { switch(profile) { case VAProfileAV1Profile0: case VAProfileAV1Profile1: return true; default: return false; } } static bool profile_is_vp8(VAProfile profile) { switch(profile) { case VAProfileVP8Version0_3: return true; default: return false; } } static bool profile_is_vp9(VAProfile profile) { switch(profile) { case VAProfileVP9Profile0: case VAProfileVP9Profile1: case VAProfileVP9Profile2: case VAProfileVP9Profile3: return true; default: return false; } } /* Returns 0, 0 on error */ static vec2i profile_entrypoint_get_max_resolution(VADisplay va_dpy, VAProfile profile, VAEntrypoint entrypoint) { VAConfigAttrib attribs[2] = { { .type = VAConfigAttribMaxPictureWidth, }, { .type = VAConfigAttribMaxPictureHeight, } }; if(vaGetConfigAttributes(va_dpy, profile, entrypoint, attribs, 2) != VA_STATUS_SUCCESS || (attribs[0].value & VA_ATTRIB_NOT_SUPPORTED) || (attribs[1].value & VA_ATTRIB_NOT_SUPPORTED)) return (vec2i){0, 0}; return (vec2i){ attribs[0].value, attribs[1].value }; } /* Returns 0 on error or if none is supported */ static VAEntrypoint profile_get_video_encoding_entrypoint(VADisplay va_dpy, VAProfile profile) { int num_entrypoints = vaMaxNumEntrypoints(va_dpy); if(num_entrypoints <= 0) return 0; VAEntrypoint *entrypoint_list = calloc(num_entrypoints, sizeof(VAEntrypoint)); if(!entrypoint_list) return 0; int encoding_entrypoint_index = -1; int lower_power_entrypoint_index = -1; if(vaQueryConfigEntrypoints(va_dpy, profile, entrypoint_list, &num_entrypoints) == VA_STATUS_SUCCESS) { for(int i = 0; i < num_entrypoints; ++i) { if(entrypoint_list[i] == VAEntrypointEncSlice) encoding_entrypoint_index = i; else if(entrypoint_list[i] == VAEntrypointEncSliceLP) lower_power_entrypoint_index = i; } } VAEntrypoint encoding_entrypoint = 0; if(encoding_entrypoint_index != -1) encoding_entrypoint = entrypoint_list[encoding_entrypoint_index]; else if(lower_power_entrypoint_index != -1) encoding_entrypoint = entrypoint_list[lower_power_entrypoint_index]; free(entrypoint_list); return encoding_entrypoint; } static bool get_supported_video_codecs(VADisplay va_dpy, gsr_supported_video_codecs *video_codecs, bool cleanup) { *video_codecs = (gsr_supported_video_codecs){0}; bool success = false; VAProfile *profile_list = NULL; vaSetInfoCallback(va_dpy, NULL, NULL); int va_major = 0; int va_minor = 0; if(vaInitialize(va_dpy, &va_major, &va_minor) != VA_STATUS_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: vaInitialize failed\n"); return false; } int num_profiles = vaMaxNumProfiles(va_dpy); if(num_profiles <= 0) goto fail; profile_list = calloc(num_profiles, sizeof(VAProfile)); if(!profile_list || vaQueryConfigProfiles(va_dpy, profile_list, &num_profiles) != VA_STATUS_SUCCESS) goto fail; for(int i = 0; i < num_profiles; ++i) { if(profile_is_h264(profile_list[i])) { const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]); if(encoding_entrypoint != 0) { const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint); video_codecs->h264 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; } } else if(profile_is_hevc_8bit(profile_list[i])) { const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]); if(encoding_entrypoint != 0) { const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint); video_codecs->hevc = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; } } else if(profile_is_hevc_10bit(profile_list[i])) { const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]); if(encoding_entrypoint != 0) { const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint); video_codecs->hevc_hdr = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; video_codecs->hevc_10bit = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; } } else if(profile_is_av1(profile_list[i])) { const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]); if(encoding_entrypoint != 0) { const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint); video_codecs->av1 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; video_codecs->av1_hdr = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; video_codecs->av1_10bit = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; } } else if(profile_is_vp8(profile_list[i])) { const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]); if(encoding_entrypoint != 0) { const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint); video_codecs->vp8 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; } } else if(profile_is_vp9(profile_list[i])) { const VAEntrypoint encoding_entrypoint = profile_get_video_encoding_entrypoint(va_dpy, profile_list[i]); if(encoding_entrypoint != 0) { const vec2i max_resolution = profile_entrypoint_get_max_resolution(va_dpy, profile_list[i], encoding_entrypoint); video_codecs->vp9 = (gsr_supported_video_codec){ true, encoding_entrypoint == VAEntrypointEncSliceLP, max_resolution }; } } } success = true; fail: if(profile_list) free(profile_list); if(cleanup) vaTerminate(va_dpy); return success; } bool gsr_get_supported_video_codecs_vaapi(gsr_supported_video_codecs *video_codecs, const char *card_path, bool cleanup) { memset(video_codecs, 0, sizeof(*video_codecs)); bool success = false; int drm_fd = -1; char render_path[128]; if(!gsr_card_path_get_render_path(card_path, render_path)) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: failed to get /dev/dri/renderDXXX file from %s\n", card_path); goto done; } drm_fd = open(render_path, O_RDWR); if(drm_fd == -1) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: failed to open device %s\n", render_path); goto done; } VADisplay va_dpy = vaGetDisplayDRM(drm_fd); if(va_dpy) { if(!get_supported_video_codecs(va_dpy, video_codecs, cleanup)) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vaapi: failed to query supported video codecs for device %s\n", render_path); goto done; } success = true; } done: if(cleanup) { if(drm_fd > 0) close(drm_fd); } return success; } fsdsfdsfdsfdsf-5.13.8/src/codec_query/vulkan.c000066400000000000000000000336301520215207700213470ustar00rootroot00000000000000#include "../../include/codec_query/vulkan.h" #include "../../include/utils.h" #include #include #include #include #include #define VK_NO_PROTOTYPES #include #define MAX_PHYSICAL_DEVICES 32 static const char *required_device_extensions[] = { "VK_KHR_external_memory_fd", "VK_KHR_external_semaphore_fd", "VK_KHR_video_encode_queue", "VK_KHR_video_queue", "VK_KHR_video_maintenance1", "VK_EXT_external_memory_dma_buf", "VK_EXT_external_memory_host", "VK_EXT_image_drm_format_modifier" }; static int num_required_device_extensions = 8; static void set_h264_max_resolution(PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR, VkPhysicalDevice physical_device, gsr_supported_video_codecs *video_codecs) { #ifdef VK_KHR_video_encode_h264 const VkVideoEncodeH264ProfileInfoKHR h264_profile = { .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR, .pNext = NULL, .stdProfileIdc = STD_VIDEO_H264_PROFILE_IDC_HIGH }; const VkVideoProfileInfoKHR video_profile = { .sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, .pNext = &h264_profile, // Chain the codec-specific profile .videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR, .chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, .lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, .chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR }; VkVideoEncodeH264CapabilitiesKHR encode_caps = { .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR, .pNext = NULL }; VkVideoCapabilitiesKHR video_caps = { .sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, .pNext = &encode_caps }; if (vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile, &video_caps) == VK_SUCCESS) { video_codecs->h264.max_resolution.x = video_caps.maxCodedExtent.width; video_codecs->h264.max_resolution.y = video_caps.maxCodedExtent.height; } #else (void)vkGetPhysicalDeviceVideoCapabilitiesKHR; (void)physical_device; (void)video_codecs; #endif } static void set_hevc_max_resolution(PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR, VkPhysicalDevice physical_device, gsr_supported_video_codecs *video_codecs) { #ifdef VK_KHR_video_encode_h265 const VkVideoEncodeH265ProfileInfoKHR hevc_profile = { .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR, .pNext = NULL, .stdProfileIdc = STD_VIDEO_H265_PROFILE_IDC_MAIN }; const VkVideoProfileInfoKHR video_profile = { .sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, .pNext = &hevc_profile, // Chain the codec-specific profile .videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR, .chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, .lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, .chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR }; VkVideoEncodeH265CapabilitiesKHR encode_caps = { .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR, .pNext = NULL }; VkVideoCapabilitiesKHR video_caps = { .sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, .pNext = &encode_caps }; if (vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile, &video_caps) == VK_SUCCESS) { video_codecs->hevc.max_resolution.x = video_caps.maxCodedExtent.width; video_codecs->hevc.max_resolution.y = video_caps.maxCodedExtent.height; video_codecs->hevc_hdr.max_resolution.x = video_caps.maxCodedExtent.width; video_codecs->hevc_hdr.max_resolution.y = video_caps.maxCodedExtent.height; video_codecs->hevc_10bit.max_resolution.x = video_caps.maxCodedExtent.width; video_codecs->hevc_10bit.max_resolution.y = video_caps.maxCodedExtent.height; } #else (void)vkGetPhysicalDeviceVideoCapabilitiesKHR; (void)physical_device; (void)video_codecs; #endif } static void set_av1_max_resolution(PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR, VkPhysicalDevice physical_device, gsr_supported_video_codecs *video_codecs) { #ifdef VK_KHR_video_encode_av1 const VkVideoEncodeAV1ProfileInfoKHR av1_profile = { .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR, .pNext = NULL, .stdProfile = STD_VIDEO_AV1_PROFILE_MAIN }; const VkVideoProfileInfoKHR video_profile = { .sType = VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR, .pNext = &av1_profile, // Chain the codec-specific profile .videoCodecOperation = VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR, .chromaSubsampling = VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR, .lumaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR, .chromaBitDepth = VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR }; VkVideoEncodeAV1CapabilitiesKHR encode_caps = { .sType = VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR, .pNext = NULL }; VkVideoCapabilitiesKHR video_caps = { .sType = VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR, .pNext = &encode_caps }; if (vkGetPhysicalDeviceVideoCapabilitiesKHR(physical_device, &video_profile, &video_caps) == VK_SUCCESS) { video_codecs->av1.max_resolution.x = video_caps.maxCodedExtent.width; video_codecs->av1.max_resolution.y = video_caps.maxCodedExtent.height; video_codecs->av1_hdr.max_resolution.x = video_caps.maxCodedExtent.width; video_codecs->av1_hdr.max_resolution.y = video_caps.maxCodedExtent.height; video_codecs->av1_10bit.max_resolution.x = video_caps.maxCodedExtent.width; video_codecs->av1_10bit.max_resolution.y = video_caps.maxCodedExtent.height; } #else (void)vkGetPhysicalDeviceVideoCapabilitiesKHR; (void)physical_device; (void)video_codecs; #endif } bool gsr_get_supported_video_codecs_vulkan(gsr_supported_video_codecs *video_codecs, const char *card_path, int *device_index_ret, bool cleanup) { memset(video_codecs, 0, sizeof(*video_codecs)); *device_index_ret = 0; bool success = false; void* libvulkan = NULL; VkInstance instance = NULL; VkPhysicalDevice physical_devices[MAX_PHYSICAL_DEVICES]; VkDevice device = NULL; VkExtensionProperties *device_extensions = NULL; char render_path[128]; if(!gsr_card_path_get_render_path(card_path, render_path)) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: failed to get /dev/dri/renderDXXX file from %s\n", card_path); return false; } libvulkan = dlopen("libvulkan.so.1", RTLD_NOW); if (!libvulkan) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: failed to load libvulkan.so.1, error: %s\n", dlerror()); return false; } PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)dlsym(libvulkan, "vkGetInstanceProcAddr"); if (!vkGetInstanceProcAddr) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: could not find vkGetInstanceProcAddr in libvulkan.so.1\n"); goto done; } PFN_vkCreateInstance vkCreateInstance = (PFN_vkCreateInstance)vkGetInstanceProcAddr(NULL, "vkCreateInstance"); if(!vkCreateInstance) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: could not find vkCreateInstance in libvulkan.so.1\n"); goto done; } const VkApplicationInfo app_info = { .sType = VK_STRUCTURE_TYPE_APPLICATION_INFO, .pApplicationName = "GPU Screen Recorder", .applicationVersion = VK_MAKE_VERSION(1, 0, 0), .pEngineName = "GPU Screen Recorder", .engineVersion = VK_MAKE_VERSION(1, 0, 0), .apiVersion = VK_API_VERSION_1_3, }; const VkInstanceCreateInfo instance_create_info = { .sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, .pApplicationInfo = &app_info }; if(vkCreateInstance(&instance_create_info, NULL, &instance) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: vkCreateInstance failed\n"); goto done; } PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices = NULL; PFN_vkDestroyInstance vkDestroyInstance = NULL; PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2 = NULL; PFN_vkCreateDevice vkCreateDevice = NULL; PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties = NULL; PFN_vkDestroyDevice vkDestroyDevice = NULL; PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR = NULL; #define LOAD_INST(name) name = (PFN_##name)vkGetInstanceProcAddr(instance, #name); if(!name) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: could not find " #name " in libvulkan.so.1\n"); goto done; } LOAD_INST(vkEnumeratePhysicalDevices) LOAD_INST(vkDestroyInstance) LOAD_INST(vkGetPhysicalDeviceProperties2) LOAD_INST(vkCreateDevice) LOAD_INST(vkEnumerateDeviceExtensionProperties) LOAD_INST(vkDestroyDevice) LOAD_INST(vkGetPhysicalDeviceVideoCapabilitiesKHR) #undef LOAD_INST uint32_t num_devices = 0; if(vkEnumeratePhysicalDevices(instance, &num_devices, NULL) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: vkEnumeratePhysicalDevices (query num devices) failed\n"); goto done; } if(num_devices == 0) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: no vulkan capable device found\n"); goto done; } if(num_devices > MAX_PHYSICAL_DEVICES) num_devices = MAX_PHYSICAL_DEVICES; if(vkEnumeratePhysicalDevices(instance, &num_devices, physical_devices) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: vkEnumeratePhysicalDevices (get data) failed\n"); goto done; } VkPhysicalDevice physical_device = NULL; char device_card_path[128]; for(uint32_t i = 0; i < num_devices; ++i) { VkPhysicalDeviceDrmPropertiesEXT device_drm_properties = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT }; VkPhysicalDeviceProperties2 device_properties = { .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, .pNext = &device_drm_properties }; vkGetPhysicalDeviceProperties2(physical_devices[i], &device_properties); if(!device_drm_properties.hasRender) continue; snprintf(device_card_path, sizeof(device_card_path), DRM_RENDER_DEV_NAME, DRM_DIR_NAME, (int)device_drm_properties.renderMinor); if(strcmp(device_card_path, render_path) == 0) { physical_device = physical_devices[i]; *device_index_ret = i; break; } } if(!physical_device) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: failed to find a vulkan device that matches opengl device %s\n", card_path); goto done; } const VkDeviceCreateInfo device_create_info = { .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, .enabledExtensionCount = num_required_device_extensions, .ppEnabledExtensionNames = required_device_extensions }; if(vkCreateDevice(physical_device, &device_create_info, NULL, &device) != VK_SUCCESS) { //fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: vkCreateDevice failed. Device %s likely doesn't support vulkan video encoding\n", card_path); goto done; } uint32_t num_device_extensions = 0; if(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &num_device_extensions, NULL) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: vkEnumerateDeviceExtensionProperties (query num device extensions) failed\n"); goto done; } device_extensions = calloc(num_device_extensions, sizeof(VkExtensionProperties)); if(!device_extensions) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: failed to allocate %d device extensions\n", num_device_extensions); goto done; } if(vkEnumerateDeviceExtensionProperties(physical_device, NULL, &num_device_extensions, device_extensions) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_get_supported_video_codecs_vulkan: vkEnumerateDeviceExtensionProperties (get data) failed\n"); goto done; } for(uint32_t i = 0; i < num_device_extensions; ++i) { if(strcmp(device_extensions[i].extensionName, "VK_KHR_video_encode_h264") == 0) { video_codecs->h264.supported = true; } else if(strcmp(device_extensions[i].extensionName, "VK_KHR_video_encode_h265") == 0) { // TODO: Verify if 10bit and hdr are actually supported video_codecs->hevc.supported = true; video_codecs->hevc_10bit.supported = true; video_codecs->hevc_hdr.supported = true; } else if(strcmp(device_extensions[i].extensionName, "VK_KHR_video_encode_av1") == 0) { // TODO: Verify if 10bit and hdr are actually supported video_codecs->av1.supported = true; video_codecs->av1_10bit.supported = true; video_codecs->av1_hdr.supported = true; } } set_h264_max_resolution(vkGetPhysicalDeviceVideoCapabilitiesKHR, physical_device, video_codecs); set_hevc_max_resolution(vkGetPhysicalDeviceVideoCapabilitiesKHR, physical_device, video_codecs); set_av1_max_resolution(vkGetPhysicalDeviceVideoCapabilitiesKHR, physical_device, video_codecs); success = true; done: if(device_extensions) free(device_extensions); if(cleanup) { if(device) vkDestroyDevice(device, NULL); if(instance) vkDestroyInstance(instance, NULL); } if(libvulkan) dlclose(libvulkan); return success; } fsdsfdsfdsfdsf-5.13.8/src/color_conversion.c000066400000000000000000001520601520215207700211270ustar00rootroot00000000000000#include "../include/color_conversion.h" #include "../include/egl.h" #include #include #include #define GRAPHICS_SHADER_INDEX_Y 0 #define GRAPHICS_SHADER_INDEX_UV 1 #define GRAPHICS_SHADER_INDEX_Y_EXTERNAL 2 #define GRAPHICS_SHADER_INDEX_UV_EXTERNAL 3 #define GRAPHICS_SHADER_INDEX_RGB 4 #define GRAPHICS_SHADER_INDEX_RGB_EXTERNAL 5 #define GRAPHICS_SHADER_INDEX_YUYV_TO_Y 6 #define GRAPHICS_SHADER_INDEX_YUYV_TO_UV 7 #define GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL 8 #define GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL 9 #define GRAPHICS_SHADER_INDEX_YUYV_TO_RGB 10 #define GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL 11 /* https://en.wikipedia.org/wiki/YCbCr, see study/color_space_transform_matrix.png */ /* ITU-R BT2020, full */ /* https://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.2020-2-201510-I!!PDF-E.pdf */ #define RGB_TO_P010_FULL "const mat4 RGBtoYUV = mat4(0.262700, -0.139630, 0.500000, 0.000000,\n" \ " 0.678000, -0.360370, -0.459786, 0.000000,\n" \ " 0.059300, 0.500000, -0.040214, 0.000000,\n" \ " 0.000000, 0.500000, 0.500000, 1.000000);\n" /* ITU-R BT2020, limited (full multiplied by (235-16)/255, adding 16/255 to luma) */ #define RGB_TO_P010_LIMITED "const mat4 RGBtoYUV = mat4(0.225613, -0.119918, 0.429412, 0.000000,\n" \ " 0.582282, -0.309494, -0.394875, 0.000000,\n" \ " 0.050928, 0.429412, -0.034537, 0.000000,\n" \ " 0.062745, 0.500000, 0.500000, 1.000000);\n" /* ITU-R BT709, full, custom values: 0.2110 0.7110 0.0710 */ /* https://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.709-6-201506-I!!PDF-E.pdf */ #define RGB_TO_NV12_FULL "const mat4 RGBtoYUV = mat4(0.211000, -0.113563, 0.500000, 0.000000,\n" \ " 0.711000, -0.382670, -0.450570, 0.000000,\n" \ " 0.071000, 0.500000, -0.044994, 0.000000,\n" \ " 0.000000, 0.500000, 0.500000, 1.000000);\n" /* ITU-R BT709, limited, custom values: 0.2100 0.7100 0.0700 (full multiplied by (235-16)/255, adding 16/255 to luma) */ #define RGB_TO_NV12_LIMITED "const mat4 RGBtoYUV = mat4(0.180353, -0.096964, 0.429412, 0.000000,\n" \ " 0.609765, -0.327830, -0.385927, 0.000000,\n" \ " 0.060118, 0.429412, -0.038049, 0.000000,\n" \ " 0.062745, 0.500000, 0.500000, 1.000000);\n" static const char* color_format_range_get_transform_matrix(gsr_destination_color color_format, gsr_color_range color_range) { switch(color_format) { case GSR_DESTINATION_COLOR_NV12: { switch(color_range) { case GSR_COLOR_RANGE_LIMITED: return RGB_TO_NV12_LIMITED; case GSR_COLOR_RANGE_FULL: return RGB_TO_NV12_FULL; } break; } case GSR_DESTINATION_COLOR_P010: { switch(color_range) { case GSR_COLOR_RANGE_LIMITED: return RGB_TO_P010_LIMITED; case GSR_COLOR_RANGE_FULL: return RGB_TO_P010_FULL; } break; } case GSR_DESTINATION_COLOR_RGB: return ""; default: return NULL; } return NULL; } static int load_graphics_shader_y(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture) { const char *color_transform_matrix = color_format_range_get_transform_matrix(color_format, color_range); char vertex_shader[2048]; snprintf(vertex_shader, sizeof(vertex_shader), "#version 300 es \n" "in vec2 pos; \n" "in vec2 texcoords; \n" "out vec2 texcoords_out; \n" "uniform vec2 offset; \n" "uniform float rotation; \n" "uniform mat2 rotation_matrix; \n" "void main() \n" "{ \n" " texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5); \n" " gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0); \n" "} \n"); const char *brightness = color_format == GSR_DESTINATION_COLOR_NV12 ? "1.007049345" : "1.0"; char main_code[512]; snprintf(main_code, sizeof(main_code), " vec4 pixel = texture(tex1, texcoords_out); \n" " FragColor.x = (RGBtoYUV * vec4(pixel.rgb, 1.0)).x*%s; \n" " FragColor.w = pixel.a; \n", brightness); char fragment_shader[2048]; if(external_texture) { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "#extension GL_OES_EGL_image_external : enable \n" "#extension GL_OES_EGL_image_external_essl3 : require \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform samplerExternalOES tex1; \n" "out vec4 FragColor; \n" "%s" "void main() \n" "{ \n" "%s" "} \n", color_transform_matrix, main_code); } else { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform sampler2D tex1; \n" "out vec4 FragColor; \n" "%s" "void main() \n" "{ \n" "%s" "} \n", color_transform_matrix, main_code); } if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0) return -1; gsr_shader_bind_attribute_location(shader, "pos", 0); gsr_shader_bind_attribute_location(shader, "texcoords", 1); uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset"); uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix"); return 0; } static unsigned int load_graphics_shader_uv(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, gsr_destination_color color_format, gsr_color_range color_range, bool external_texture) { const char *color_transform_matrix = color_format_range_get_transform_matrix(color_format, color_range); char vertex_shader[2048]; snprintf(vertex_shader, sizeof(vertex_shader), "#version 300 es \n" "in vec2 pos; \n" "in vec2 texcoords; \n" "out vec2 texcoords_out; \n" "uniform vec2 offset; \n" "uniform float rotation; \n" "uniform mat2 rotation_matrix; \n" "void main() \n" "{ \n" " texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5); \n" " gl_Position = (vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0)) * vec4(0.5, 0.5, 1.0, 1.0) - vec4(0.5, 0.5, 0.0, 0.0); \n" "} \n"); const char *main_code = " vec4 pixel = texture(tex1, texcoords_out); \n" " FragColor.xy = (RGBtoYUV * vec4(pixel.rgb, 1.0)).yz; \n" " FragColor.w = pixel.a; \n"; char fragment_shader[2048]; if(external_texture) { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "#extension GL_OES_EGL_image_external : enable \n" "#extension GL_OES_EGL_image_external_essl3 : require \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform samplerExternalOES tex1; \n" "out vec4 FragColor; \n" "%s" "void main() \n" "{ \n" "%s" "} \n", color_transform_matrix, main_code); } else { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform sampler2D tex1; \n" "out vec4 FragColor; \n" "%s" "void main() \n" "{ \n" "%s" "} \n", color_transform_matrix, main_code); } if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0) return -1; gsr_shader_bind_attribute_location(shader, "pos", 0); gsr_shader_bind_attribute_location(shader, "texcoords", 1); uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset"); uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix"); return 0; } static unsigned int load_graphics_shader_rgb(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, bool external_texture) { char vertex_shader[2048]; snprintf(vertex_shader, sizeof(vertex_shader), "#version 300 es \n" "in vec2 pos; \n" "in vec2 texcoords; \n" "out vec2 texcoords_out; \n" "uniform vec2 offset; \n" "uniform float rotation; \n" "uniform mat2 rotation_matrix; \n" "void main() \n" "{ \n" " texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5); \n" " gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0); \n" "} \n"); const char *main_code = " vec4 pixel = texture(tex1, texcoords_out); \n" " FragColor = pixel; \n"; char fragment_shader[2048]; if(external_texture) { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "#extension GL_OES_EGL_image_external : enable \n" "#extension GL_OES_EGL_image_external_essl3 : require \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform samplerExternalOES tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } else { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform sampler2D tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0) return -1; gsr_shader_bind_attribute_location(shader, "pos", 0); gsr_shader_bind_attribute_location(shader, "texcoords", 1); uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset"); uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix"); return 0; } static int load_graphics_shader_yuyv_to_y(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, bool external_texture) { char vertex_shader[2048]; snprintf(vertex_shader, sizeof(vertex_shader), "#version 300 es \n" "in vec2 pos; \n" "in vec2 texcoords; \n" "out vec2 texcoords_out; \n" "uniform vec2 offset; \n" "uniform float rotation; \n" "uniform mat2 rotation_matrix; \n" "void main() \n" "{ \n" " texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5); \n" " gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0); \n" "} \n"); const char *main_code = " vec4 pixel = texture(tex1, texcoords_out); \n" " FragColor.x = pixel.r; \n" " FragColor.w = 1.0; \n"; char fragment_shader[2048]; if(external_texture) { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "#extension GL_OES_EGL_image_external : enable \n" "#extension GL_OES_EGL_image_external_essl3 : require \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform samplerExternalOES tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } else { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform sampler2D tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0) return -1; gsr_shader_bind_attribute_location(shader, "pos", 0); gsr_shader_bind_attribute_location(shader, "texcoords", 1); uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset"); uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix"); return 0; } static unsigned int load_graphics_shader_yuyv_to_uv(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, bool external_texture) { char vertex_shader[2048]; snprintf(vertex_shader, sizeof(vertex_shader), "#version 300 es \n" "in vec2 pos; \n" "in vec2 texcoords; \n" "out vec2 texcoords_out; \n" "uniform vec2 offset; \n" "uniform float rotation; \n" "uniform mat2 rotation_matrix; \n" "void main() \n" "{ \n" " texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5); \n" " gl_Position = (vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0)) * vec4(0.5, 0.5, 1.0, 1.0) - vec4(0.5, 0.5, 0.0, 0.0); \n" "} \n"); const char *main_code = " vec2 resolution = vec2(textureSize(tex1, 0));\n" " ivec2 uv = ivec2(texcoords_out * resolution);\n" " float u = 0.0;\n" " float v = 0.0;\n" " vec4 this_color = texelFetch(tex1, uv, 0);\n" " if((uv.x & 1) == 0) {\n" " vec2 next_color = texelFetch(tex1, uv + ivec2(1, 0), 0).rg;\n" " u = this_color.g;\n" " v = next_color.g;\n" " } else {\n" " vec2 prev_color = texelFetch(tex1, uv - ivec2(1, 0), 0).rg;\n" " u = prev_color.g;\n" " v = this_color.g;\n" " }\n" " FragColor.rg = vec2(u, v);\n" " FragColor.w = 1.0;\n"; char fragment_shader[2048]; if(external_texture) { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "#extension GL_OES_EGL_image_external : enable \n" "#extension GL_OES_EGL_image_external_essl3 : require \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform samplerExternalOES tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } else { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform sampler2D tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0) return -1; gsr_shader_bind_attribute_location(shader, "pos", 0); gsr_shader_bind_attribute_location(shader, "texcoords", 1); uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset"); uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix"); return 0; } static unsigned int load_graphics_shader_yuyv_to_rgb(gsr_shader *shader, gsr_egl *egl, gsr_color_graphics_uniforms *uniforms, bool external_texture) { char vertex_shader[2048]; snprintf(vertex_shader, sizeof(vertex_shader), "#version 300 es \n" "in vec2 pos; \n" "in vec2 texcoords; \n" "out vec2 texcoords_out; \n" "uniform vec2 offset; \n" "uniform float rotation; \n" "uniform mat2 rotation_matrix; \n" "void main() \n" "{ \n" " texcoords_out = vec2(texcoords.x - 0.5, texcoords.y - 0.5) * rotation_matrix + vec2(0.5, 0.5); \n" " gl_Position = vec4(offset.x, offset.y, 0.0, 0.0) + vec4(pos.x, pos.y, 0.0, 1.0); \n" "} \n"); const char *main_code = " vec2 resolution = vec2(textureSize(tex1, 0));\n" " ivec2 uv = ivec2(texcoords_out * resolution);\n" " float y = 0.0;\n" " float u = 0.0;\n" " float v = 0.0;\n" " vec4 this_color = texelFetch(tex1, uv, 0);\n" " if((uv.x & 1) == 0) {\n" " vec2 next_color = texelFetch(tex1, uv + ivec2(1, 0), 0).rg;\n" " y = this_color.r;\n" " u = this_color.g;\n" " v = next_color.g;\n" " } else {\n" " vec2 prev_color = texelFetch(tex1, uv - ivec2(1, 0), 0).rg;\n" " y = this_color.r;\n" " u = prev_color.g;\n" " v = this_color.g;\n" " }\n" " FragColor = vec4(\n" " y + 1.4065 * (v - 0.5),\n" " y - 0.3455 * (u - 0.5) - 0.7169 * (v - 0.5),\n" " y + 1.1790 * (u - 0.5),\n" " 1.0);\n"; char fragment_shader[4096]; if(external_texture) { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "#extension GL_OES_EGL_image_external : enable \n" "#extension GL_OES_EGL_image_external_essl3 : require \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform samplerExternalOES tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } else { snprintf(fragment_shader, sizeof(fragment_shader), "#version 300 es \n" "precision highp float; \n" "in vec2 texcoords_out; \n" "uniform sampler2D tex1; \n" "out vec4 FragColor; \n" "void main() \n" "{ \n" "%s" "} \n", main_code); } if(gsr_shader_init(shader, egl, vertex_shader, fragment_shader) != 0) return -1; gsr_shader_bind_attribute_location(shader, "pos", 0); gsr_shader_bind_attribute_location(shader, "texcoords", 1); uniforms->offset = egl->glGetUniformLocation(shader->program_id, "offset"); uniforms->rotation_matrix = egl->glGetUniformLocation(shader->program_id, "rotation_matrix"); return 0; } static int load_framebuffers(gsr_color_conversion *self) { /* TODO: Only generate the necessary amount of framebuffers (self->params.num_destination_textures) */ const unsigned int draw_buffer = GL_COLOR_ATTACHMENT0; self->params.egl->glGenFramebuffers(GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS, self->framebuffers); self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]); self->params.egl->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->params.destination_textures[0], 0); self->params.egl->glDrawBuffers(1, &draw_buffer); if(self->params.egl->glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to create framebuffer for Y\n"); goto err; } if(self->params.num_destination_textures > 1) { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]); self->params.egl->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->params.destination_textures[1], 0); self->params.egl->glDrawBuffers(1, &draw_buffer); if(self->params.egl->glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to create framebuffer for UV\n"); goto err; } } self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0); return 0; err: self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0); return -1; } static int create_vertices(gsr_color_conversion *self) { self->params.egl->glGenVertexArrays(1, &self->vertex_array_object_id); self->params.egl->glBindVertexArray(self->vertex_array_object_id); self->params.egl->glGenBuffers(1, &self->vertex_buffer_object_id); self->params.egl->glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer_object_id); self->params.egl->glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(float), NULL, GL_DYNAMIC_DRAW); self->params.egl->glEnableVertexAttribArray(0); self->params.egl->glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)0); self->params.egl->glEnableVertexAttribArray(1); self->params.egl->glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 4 * sizeof(float), (void*)(2 * sizeof(float))); self->params.egl->glBindVertexArray(0); return 0; } static bool gsr_color_conversion_load_graphics_shaders(gsr_color_conversion *self) { switch(self->params.destination_color) { case GSR_DESTINATION_COLOR_NV12: case GSR_DESTINATION_COLOR_P010: { if(load_graphics_shader_y(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_Y], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_Y], self->params.destination_color, self->params.color_range, false) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y graphics shader\n"); return false; } if(load_graphics_shader_uv(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_UV], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_UV], self->params.destination_color, self->params.color_range, false) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV graphics shader\n"); return false; } if(load_graphics_shader_yuyv_to_y(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_Y], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_Y], false) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to Y graphics shader\n"); return false; } if(load_graphics_shader_yuyv_to_uv(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_UV], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_UV], false) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to UV graphics shader\n"); return false; } break; } case GSR_DESTINATION_COLOR_RGB: { if(load_graphics_shader_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_RGB], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_RGB], false) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load RGB graphics shader\n"); return false; } if(load_graphics_shader_yuyv_to_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB], false) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to RGB graphics shader\n"); return false; } break; } } return true; } static bool gsr_color_conversion_load_external_graphics_shaders(gsr_color_conversion *self) { switch(self->params.destination_color) { case GSR_DESTINATION_COLOR_NV12: case GSR_DESTINATION_COLOR_P010: { if(load_graphics_shader_y(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_Y_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_Y_EXTERNAL], self->params.destination_color, self->params.color_range, true) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load Y graphics shader (external)\n"); return false; } if(load_graphics_shader_uv(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_UV_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_UV_EXTERNAL], self->params.destination_color, self->params.color_range, true) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load UV graphics shader (external)\n"); return false; } if(load_graphics_shader_yuyv_to_y(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL], true) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to Y graphics shader (external)\n"); return false; } if(load_graphics_shader_yuyv_to_uv(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL], true) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to UV graphics shader (external)\n"); return false; } break; } case GSR_DESTINATION_COLOR_RGB: { if(load_graphics_shader_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_RGB_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_RGB_EXTERNAL], true) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load RGB graphics shader (external)\n"); return false; } if(load_graphics_shader_yuyv_to_rgb(&self->graphics_shaders[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL], self->params.egl, &self->graphics_uniforms[GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL], true) != 0) { fprintf(stderr, "gsr error: gsr_color_conversion_init: failed to load YUYV to RGB graphics shader (external)\n"); return false; } break; } } return true; } int gsr_color_conversion_init(gsr_color_conversion *self, const gsr_color_conversion_params *params) { assert(params); assert(params->egl); memset(self, 0, sizeof(*self)); self->params.egl = params->egl; self->params = *params; switch(self->params.destination_color) { case GSR_DESTINATION_COLOR_NV12: case GSR_DESTINATION_COLOR_P010: { if(self->params.num_destination_textures != 2) { fprintf(stderr, "gsr error: gsr_color_conversion_init: expected 2 destination textures for destination color NV12/P010, got %d destination texture(s)\n", self->params.num_destination_textures); goto err; } break; } case GSR_DESTINATION_COLOR_RGB: { if(self->params.num_destination_textures != 1) { fprintf(stderr, "gsr error: gsr_color_conversion_init: expected 1 destination textures for destination color RGB8, got %d destination texture(s)\n", self->params.num_destination_textures); goto err; } break; } } if(!gsr_color_conversion_load_graphics_shaders(self)) goto err; if(self->params.load_external_image_shader) { if(!gsr_color_conversion_load_external_graphics_shaders(self)) goto err; } if(load_framebuffers(self) != 0) goto err; if(create_vertices(self) != 0) goto err; return 0; err: gsr_color_conversion_deinit(self); return -1; } void gsr_color_conversion_deinit(gsr_color_conversion *self) { if(!self->params.egl) return; if(self->vertex_buffer_object_id) { self->params.egl->glDeleteBuffers(1, &self->vertex_buffer_object_id); self->vertex_buffer_object_id = 0; } if(self->vertex_array_object_id) { self->params.egl->glDeleteVertexArrays(1, &self->vertex_array_object_id); self->vertex_array_object_id = 0; } self->params.egl->glDeleteFramebuffers(GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS, self->framebuffers); for(int i = 0; i < GSR_COLOR_CONVERSION_MAX_FRAMEBUFFERS; ++i) { self->framebuffers[i] = 0; } for(int i = 0; i < GSR_COLOR_CONVERSION_MAX_GRAPHICS_SHADERS; ++i) { gsr_shader_deinit(&self->graphics_shaders[i]); } self->params.egl = NULL; } static void gsr_color_conversion_apply_rotation(gsr_rotation rotation, float rotation_matrix[2][2]) { /* rotation_matrix[0][0] = cos(angle); rotation_matrix[0][1] = -sin(angle); rotation_matrix[1][0] = sin(angle); rotation_matrix[1][1] = cos(angle); The manual matrix code below is the same as this code above, but without floating-point errors. This is done to remove any blurring caused by these floating-point errors. */ switch(rotation) { case GSR_ROT_0: rotation_matrix[0][0] = 1.0f; rotation_matrix[0][1] = 0.0f; rotation_matrix[1][0] = 0.0f; rotation_matrix[1][1] = 1.0f; break; case GSR_ROT_90: rotation_matrix[0][0] = 0.0f; rotation_matrix[0][1] = -1.0f; rotation_matrix[1][0] = 1.0f; rotation_matrix[1][1] = 0.0f; break; case GSR_ROT_180: rotation_matrix[0][0] = -1.0f; rotation_matrix[0][1] = 0.0f; rotation_matrix[1][0] = 0.0f; rotation_matrix[1][1] = -1.0f; break; case GSR_ROT_270: rotation_matrix[0][0] = 0.0f; rotation_matrix[0][1] = 1.0f; rotation_matrix[1][0] = -1.0f; rotation_matrix[1][1] = 0.0f; break; } } static void gsr_color_conversion_swizzle_texture_source(gsr_color_conversion *self, unsigned int texture_target, gsr_source_color source_color) { if(source_color == GSR_SOURCE_COLOR_BGR) { const int swizzle_mask[] = { GL_BLUE, GL_GREEN, GL_RED, 1 }; self->params.egl->glTexParameteriv(texture_target, GL_TEXTURE_SWIZZLE_RGBA, swizzle_mask); } } static void gsr_color_conversion_swizzle_reset(gsr_color_conversion *self, unsigned int texture_target, gsr_source_color source_color) { if(source_color == GSR_SOURCE_COLOR_BGR) { const int swizzle_mask[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA }; self->params.egl->glTexParameteriv(texture_target, GL_TEXTURE_SWIZZLE_RGBA, swizzle_mask); } } static void gsr_color_conversion_draw_graphics(gsr_color_conversion *self, unsigned int texture_id, bool external_texture, gsr_rotation rotation, gsr_flip flip, float rotation_matrix[2][2], vec2i source_position, vec2i source_size, vec2i destination_pos, vec2i texture_size, vec2f scale, gsr_source_color source_color) { if(source_size.x == 0 || source_size.y == 0) return; const vec2i dest_texture_size = self->params.destination_textures_size[0]; const unsigned int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; if(rotation == GSR_ROT_90 || rotation == GSR_ROT_270) { const float tmp = texture_size.x; texture_size.x = texture_size.y; texture_size.y = tmp; } self->params.egl->glBindTexture(texture_target, texture_id); gsr_color_conversion_swizzle_texture_source(self, texture_target, source_color); const vec2f pos_norm = { ((float)destination_pos.x / (dest_texture_size.x == 0 ? 1.0f : (float)dest_texture_size.x)) * 2.0f, ((float)destination_pos.y / (dest_texture_size.y == 0 ? 1.0f : (float)dest_texture_size.y)) * 2.0f, }; const vec2f size_norm = { ((float)source_size.x / (dest_texture_size.x == 0 ? 1.0f : (float)dest_texture_size.x)) * 2.0f * scale.x, ((float)source_size.y / (dest_texture_size.y == 0 ? 1.0f : (float)dest_texture_size.y)) * 2.0f * scale.y, }; const vec2f texture_pos_norm = { (float)source_position.x / (texture_size.x == 0 ? 1.0f : (float)texture_size.x), (float)source_position.y / (texture_size.y == 0 ? 1.0f : (float)texture_size.y), }; const vec2f texture_size_norm = { (float)source_size.x / (texture_size.x == 0 ? 1.0f : (float)texture_size.x), (float)source_size.y / (texture_size.y == 0 ? 1.0f : (float)texture_size.y), }; float vertices[] = { -1.0f + 0.0f, -1.0f + 0.0f + size_norm.y, texture_pos_norm.x, texture_pos_norm.y + texture_size_norm.y, -1.0f + 0.0f, -1.0f + 0.0f, texture_pos_norm.x, texture_pos_norm.y, -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f, texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y, -1.0f + 0.0f, -1.0f + 0.0f + size_norm.y, texture_pos_norm.x, texture_pos_norm.y + texture_size_norm.y, -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f, texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y, -1.0f + 0.0f + size_norm.x, -1.0f + 0.0f + size_norm.y, texture_pos_norm.x + texture_size_norm.x, texture_pos_norm.y + texture_size_norm.y }; if(flip & GSR_FLIP_HORIZONTAL) { for(int i = 0; i < 6; ++i) { const float prev_x = vertices[i*4 + 2]; vertices[i*4 + 2] = texture_pos_norm.x + texture_size_norm.x - prev_x; } } if(flip & GSR_FLIP_VERTICAL) { for(int i = 0; i < 6; ++i) { const float prev_y = vertices[i*4 + 3]; vertices[i*4 + 3] = texture_pos_norm.y + texture_size_norm.y - prev_y; } } self->params.egl->glBindVertexArray(self->vertex_array_object_id); self->params.egl->glViewport(0, 0, dest_texture_size.x, dest_texture_size.y); /* TODO: this, also cleanup */ self->params.egl->glBindBuffer(GL_ARRAY_BUFFER, self->vertex_buffer_object_id); self->params.egl->glBufferSubData(GL_ARRAY_BUFFER, 0, 24 * sizeof(float), vertices); switch(source_color) { case GSR_SOURCE_COLOR_RGB: case GSR_SOURCE_COLOR_BGR: { switch(self->params.destination_color) { case GSR_DESTINATION_COLOR_NV12: case GSR_DESTINATION_COLOR_P010: { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]); //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example) int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_Y_EXTERNAL : GRAPHICS_SHADER_INDEX_Y; gsr_shader_use(&self->graphics_shaders[shader_index]); self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix); self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y); self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6); if(self->params.num_destination_textures > 1) { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]); //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); shader_index = external_texture ? GRAPHICS_SHADER_INDEX_UV_EXTERNAL : GRAPHICS_SHADER_INDEX_UV; gsr_shader_use(&self->graphics_shaders[shader_index]); self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix); self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y); self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6); } break; } case GSR_DESTINATION_COLOR_RGB: { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]); //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example) const int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_RGB_EXTERNAL : GRAPHICS_SHADER_INDEX_RGB; gsr_shader_use(&self->graphics_shaders[shader_index]); self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix); self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y); self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6); break; } } break; } case GSR_SOURCE_COLOR_YUYV: { switch(self->params.destination_color) { case GSR_DESTINATION_COLOR_NV12: case GSR_DESTINATION_COLOR_P010: { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]); //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example) int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_YUYV_TO_Y_EXTERNAL : GRAPHICS_SHADER_INDEX_YUYV_TO_Y; gsr_shader_use(&self->graphics_shaders[shader_index]); self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix); self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y); self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6); if(self->params.num_destination_textures > 1) { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]); //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); shader_index = external_texture ? GRAPHICS_SHADER_INDEX_YUYV_TO_UV_EXTERNAL : GRAPHICS_SHADER_INDEX_YUYV_TO_UV; gsr_shader_use(&self->graphics_shaders[shader_index]); self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix); self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y); self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6); } break; } case GSR_DESTINATION_COLOR_RGB: { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]); //cap_xcomp->params.egl->glClear(GL_COLOR_BUFFER_BIT); // TODO: Do this in a separate clear_ function. We want to do that when using multiple drm to create the final image (multiple monitors for example) const int shader_index = external_texture ? GRAPHICS_SHADER_INDEX_YUYV_TO_RGB_EXTERNAL : GRAPHICS_SHADER_INDEX_YUYV_TO_RGB; gsr_shader_use(&self->graphics_shaders[shader_index]); self->params.egl->glUniformMatrix2fv(self->graphics_uniforms[shader_index].rotation_matrix, 1, GL_TRUE, (const float*)rotation_matrix); self->params.egl->glUniform2f(self->graphics_uniforms[shader_index].offset, pos_norm.x, pos_norm.y); self->params.egl->glDrawArrays(GL_TRIANGLES, 0, 6); break; } } break; } } self->params.egl->glBindVertexArray(0); self->params.egl->glUseProgram(0); gsr_color_conversion_swizzle_reset(self, texture_target, source_color); self->params.egl->glBindTexture(texture_target, 0); self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0); } void gsr_color_conversion_draw(gsr_color_conversion *self, unsigned int texture_id, vec2i destination_pos, vec2i destination_size, vec2i source_pos, vec2i source_size, vec2i texture_size, gsr_rotation rotation, gsr_flip flip, gsr_source_color source_color, bool external_texture) { assert(!external_texture || self->params.load_external_image_shader); if(external_texture && !self->params.load_external_image_shader) { fprintf(stderr, "gsr error: gsr_color_conversion_draw: external texture not loaded\n"); return; } vec2f scale = {0.0f, 0.0f}; if(source_size.x > 0 && source_size.y > 0) scale = (vec2f){ (double)destination_size.x/(double)source_size.x, (double)destination_size.y/(double)source_size.y }; vec2i source_position = {0, 0}; float rotation_matrix[2][2] = {{0, 0}, {0, 0}}; gsr_color_conversion_apply_rotation(rotation, rotation_matrix); const int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; self->params.egl->glBindTexture(texture_target, texture_id); source_position.x += source_pos.x; source_position.y += source_pos.y; gsr_color_conversion_draw_graphics(self, texture_id, external_texture, rotation, flip, rotation_matrix, source_position, source_size, destination_pos, texture_size, scale, source_color); self->params.egl->glFlush(); // TODO: Use the minimal barrier required self->params.egl->glMemoryBarrier(GL_ALL_BARRIER_BITS); // GL_SHADER_IMAGE_ACCESS_BARRIER_BIT self->params.egl->glUseProgram(0); self->params.egl->glBindTexture(texture_target, 0); } void gsr_color_conversion_clear(gsr_color_conversion *self) { float color1[4] = {0.0f, 0.0f, 0.0f, 1.0f}; float color2[4] = {0.0f, 0.0f, 0.0f, 1.0f}; switch(self->params.destination_color) { case GSR_DESTINATION_COLOR_NV12: case GSR_DESTINATION_COLOR_P010: { color2[0] = 0.5f; color2[1] = 0.5f; color2[2] = 0.0f; color2[3] = 1.0f; break; } case GSR_DESTINATION_COLOR_RGB: { color2[0] = 0.0f; color2[1] = 0.0f; color2[2] = 0.0f; color2[3] = 1.0f; break; } } self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[0]); self->params.egl->glClearColor(color1[0], color1[1], color1[2], color1[3]); self->params.egl->glClear(GL_COLOR_BUFFER_BIT); if(self->params.num_destination_textures > 1) { self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[1]); self->params.egl->glClearColor(color2[0], color2[1], color2[2], color2[3]); self->params.egl->glClear(GL_COLOR_BUFFER_BIT); } self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0); } void gsr_color_conversion_read_destination_texture(gsr_color_conversion *self, int destination_texture_index, int x, int y, int width, int height, unsigned int color_format, unsigned int data_format, void *pixels) { assert(destination_texture_index >= 0 && destination_texture_index < self->params.num_destination_textures); self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, self->framebuffers[destination_texture_index]); self->params.egl->glReadPixels(x, y, width, height, color_format, data_format, pixels); self->params.egl->glBindFramebuffer(GL_FRAMEBUFFER, 0); } gsr_rotation gsr_monitor_rotation_to_rotation(gsr_monitor_rotation monitor_rotation) { return (gsr_rotation)monitor_rotation; } fsdsfdsfdsfdsf-5.13.8/src/cuda.c000066400000000000000000000072651520215207700164660ustar00rootroot00000000000000#include "../include/cuda.h" #include "../include/library_loader.h" #include #include #include #include bool gsr_cuda_load(gsr_cuda *self) { memset(self, 0, sizeof(gsr_cuda)); dlerror(); /* clear */ void *lib = dlopen("libcuda.so.1", RTLD_LAZY); if(!lib) { lib = dlopen("libcuda.so", RTLD_LAZY); if(!lib) { fprintf(stderr, "gsr error: gsr_cuda_load failed: failed to load libcuda.so/libcuda.so.1, error: %s\n", dlerror()); return false; } } const dlsym_assign required_dlsym[] = { { (void**)&self->cuInit, "cuInit" }, { (void**)&self->cuDeviceGetCount, "cuDeviceGetCount" }, { (void**)&self->cuDeviceGet, "cuDeviceGet" }, { (void**)&self->cuCtxCreate_v2, "cuCtxCreate_v2" }, { (void**)&self->cuCtxDestroy_v2, "cuCtxDestroy_v2" }, { (void**)&self->cuCtxPushCurrent_v2, "cuCtxPushCurrent_v2" }, { (void**)&self->cuCtxPopCurrent_v2, "cuCtxPopCurrent_v2" }, { (void**)&self->cuGetErrorString, "cuGetErrorString" }, { (void**)&self->cuMemcpy2D_v2, "cuMemcpy2D_v2" }, { (void**)&self->cuMemcpy2DAsync_v2, "cuMemcpy2DAsync_v2" }, { (void**)&self->cuStreamSynchronize, "cuStreamSynchronize" }, { (void**)&self->cuGraphicsGLRegisterImage, "cuGraphicsGLRegisterImage" }, { (void**)&self->cuGraphicsEGLRegisterImage, "cuGraphicsEGLRegisterImage" }, { (void**)&self->cuGraphicsResourceSetMapFlags, "cuGraphicsResourceSetMapFlags" }, { (void**)&self->cuGraphicsMapResources, "cuGraphicsMapResources" }, { (void**)&self->cuGraphicsUnmapResources, "cuGraphicsUnmapResources" }, { (void**)&self->cuGraphicsUnregisterResource, "cuGraphicsUnregisterResource" }, { (void**)&self->cuGraphicsSubResourceGetMappedArray, "cuGraphicsSubResourceGetMappedArray" }, { NULL, NULL } }; CUresult res; if(!dlsym_load_list(lib, required_dlsym)) { fprintf(stderr, "gsr error: gsr_cuda_load failed: missing required symbols in libcuda.so/libcuda.so.1\n"); goto fail; } res = self->cuInit(0); if(res != CUDA_SUCCESS) { const char *err_str = "unknown"; self->cuGetErrorString(res, &err_str); fprintf(stderr, "gsr error: gsr_cuda_load failed: cuInit failed, error: %s (result: %d)\n", err_str, res); goto fail; } int nGpu = 0; self->cuDeviceGetCount(&nGpu); if(nGpu <= 0) { fprintf(stderr, "gsr error: gsr_cuda_load failed: no cuda supported devices found\n"); goto fail; } // TODO: Use the device associated with the opengl graphics context CUdevice cu_dev; res = self->cuDeviceGet(&cu_dev, 0); if(res != CUDA_SUCCESS) { const char *err_str = "unknown"; self->cuGetErrorString(res, &err_str); fprintf(stderr, "gsr error: gsr_cuda_load failed: unable to get CUDA device, error: %s (result: %d)\n", err_str, res); goto fail; } res = self->cuCtxCreate_v2(&self->cu_ctx, CU_CTX_SCHED_AUTO, cu_dev); if(res != CUDA_SUCCESS) { const char *err_str = "unknown"; self->cuGetErrorString(res, &err_str); fprintf(stderr, "gsr error: gsr_cuda_load failed: unable to create CUDA context, error: %s (result: %d)\n", err_str, res); goto fail; } self->library = lib; return true; fail: dlclose(lib); memset(self, 0, sizeof(gsr_cuda)); return false; } void gsr_cuda_unload(gsr_cuda *self) { if(self->library) { if(self->cu_ctx) { self->cuCtxDestroy_v2(self->cu_ctx); self->cu_ctx = 0; } dlclose(self->library); } memset(self, 0, sizeof(gsr_cuda)); } fsdsfdsfdsfdsf-5.13.8/src/cursor.c000066400000000000000000000104471520215207700170630ustar00rootroot00000000000000#include "../include/cursor.h" #include #include #include #include #include // TODO: Test cursor visibility with XFixesHideCursor static bool gsr_cursor_set_from_x11_cursor_image(gsr_cursor *self, XFixesCursorImage *x11_cursor_image, bool *visible) { uint8_t *cursor_data = NULL; uint8_t *out = NULL; *visible = false; if(!x11_cursor_image) goto err; if(!x11_cursor_image->pixels) goto err; self->hotspot.x = x11_cursor_image->xhot; self->hotspot.y = x11_cursor_image->yhot; self->egl->glBindTexture(GL_TEXTURE_2D, self->texture_id); self->size.x = x11_cursor_image->width; self->size.y = x11_cursor_image->height; const unsigned long *pixels = x11_cursor_image->pixels; cursor_data = malloc(self->size.x * self->size.y * 4); if(!cursor_data) goto err; out = cursor_data; /* Un-premultiply alpha */ for(int y = 0; y < self->size.y; ++y) { for(int x = 0; x < self->size.x; ++x) { uint32_t pixel = *pixels++; uint8_t *in = (uint8_t*)&pixel; uint8_t alpha = in[3]; if(alpha == 0) { alpha = 1; } else { *visible = true; } out[0] = (float)in[2] * 255.0/(float)alpha; out[1] = (float)in[1] * 255.0/(float)alpha; out[2] = (float)in[0] * 255.0/(float)alpha; out[3] = in[3]; out += 4; in += 4; } } // TODO: glTextureSubImage2D if same size self->egl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self->size.x, self->size.y, 0, GL_RGBA, GL_UNSIGNED_BYTE, cursor_data); free(cursor_data); self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->egl->glBindTexture(GL_TEXTURE_2D, 0); XFree(x11_cursor_image); return true; err: self->egl->glBindTexture(GL_TEXTURE_2D, 0); if(x11_cursor_image) XFree(x11_cursor_image); return false; } int gsr_cursor_init(gsr_cursor *self, gsr_egl *egl, Display *display) { int x_fixes_error_base = 0; assert(egl); assert(display); memset(self, 0, sizeof(*self)); self->egl = egl; self->display = display; self->x_fixes_event_base = 0; if(!XFixesQueryExtension(self->display, &self->x_fixes_event_base, &x_fixes_error_base)) { fprintf(stderr, "gsr error: gsr_cursor_init: your X11 server is missing the XFixes extension\n"); gsr_cursor_deinit(self); return -1; } self->egl->glGenTextures(1, &self->texture_id); XFixesSelectCursorInput(self->display, DefaultRootWindow(self->display), XFixesDisplayCursorNotifyMask); gsr_cursor_set_from_x11_cursor_image(self, XFixesGetCursorImage(self->display), &self->visible); self->cursor_image_set = true; return 0; } void gsr_cursor_deinit(gsr_cursor *self) { if(!self->display) return; if(self->texture_id) { self->egl->glDeleteTextures(1, &self->texture_id); self->texture_id = 0; } if(self->display) XFixesSelectCursorInput(self->display, DefaultRootWindow(self->display), 0); self->display = NULL; self->egl = NULL; } bool gsr_cursor_on_event(gsr_cursor *self, XEvent *xev) { if(!self->display) return false; bool updated = false; if(xev->type == self->x_fixes_event_base + XFixesCursorNotify) { XFixesCursorNotifyEvent *cursor_notify_event = (XFixesCursorNotifyEvent*)xev; if(cursor_notify_event->subtype == XFixesDisplayCursorNotify && cursor_notify_event->window == DefaultRootWindow(self->display)) { self->cursor_image_set = false; } } if(!self->cursor_image_set) { self->cursor_image_set = true; gsr_cursor_set_from_x11_cursor_image(self, XFixesGetCursorImage(self->display), &self->visible); updated = true; } return updated; } void gsr_cursor_tick(gsr_cursor *self, Window relative_to) { if(!self->display) return; Window dummy_window; int dummy_i; unsigned int dummy_u; XQueryPointer(self->display, relative_to, &dummy_window, &dummy_window, &dummy_i, &dummy_i, &self->position.x, &self->position.y, &dummy_u); } fsdsfdsfdsfdsf-5.13.8/src/damage.c000066400000000000000000000407571520215207700167730ustar00rootroot00000000000000#include "../include/damage.h" #include "../include/utils.h" #include "../include/window/window.h" #include #include #include #include #include typedef struct { vec2i pos; vec2i size; } gsr_rectangle; static bool rectangles_intersect(gsr_rectangle rect1, gsr_rectangle rect2) { return rect1.pos.x < rect2.pos.x + rect2.size.x && rect1.pos.x + rect1.size.x > rect2.pos.x && rect1.pos.y < rect2.pos.y + rect2.size.y && rect1.pos.y + rect1.size.y > rect2.pos.y; } static bool xrandr_is_supported(Display *display) { int major_version = 0; int minor_version = 0; if(!XRRQueryVersion(display, &major_version, &minor_version)) return false; return major_version > 1 || (major_version == 1 && minor_version >= 2); } static int gsr_damage_get_tracked_monitor_index(const gsr_damage *self, const char *monitor_name) { for(int i = 0; i < self->num_monitors_tracked; ++i) { if(strcmp(self->monitors_tracked[i].monitor_name, monitor_name) == 0) return i; } return -1; } static void add_monitor_callback(const gsr_monitor *monitor, void *userdata) { gsr_damage *self = userdata; const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor->name); gsr_damage_monitor *damage_monitor = NULL; if(damage_monitor_index != -1) { damage_monitor = &self->monitors_tracked[damage_monitor_index]; damage_monitor->monitor = NULL; } if(self->num_monitors + 1 > GSR_DAMAGE_MAX_MONITORS) { fprintf(stderr, "gsr error: gsr_damage_on_output_change: max monitors reached\n"); return; } char *monitor_name_copy = strdup(monitor->name); if(!monitor_name_copy) { fprintf(stderr, "gsr error: gsr_damage_on_output_change: strdup failed for monitor: %s\n", monitor->name); return; } self->monitors[self->num_monitors] = *monitor; self->monitors[self->num_monitors].name = monitor_name_copy; ++self->num_monitors; if(damage_monitor) damage_monitor->monitor = &self->monitors[self->num_monitors - 1]; } bool gsr_damage_init(gsr_damage *self, gsr_egl *egl, gsr_cursor *cursor, bool track_cursor) { memset(self, 0, sizeof(*self)); self->egl = egl; self->track_cursor = track_cursor; self->cursor = cursor; if(gsr_window_get_display_server(egl->window) != GSR_DISPLAY_SERVER_X11) { fprintf(stderr, "gsr error: gsr_damage_init: damage tracking is not supported on wayland\n"); return false; } self->display = gsr_window_get_display(egl->window); if(!XDamageQueryExtension(self->display, &self->damage_event, &self->damage_error)) { fprintf(stderr, "gsr error: gsr_damage_init: XDamage is not supported by your X11 server\n"); gsr_damage_deinit(self); return false; } if(!XRRQueryExtension(self->display, &self->randr_event, &self->randr_error)) { fprintf(stderr, "gsr error: gsr_damage_init: XRandr is not supported by your X11 server\n"); gsr_damage_deinit(self); return false; } if(!xrandr_is_supported(self->display)) { fprintf(stderr, "gsr error: gsr_damage_init: your X11 randr version is too old\n"); gsr_damage_deinit(self); return false; } XRRSelectInput(self->display, DefaultRootWindow(self->display), RRScreenChangeNotifyMask | RRCrtcChangeNotifyMask | RROutputChangeNotifyMask); self->monitor_damage = XDamageCreate(self->display, DefaultRootWindow(self->display), XDamageReportNonEmpty); if(!self->monitor_damage) { fprintf(stderr, "gsr error: gsr_damage_init: XDamageCreate failed\n"); gsr_damage_deinit(self); return false; } XDamageSubtract(self->display, self->monitor_damage, None, None); for_each_active_monitor_output_x11_not_cached(self->display, add_monitor_callback, self); self->damaged = true; return true; } static void gsr_damage_deinit_monitors(gsr_damage *self) { for(int i = 0; i < self->num_monitors; ++i) { free((char*)self->monitors[i].name); } self->num_monitors = 0; } void gsr_damage_deinit(gsr_damage *self) { if(self->monitor_damage) { XDamageDestroy(self->display, self->monitor_damage); self->monitor_damage = None; } for(int i = 0; i < self->num_monitors_tracked; ++i) { free(self->monitors_tracked[i].monitor_name); } self->num_monitors_tracked = 0; for(int i = 0; i < self->num_windows_tracked; ++i) { XSelectInput(self->display, self->windows_tracked[i].window_id, 0); XDamageDestroy(self->display, self->windows_tracked[i].damage); } self->num_windows_tracked = 0; self->all_monitors_tracked_refcount = 0; gsr_damage_deinit_monitors(self); self->damage_event = 0; self->damage_error = 0; self->randr_event = 0; self->randr_error = 0; } static int gsr_damage_get_tracked_window_index(const gsr_damage *self, int64_t window) { for(int i = 0; i < self->num_windows_tracked; ++i) { if(self->windows_tracked[i].window_id == window) return i; } return -1; } bool gsr_damage_start_tracking_window(gsr_damage *self, int64_t window) { if(self->damage_event == 0 || window == None) return false; const int damage_window_index = gsr_damage_get_tracked_window_index(self, window); if(damage_window_index != -1) { ++self->windows_tracked[damage_window_index].refcount; return true; } if(self->num_windows_tracked + 1 > GSR_DAMAGE_MAX_TRACKED_TARGETS) { fprintf(stderr, "gsr error: gsr_damage_start_tracking_window: max window targets reached\n"); return false; } XWindowAttributes win_attr; win_attr.x = 0; win_attr.y = 0; win_attr.width = 0; win_attr.height = 0; if(!XGetWindowAttributes(self->display, window, &win_attr)) fprintf(stderr, "gsr warning: gsr_damage_start_tracking_window failed: failed to get window attributes: %ld\n", (long)window); const Damage damage = XDamageCreate(self->display, window, XDamageReportNonEmpty); if(!damage) { fprintf(stderr, "gsr error: gsr_damage_start_tracking_window: XDamageCreate failed\n"); return false; } XDamageSubtract(self->display, damage, None, None); XSelectInput(self->display, window, StructureNotifyMask | ExposureMask); gsr_damage_window *damage_window = &self->windows_tracked[self->num_windows_tracked]; ++self->num_windows_tracked; damage_window->window_id = window; damage_window->window_pos.x = win_attr.x; damage_window->window_pos.y = win_attr.y; damage_window->window_size.x = win_attr.width; damage_window->window_size.y = win_attr.height; damage_window->damage = damage; damage_window->refcount = 1; return true; } void gsr_damage_stop_tracking_window(gsr_damage *self, int64_t window) { if(window == None) return; const int damage_window_index = gsr_damage_get_tracked_window_index(self, window); if(damage_window_index == -1) return; gsr_damage_window *damage_window = &self->windows_tracked[damage_window_index]; --damage_window->refcount; if(damage_window->refcount <= 0) { XSelectInput(self->display, damage_window->window_id, 0); XDamageDestroy(self->display, damage_window->damage); self->windows_tracked[damage_window_index] = self->windows_tracked[self->num_windows_tracked - 1]; --self->num_windows_tracked; } } static gsr_monitor* gsr_damage_get_monitor_by_id(gsr_damage *self, RRCrtc id) { for(int i = 0; i < self->num_monitors; ++i) { if(self->monitors[i].monitor_identifier == id) return &self->monitors[i]; } return NULL; } static gsr_monitor* gsr_damage_get_monitor_by_name(gsr_damage *self, const char *name) { for(int i = 0; i < self->num_monitors; ++i) { if(strcmp(self->monitors[i].name, name) == 0) return &self->monitors[i]; } return NULL; } bool gsr_damage_start_tracking_monitor(gsr_damage *self, const char *monitor_name) { if(self->damage_event == 0) return false; if(strcmp(monitor_name, "screen-direct") == 0 || strcmp(monitor_name, "screen-direct-force") == 0) monitor_name = NULL; if(!monitor_name) { ++self->all_monitors_tracked_refcount; return true; } const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor_name); if(damage_monitor_index != -1) { ++self->monitors_tracked[damage_monitor_index].refcount; return true; } if(self->num_monitors_tracked + 1 > GSR_DAMAGE_MAX_TRACKED_TARGETS) { fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: max monitor targets reached\n"); return false; } char *monitor_name_copy = strdup(monitor_name); if(!monitor_name_copy) { fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: strdup failed for monitor: %s\n", monitor_name); return false; } gsr_monitor *monitor = gsr_damage_get_monitor_by_name(self, monitor_name); if(!monitor) { fprintf(stderr, "gsr error: gsr_damage_start_tracking_monitor: failed to find monitor: %s\n", monitor_name); free(monitor_name_copy); return false; } gsr_damage_monitor *damage_monitor = &self->monitors_tracked[self->num_monitors_tracked]; ++self->num_monitors_tracked; damage_monitor->monitor_name = monitor_name_copy; damage_monitor->monitor = monitor; damage_monitor->refcount = 1; return true; } void gsr_damage_stop_tracking_monitor(gsr_damage *self, const char *monitor_name) { if(strcmp(monitor_name, "screen-direct") == 0 || strcmp(monitor_name, "screen-direct-force") == 0) monitor_name = NULL; if(!monitor_name) { --self->all_monitors_tracked_refcount; if(self->all_monitors_tracked_refcount < 0) self->all_monitors_tracked_refcount = 0; return; } const int damage_monitor_index = gsr_damage_get_tracked_monitor_index(self, monitor_name); if(damage_monitor_index == -1) return; gsr_damage_monitor *damage_monitor = &self->monitors_tracked[damage_monitor_index]; --damage_monitor->refcount; if(damage_monitor->refcount <= 0) { free(damage_monitor->monitor_name); self->monitors_tracked[damage_monitor_index] = self->monitors_tracked[self->num_monitors_tracked - 1]; --self->num_monitors_tracked; } } static void gsr_damage_on_crtc_change(gsr_damage *self, XEvent *xev) { const XRRCrtcChangeNotifyEvent *rr_crtc_change_event = (XRRCrtcChangeNotifyEvent*)xev; if(rr_crtc_change_event->crtc == 0) return; if(rr_crtc_change_event->width == 0 || rr_crtc_change_event->height == 0) return; gsr_monitor *monitor = gsr_damage_get_monitor_by_id(self, rr_crtc_change_event->crtc); if(!monitor) return; if(rr_crtc_change_event->x != monitor->pos.x || rr_crtc_change_event->y != monitor->pos.y || (int)rr_crtc_change_event->width != monitor->size.x || (int)rr_crtc_change_event->height != monitor->size.y) { monitor->pos.x = rr_crtc_change_event->x; monitor->pos.y = rr_crtc_change_event->y; monitor->size.x = rr_crtc_change_event->width; monitor->size.y = rr_crtc_change_event->height; } } static void gsr_damage_on_output_change(gsr_damage *self, XEvent *xev) { const XRROutputChangeNotifyEvent *rr_output_change_event = (XRROutputChangeNotifyEvent*)xev; if(!rr_output_change_event->output) return; gsr_damage_deinit_monitors(self); for_each_active_monitor_output_x11_not_cached(self->display, add_monitor_callback, self); } static void gsr_damage_on_randr_event(gsr_damage *self, XEvent *xev) { const XRRNotifyEvent *rr_event = (XRRNotifyEvent*)xev; switch(rr_event->subtype) { case RRNotify_CrtcChange: gsr_damage_on_crtc_change(self, xev); break; case RRNotify_OutputChange: gsr_damage_on_output_change(self, xev); break; } } static void gsr_damage_on_damage_event(gsr_damage *self, XEvent *xev) { const XDamageNotifyEvent *de = (XDamageNotifyEvent*)xev; XserverRegion region = XFixesCreateRegion(self->display, NULL, 0); /* Subtract all the damage, repairing the window */ XDamageSubtract(self->display, de->damage, None, region); if(self->all_monitors_tracked_refcount > 0) self->damaged = true; if(!self->damaged) { for(int i = 0; i < self->num_windows_tracked; ++i) { const gsr_damage_window *damage_window = &self->windows_tracked[i]; if(damage_window->window_id == (int64_t)de->drawable) { self->damaged = true; break; } } } if(!self->damaged) { int num_rectangles = 0; XRectangle *rectangles = XFixesFetchRegion(self->display, region, &num_rectangles); if(rectangles) { for(int i = 0; i < num_rectangles; ++i) { const gsr_rectangle damage_region = { (vec2i){rectangles[i].x, rectangles[i].y}, (vec2i){rectangles[i].width, rectangles[i].height} }; for(int j = 0; j < self->num_monitors_tracked; ++j) { const gsr_monitor *monitor = self->monitors_tracked[j].monitor; if(!monitor) continue; const gsr_rectangle monitor_region = { monitor->pos, monitor->size }; self->damaged = rectangles_intersect(monitor_region, damage_region); if(self->damaged) goto intersection_found; } } intersection_found: XFree(rectangles); } } XFixesDestroyRegion(self->display, region); XFlush(self->display); } static void gsr_damage_on_tick_cursor(gsr_damage *self) { if(self->cursor->position.x == self->cursor_pos.x && self->cursor->position.y == self->cursor_pos.y) return; self->cursor_pos = self->cursor->position; if(self->damaged) return; const gsr_rectangle cursor_region = { self->cursor->position, self->cursor->size }; if(self->all_monitors_tracked_refcount > 0) self->damaged = true; if(!self->damaged) { for(int i = 0; i < self->num_windows_tracked; ++i) { const gsr_damage_window *damage_window = &self->windows_tracked[i]; const gsr_rectangle window_region = { damage_window->window_pos, damage_window->window_size }; if(rectangles_intersect(window_region, cursor_region)) { self->damaged = true; break; } } } if(!self->damaged) { for(int i = 0; i < self->num_monitors_tracked; ++i) { const gsr_monitor *monitor = self->monitors_tracked[i].monitor; if(!monitor) continue; const gsr_rectangle monitor_region = { monitor->pos, monitor->size }; if(rectangles_intersect(monitor_region, cursor_region)) { self->damaged = true; break; } } } } static void gsr_damage_on_window_configure_notify(gsr_damage *self, XEvent *xev) { for(int i = 0; i < self->num_windows_tracked; ++i) { gsr_damage_window *damage_window = &self->windows_tracked[i]; if(damage_window->window_id == (int64_t)xev->xconfigure.window) { damage_window->window_pos.x = xev->xconfigure.x; damage_window->window_pos.y = xev->xconfigure.y; damage_window->window_size.x = xev->xconfigure.width; damage_window->window_size.y = xev->xconfigure.height; break; } } } void gsr_damage_on_event(gsr_damage *self, XEvent *xev) { if(self->damage_event == 0) return; if(xev->type == ConfigureNotify) gsr_damage_on_window_configure_notify(self, xev); if(self->randr_event) { if(xev->type == self->randr_event + RRScreenChangeNotify) XRRUpdateConfiguration(xev); if(xev->type == self->randr_event + RRNotify) gsr_damage_on_randr_event(self, xev); } if(self->damage_event && xev->type == self->damage_event + XDamageNotify) gsr_damage_on_damage_event(self, xev); } void gsr_damage_tick(gsr_damage *self) { if(self->damage_event == 0) return; if(self->track_cursor && self->cursor->visible) gsr_damage_on_tick_cursor(self); } bool gsr_damage_is_damaged(gsr_damage *self) { return self->damage_event == 0 || self->damaged; } void gsr_damage_clear(gsr_damage *self) { self->damaged = false; } fsdsfdsfdsfdsf-5.13.8/src/dbus.c000066400000000000000000001034421520215207700165010ustar00rootroot00000000000000#include "../include/dbus.h" #include #include #include #include #include #include /* TODO: Make non-blocking when GPU Screen Recorder is turned into a library */ /* TODO: Make sure responses matches the requests */ #define DESKTOP_PORTAL_SIGNAL_RULE "type='signal',interface='org.freedesktop.Portal.Request'" typedef enum { DICT_TYPE_STRING, DICT_TYPE_UINT32, DICT_TYPE_BOOL, } dict_value_type; typedef struct { const char *key; dict_value_type value_type; union { char *str; dbus_uint32_t u32; dbus_bool_t boolean; }; } dict_entry; static bool generate_random_characters(char *buffer, int buffer_size, const char *alphabet, size_t alphabet_size) { /* TODO: Use other functions on other platforms than linux */ if(getrandom(buffer, buffer_size, 0) < buffer_size) { fprintf(stderr, "Failed to get random bytes, error: %s\n", strerror(errno)); return false; } for(int i = 0; i < buffer_size; ++i) { unsigned char c = *(unsigned char*)&buffer[i]; buffer[i] = alphabet[c % alphabet_size]; } return true; } static bool generate_random_characters_standard_alphabet(char *buffer, int buffer_size) { return generate_random_characters(buffer, buffer_size, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 62); } static const char* dict_value_type_to_string(dict_value_type type) { switch(type) { case DICT_TYPE_STRING: return "string"; case DICT_TYPE_UINT32: return "uint32"; case DICT_TYPE_BOOL: return "boolean"; } return "(unknown)"; } bool gsr_dbus_init(gsr_dbus *self, const char *screencast_restore_token) { memset(self, 0, sizeof(*self)); dbus_error_init(&self->err); self->random_str[DBUS_RANDOM_STR_SIZE] = '\0'; if(!generate_random_characters_standard_alphabet(self->random_str, DBUS_RANDOM_STR_SIZE)) { fprintf(stderr, "gsr error: gsr_dbus_init: failed to generate random string\n"); return false; } self->con = dbus_bus_get(DBUS_BUS_SESSION, &self->err); if(dbus_error_is_set(&self->err)) { fprintf(stderr, "gsr error: gsr_dbus_init: dbus_bus_get failed with error: %s\n", self->err.message); return false; } if(!self->con) { fprintf(stderr, "gsr error: gsr_dbus_init: failed to get dbus session\n"); return false; } if(screencast_restore_token) { self->screencast_restore_token = strdup(screencast_restore_token); if(!self->screencast_restore_token) { fprintf(stderr, "gsr error: gsr_dbus_init: failed to clone restore token\n"); gsr_dbus_deinit(self); return false; } } return true; } void gsr_dbus_deinit(gsr_dbus *self) { if(self->screencast_restore_token) { free(self->screencast_restore_token); self->screencast_restore_token = NULL; } if(self->desktop_portal_rule_added) { dbus_bus_remove_match(self->con, DESKTOP_PORTAL_SIGNAL_RULE, NULL); // dbus_connection_flush(self->con); self->desktop_portal_rule_added = false; } if(self->con) { dbus_error_free(&self->err); // Apparently shouldn't be used when a connection is setup by using dbus_bus_get //dbus_connection_close(self->con); dbus_connection_unref(self->con); self->con = NULL; } } static bool gsr_dbus_desktop_portal_get_property(gsr_dbus *self, const char *interface, const char *property_name, uint32_t *result) { *result = 0; DBusMessage *msg = dbus_message_new_method_call( "org.freedesktop.portal.Desktop", // target for the method call "/org/freedesktop/portal/desktop", // object to call on "org.freedesktop.DBus.Properties", // interface to call on "Get"); // method name if(!msg) { fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: dbus_message_new_method_call failed\n"); return false; } DBusMessageIter it; dbus_message_iter_init_append(msg, &it); if(!dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &interface)) { fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: failed to add interface\n"); dbus_message_unref(msg); return false; } if(!dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &property_name)) { fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: failed to add property_name\n"); dbus_message_unref(msg); return false; } DBusPendingCall *pending = NULL; if(!dbus_connection_send_with_reply(self->con, msg, &pending, -1) || !pending) { // -1 is default timeout fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: dbus_connection_send_with_reply failed\n"); dbus_message_unref(msg); return false; } dbus_connection_flush(self->con); //fprintf(stderr, "Request Sent\n"); dbus_message_unref(msg); msg = NULL; dbus_pending_call_block(pending); msg = dbus_pending_call_steal_reply(pending); if(!msg) { fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: dbus_pending_call_steal_reply failed\n"); dbus_pending_call_unref(pending); dbus_message_unref(msg); return false; } dbus_pending_call_unref(pending); pending = NULL; DBusMessageIter resp_args; if(!dbus_message_iter_init(msg, &resp_args)) { fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: response message is missing arguments\n"); dbus_message_unref(msg); return false; } else if(DBUS_TYPE_UINT32 == dbus_message_iter_get_arg_type(&resp_args)) { dbus_message_iter_get_basic(&resp_args, result); } else if(DBUS_TYPE_VARIANT == dbus_message_iter_get_arg_type(&resp_args)) { DBusMessageIter variant_iter; dbus_message_iter_recurse(&resp_args, &variant_iter); if(dbus_message_iter_get_arg_type(&variant_iter) == DBUS_TYPE_UINT32) { dbus_message_iter_get_basic(&variant_iter, result); } else { fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: response message is not a variant with an uint32, %c\n", dbus_message_iter_get_arg_type(&variant_iter)); dbus_message_unref(msg); return false; } } else { fprintf(stderr, "gsr error: gsr_dbus_desktop_portal_get_property: response message is not an uint32, %c\n", dbus_message_iter_get_arg_type(&resp_args)); dbus_message_unref(msg); return false; // TODO: Check dbus_error_is_set? } dbus_message_unref(msg); return true; } static uint32_t gsr_dbus_get_screencast_version_cached(gsr_dbus *self) { if(self->screencast_version == 0) gsr_dbus_desktop_portal_get_property(self, "org.freedesktop.portal.ScreenCast", "version", &self->screencast_version); return self->screencast_version; } static bool gsr_dbus_ensure_desktop_portal_rule_added(gsr_dbus *self) { if(self->desktop_portal_rule_added) return true; dbus_bus_add_match(self->con, DESKTOP_PORTAL_SIGNAL_RULE, &self->err); dbus_connection_flush(self->con); if(dbus_error_is_set(&self->err)) { fprintf(stderr, "gsr error: gsr_dbus_ensure_desktop_portal_rule_added: failed to add dbus rule %s, error: %s\n", DESKTOP_PORTAL_SIGNAL_RULE, self->err.message); return false; } self->desktop_portal_rule_added = true; return true; } static void gsr_dbus_portal_get_unique_handle_token(gsr_dbus *self, char *buffer, int size) { snprintf(buffer, size, "gpu_screen_recorder_handle_%s_%u", self->random_str, self->handle_counter++); } static void gsr_dbus_portal_get_unique_session_token(gsr_dbus *self, char *buffer, int size) { snprintf(buffer, size, "gpu_screen_recorder_session_%s", self->random_str); } static bool dbus_add_dict(DBusMessageIter *it, const dict_entry *entries, int num_entries) { DBusMessageIter array_it; if(!dbus_message_iter_open_container(it, DBUS_TYPE_ARRAY, "{sv}", &array_it)) return false; for (int i = 0; i < num_entries; ++i) { DBusMessageIter entry_it = DBUS_MESSAGE_ITER_INIT_CLOSED; DBusMessageIter variant_it = DBUS_MESSAGE_ITER_INIT_CLOSED; if(!dbus_message_iter_open_container(&array_it, DBUS_TYPE_DICT_ENTRY, NULL, &entry_it)) goto entry_err; if(!dbus_message_iter_append_basic(&entry_it, DBUS_TYPE_STRING, &entries[i].key)) goto entry_err; switch (entries[i].value_type) { case DICT_TYPE_STRING: { if(!dbus_message_iter_open_container(&entry_it, DBUS_TYPE_VARIANT, DBUS_TYPE_STRING_AS_STRING, &variant_it)) goto entry_err; if(!dbus_message_iter_append_basic(&variant_it, DBUS_TYPE_STRING, &entries[i].str)) goto entry_err; break; } case DICT_TYPE_UINT32: { if(!dbus_message_iter_open_container(&entry_it, DBUS_TYPE_VARIANT, DBUS_TYPE_UINT32_AS_STRING, &variant_it)) goto entry_err; if(!dbus_message_iter_append_basic(&variant_it, DBUS_TYPE_UINT32, &entries[i].u32)) goto entry_err; break; } case DICT_TYPE_BOOL: { if(!dbus_message_iter_open_container(&entry_it, DBUS_TYPE_VARIANT, DBUS_TYPE_BOOLEAN_AS_STRING, &variant_it)) goto entry_err; if(!dbus_message_iter_append_basic(&variant_it, DBUS_TYPE_BOOLEAN, &entries[i].boolean)) goto entry_err; break; } } dbus_message_iter_close_container(&entry_it, &variant_it); dbus_message_iter_close_container(&array_it, &entry_it); continue; entry_err: dbus_message_iter_abandon_container_if_open(&array_it, &variant_it); dbus_message_iter_abandon_container_if_open(&array_it, &entry_it); dbus_message_iter_abandon_container_if_open(it, &array_it); return false; } return dbus_message_iter_close_container(it, &array_it); } /* If |response_msg| is NULL then we dont wait for a response signal */ static bool gsr_dbus_call_screencast_method(gsr_dbus *self, const char *method_name, const char *session_handle, const char *parent_window, const dict_entry *entries, int num_entries, int *resp_fd, DBusMessage **response_msg) { if(resp_fd) *resp_fd = -1; if(response_msg) *response_msg = NULL; if(!gsr_dbus_ensure_desktop_portal_rule_added(self)) return false; DBusMessage *msg = dbus_message_new_method_call( "org.freedesktop.portal.Desktop", // target for the method call "/org/freedesktop/portal/desktop", // object to call on "org.freedesktop.portal.ScreenCast", // interface to call on method_name); // method name if(!msg) { fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: dbus_message_new_method_call failed\n"); return false; } DBusMessageIter it; dbus_message_iter_init_append(msg, &it); if(session_handle) { if(!dbus_message_iter_append_basic(&it, DBUS_TYPE_OBJECT_PATH, &session_handle)) { fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: failed to add session_handle\n"); dbus_message_unref(msg); return false; } } if(parent_window) { if(!dbus_message_iter_append_basic(&it, DBUS_TYPE_STRING, &parent_window)) { fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: failed to add parent_window\n"); dbus_message_unref(msg); return false; } } if(!dbus_add_dict(&it, entries, num_entries)) { fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: failed to add dict\n"); dbus_message_unref(msg); return false; } DBusPendingCall *pending = NULL; if(!dbus_connection_send_with_reply(self->con, msg, &pending, -1) || !pending) { // -1 is default timeout fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: dbus_connection_send_with_reply failed\n"); dbus_message_unref(msg); return false; } dbus_connection_flush(self->con); //fprintf(stderr, "Request Sent\n"); dbus_message_unref(msg); msg = NULL; dbus_pending_call_block(pending); msg = dbus_pending_call_steal_reply(pending); if(!msg) { fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: dbus_pending_call_steal_reply failed\n"); dbus_pending_call_unref(pending); dbus_message_unref(msg); return false; } dbus_pending_call_unref(pending); pending = NULL; DBusMessageIter resp_args; if(!dbus_message_iter_init(msg, &resp_args)) { fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: response message is missing arguments\n"); dbus_message_unref(msg); return false; } else if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&resp_args)) { const char *res = NULL; dbus_message_iter_get_basic(&resp_args, &res); } else if(DBUS_TYPE_UNIX_FD == dbus_message_iter_get_arg_type(&resp_args)) { int fd = -1; dbus_message_iter_get_basic(&resp_args, &fd); if(resp_fd) *resp_fd = fd; } else if(DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&resp_args)) { char *err = NULL; dbus_message_iter_get_basic(&resp_args, &err); fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: failed with error: %s\n", err); dbus_message_unref(msg); return false; // TODO: Check dbus_error_is_set? } else { fprintf(stderr, "gsr error: gsr_dbus_call_screencast_method: response message is not an object path or unix fd\n"); dbus_message_unref(msg); return false; // TODO: Check dbus_error_is_set? } dbus_message_unref(msg); if(!response_msg) return true; /* TODO: Add timeout, but take into consideration user interactive signals (such as selecting a monitor to capture for ScreenCast) */ for (;;) { const int timeout_milliseconds = 10; dbus_connection_read_write(self->con, timeout_milliseconds); *response_msg = dbus_connection_pop_message(self->con); if(!*response_msg) continue; if(!dbus_message_is_signal(*response_msg, "org.freedesktop.portal.Request", "Response")) { dbus_message_unref(*response_msg); *response_msg = NULL; continue; } break; } return true; } static int gsr_dbus_get_response_status(DBusMessageIter *resp_args) { if(dbus_message_iter_get_arg_type(resp_args) != DBUS_TYPE_UINT32) { fprintf(stderr, "gsr error: gsr_dbus_get_response_status: missing uint32 in response\n"); return -1; } dbus_uint32_t response_status = 0; dbus_message_iter_get_basic(resp_args, &response_status); dbus_message_iter_next(resp_args); return (int)response_status; } static dict_entry* find_dict_entry_by_key(dict_entry *entries, int num_entries, const char *key) { for(int i = 0; i < num_entries; ++i) { if(strcmp(entries[i].key, key) == 0) return &entries[i]; } return NULL; } static bool gsr_dbus_get_variant_value(DBusMessageIter *iter, dict_entry *entry) { if(dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT) { fprintf(stderr, "gsr error: gsr_dbus_get_variant_value: value is not a variant\n"); return false; } DBusMessageIter variant_iter; dbus_message_iter_recurse(iter, &variant_iter); switch(dbus_message_iter_get_arg_type(&variant_iter)) { case DBUS_TYPE_STRING: { if(entry->value_type != DICT_TYPE_STRING) { fprintf(stderr, "gsr error: gsr_dbus_get_variant_value: expected entry value to be a(n) %s was a string\n", dict_value_type_to_string(entry->value_type)); return false; } const char *value = NULL; dbus_message_iter_get_basic(&variant_iter, &value); if(!value) { fprintf(stderr, "gsr error: gsr_dbus_get_variant_value: failed to get entry value as value\n"); return false; } if(entry->str) { free(entry->str); entry->str = NULL; } entry->str = strdup(value); if(!entry->str) { fprintf(stderr, "gsr error: gsr_dbus_get_variant_value: failed to copy value\n"); return false; } return true; } case DBUS_TYPE_UINT32: { if(entry->value_type != DICT_TYPE_UINT32) { fprintf(stderr, "gsr error: gsr_dbus_get_variant_value: expected entry value to be a(n) %s was an uint32\n", dict_value_type_to_string(entry->value_type)); return false; } dbus_message_iter_get_basic(&variant_iter, &entry->u32); return true; } case DBUS_TYPE_BOOLEAN: { if(entry->value_type != DICT_TYPE_BOOL) { fprintf(stderr, "gsr error: gsr_dbus_get_variant_value: expected entry value to be a(n) %s was a boolean\n", dict_value_type_to_string(entry->value_type)); return false; } dbus_message_iter_get_basic(&variant_iter, &entry->boolean); return true; } } fprintf(stderr, "gsr error: gsr_dbus_get_variant_value: got unexpected type, expected string, uint32 or boolean\n"); return false; } /* Parses a{sv} into matching key entries in |entries|. If the entry value is a string then it's allocated with malloc and is null-terminated and has to be free by the caller. The entry values should be 0 before this method is called. The entries are free'd if this function fails. */ static bool gsr_dbus_get_map(DBusMessageIter *resp_args, dict_entry *entries, int num_entries) { if(dbus_message_iter_get_arg_type(resp_args) != DBUS_TYPE_ARRAY) { fprintf(stderr, "gsr error: gsr_dbus_get_map: missing array in response\n"); return false; } DBusMessageIter subiter; dbus_message_iter_recurse(resp_args, &subiter); while(dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_INVALID) { DBusMessageIter dictiter = DBUS_MESSAGE_ITER_INIT_CLOSED; const char *key = NULL; dict_entry *entry = NULL; // fprintf(stderr, " array element type: %c, %s\n", // dbus_message_iter_get_arg_type(&subiter), // dbus_message_iter_get_signature(&subiter)); if(dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_DICT_ENTRY) { fprintf(stderr, "gsr error: gsr_dbus_get_map: array value is not an entry\n"); return false; } dbus_message_iter_recurse(&subiter, &dictiter); if(dbus_message_iter_get_arg_type(&dictiter) != DBUS_TYPE_STRING) { fprintf(stderr, "gsr error: gsr_dbus_get_map: entry key is not a string\n"); goto error; } dbus_message_iter_get_basic(&dictiter, &key); if(!key) { fprintf(stderr, "gsr error: gsr_dbus_get_map: failed to get entry key as value\n"); goto error; } entry = find_dict_entry_by_key(entries, num_entries, key); if(!entry) { dbus_message_iter_next(&subiter); continue; } if(!dbus_message_iter_next(&dictiter)) { fprintf(stderr, "gsr error: gsr_dbus_get_map: missing entry value\n"); goto error; } if(!gsr_dbus_get_variant_value(&dictiter, entry)) goto error; dbus_message_iter_next(&subiter); } return true; error: for(int i = 0; i < num_entries; ++i) { if(entries[i].value_type == DICT_TYPE_STRING) { free(entries[i].str); entries[i].str = NULL; } } return false; } int gsr_dbus_screencast_create_session(gsr_dbus *self, char **session_handle) { assert(session_handle); *session_handle = NULL; char handle_token[64]; gsr_dbus_portal_get_unique_handle_token(self, handle_token, sizeof(handle_token)); char session_handle_token[64]; gsr_dbus_portal_get_unique_session_token(self, session_handle_token, sizeof(session_handle_token)); dict_entry args[2]; args[0].key = "handle_token"; args[0].value_type = DICT_TYPE_STRING; args[0].str = handle_token; args[1].key = "session_handle_token"; args[1].value_type = DICT_TYPE_STRING; args[1].str = session_handle_token; DBusMessage *response_msg = NULL; if(!gsr_dbus_call_screencast_method(self, "CreateSession", NULL, NULL, args, 2, NULL, &response_msg)) { fprintf(stderr, "gsr error: gsr_dbus_screencast_create_session: failed to setup ScreenCast session. Make sure you have a desktop portal running with support for the ScreenCast interface and that the desktop portal matches the Wayland compositor you are running.\n"); return -1; } // TODO: Verify signal path matches |res|, maybe check the below // DBUS_TYPE_ARRAY value? //fprintf(stderr, "signature: %s, sender: %s\n", dbus_message_get_signature(msg), dbus_message_get_sender(msg)); DBusMessageIter resp_args; if(!dbus_message_iter_init(response_msg, &resp_args)) { fprintf(stderr, "gsr error: gsr_dbus_screencast_create_session: missing response\n"); dbus_message_unref(response_msg); return -1; } const int response_status = gsr_dbus_get_response_status(&resp_args); if(response_status != 0) { dbus_message_unref(response_msg); return response_status; } dict_entry entries[1]; entries[0].key = "session_handle"; entries[0].str = NULL; entries[0].value_type = DICT_TYPE_STRING; if(!gsr_dbus_get_map(&resp_args, entries, 1)) { dbus_message_unref(response_msg); return -1; } if(!entries[0].str) { fprintf(stderr, "gsr error: gsr_dbus_screencast_create_session: missing \"session_handle\" in response\n"); dbus_message_unref(response_msg); return -1; } *session_handle = entries[0].str; //fprintf(stderr, "session handle: |%s|\n", entries[0].str); //free(entries[0].str); dbus_message_unref(response_msg); return 0; } static uint32_t unset_unsupported_capture_types(uint32_t requested_capture_types, uint32_t available_capture_types) { if(!(available_capture_types & GSR_PORTAL_CAPTURE_TYPE_MONITOR)) requested_capture_types &= ~GSR_PORTAL_CAPTURE_TYPE_MONITOR; if(!(available_capture_types & GSR_PORTAL_CAPTURE_TYPE_WINDOW)) requested_capture_types &= ~GSR_PORTAL_CAPTURE_TYPE_WINDOW; if(!(available_capture_types & GSR_PORTAL_CAPTURE_TYPE_VIRTUAL)) requested_capture_types &= ~GSR_PORTAL_CAPTURE_TYPE_VIRTUAL; return requested_capture_types; } static uint32_t unset_unsupported_cursor_modes(uint32_t requested_cursor_modes, uint32_t available_cursor_modes) { if(!(available_cursor_modes & GSR_PORTAL_CURSOR_MODE_HIDDEN)) requested_cursor_modes &= ~GSR_PORTAL_CURSOR_MODE_HIDDEN; if(!(available_cursor_modes & GSR_PORTAL_CURSOR_MODE_EMBEDDED)) requested_cursor_modes &= ~GSR_PORTAL_CURSOR_MODE_EMBEDDED; if(!(available_cursor_modes & GSR_PORTAL_CURSOR_MODE_METADATA)) requested_cursor_modes &= ~GSR_PORTAL_CURSOR_MODE_METADATA; return requested_cursor_modes; } int gsr_dbus_screencast_select_sources(gsr_dbus *self, const char *session_handle, uint32_t capture_type, uint32_t cursor_mode) { assert(session_handle); uint32_t available_source_types = 0; gsr_dbus_desktop_portal_get_property(self, "org.freedesktop.portal.ScreenCast", "AvailableSourceTypes", &available_source_types); if(available_source_types == 0) fprintf(stderr, "gsr error: gsr_dbus_screencast_select_sources: no source types are available\n"); capture_type = unset_unsupported_capture_types(capture_type, available_source_types); uint32_t available_cursor_modes = 0; gsr_dbus_desktop_portal_get_property(self, "org.freedesktop.portal.ScreenCast", "AvailableCursorModes", &available_cursor_modes); if(available_cursor_modes == 0) fprintf(stderr, "gsr error: gsr_dbus_screencast_select_sources: no cursors modes are available\n"); cursor_mode = unset_unsupported_cursor_modes(cursor_mode, available_cursor_modes); char handle_token[64]; gsr_dbus_portal_get_unique_handle_token(self, handle_token, sizeof(handle_token)); int num_arg_dict = 4; dict_entry args[6]; args[0].key = "types"; args[0].value_type = DICT_TYPE_UINT32; args[0].u32 = capture_type; args[1].key = "multiple"; args[1].value_type = DICT_TYPE_BOOL; args[1].boolean = false; /* TODO: Wayland ignores this and still gives the option to select multiple sources. Support that case.. */ args[2].key = "handle_token"; args[2].value_type = DICT_TYPE_STRING; args[2].str = handle_token; args[3].key = "cursor_mode"; args[3].value_type = DICT_TYPE_UINT32; args[3].u32 = cursor_mode; const int screencast_server_version = gsr_dbus_get_screencast_version_cached(self); if(screencast_server_version >= 4) { num_arg_dict = 5; args[4].key = "persist_mode"; args[4].value_type = DICT_TYPE_UINT32; args[4].u32 = 2; /* persist until explicitly revoked */ if(self->screencast_restore_token && self->screencast_restore_token[0]) { num_arg_dict = 6; args[5].key = "restore_token"; args[5].value_type = DICT_TYPE_STRING; args[5].str = self->screencast_restore_token; } } else if(self->screencast_restore_token && self->screencast_restore_token[0]) { fprintf(stderr, "gsr warning: gsr_dbus_screencast_select_sources: tried to use restore token but this option is only available in screencast version >= 4, your wayland compositors screencast version is %d\n", screencast_server_version); } DBusMessage *response_msg = NULL; if(!gsr_dbus_call_screencast_method(self, "SelectSources", session_handle, NULL, args, num_arg_dict, NULL, &response_msg)) { if(num_arg_dict == 6) { /* We dont know what the error exactly is but assume it may be because of invalid restore token. In that case try without restore token */ fprintf(stderr, "gsr warning: gsr_dbus_screencast_select_sources: SelectSources failed, retrying without restore_token\n"); num_arg_dict = 5; if(!gsr_dbus_call_screencast_method(self, "SelectSources", session_handle, NULL, args, num_arg_dict, NULL, &response_msg)) return -1; } else { return -1; } } // TODO: Verify signal path matches |res|, maybe check the below //fprintf(stderr, "signature: %s, sender: %s\n", dbus_message_get_signature(msg), dbus_message_get_sender(msg)); DBusMessageIter resp_args; if(!dbus_message_iter_init(response_msg, &resp_args)) { fprintf(stderr, "gsr error: gsr_dbus_screencast_create_session: missing response\n"); dbus_message_unref(response_msg); return -1; } const int response_status = gsr_dbus_get_response_status(&resp_args); if(response_status != 0) { dbus_message_unref(response_msg); return response_status; } dbus_message_unref(response_msg); return 0; } static dbus_uint32_t screencast_stream_get_pipewire_node(DBusMessageIter *iter) { DBusMessageIter subiter; dbus_message_iter_recurse(iter, &subiter); if(dbus_message_iter_get_arg_type(&subiter) == DBUS_TYPE_STRUCT) { DBusMessageIter structiter; dbus_message_iter_recurse(&subiter, &structiter); if(dbus_message_iter_get_arg_type(&structiter) == DBUS_TYPE_UINT32) { dbus_uint32_t data = 0; dbus_message_iter_get_basic(&structiter, &data); return data; } } return 0; } int gsr_dbus_screencast_start(gsr_dbus *self, const char *session_handle, uint32_t *pipewire_node) { assert(session_handle); *pipewire_node = 0; char handle_token[64]; gsr_dbus_portal_get_unique_handle_token(self, handle_token, sizeof(handle_token)); dict_entry args[1]; args[0].key = "handle_token"; args[0].value_type = DICT_TYPE_STRING; args[0].str = handle_token; DBusMessage *response_msg = NULL; if(!gsr_dbus_call_screencast_method(self, "Start", session_handle, "", args, 1, NULL, &response_msg)) return -1; // TODO: Verify signal path matches |res|, maybe check the below //fprintf(stderr, "signature: %s, sender: %s\n", dbus_message_get_signature(msg), dbus_message_get_sender(msg)); DBusMessageIter resp_args; if(!dbus_message_iter_init(response_msg, &resp_args)) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: missing response\n"); dbus_message_unref(response_msg); return -1; } const int response_status = gsr_dbus_get_response_status(&resp_args); if(response_status != 0) { dbus_message_unref(response_msg); return response_status; } if(dbus_message_iter_get_arg_type(&resp_args) != DBUS_TYPE_ARRAY) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: missing array in response\n"); dbus_message_unref(response_msg); return -1; } DBusMessageIter subiter; dbus_message_iter_recurse(&resp_args, &subiter); while(dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_INVALID) { DBusMessageIter dictiter = DBUS_MESSAGE_ITER_INIT_CLOSED; const char *key = NULL; // fprintf(stderr, " array element type: %c, %s\n", // dbus_message_iter_get_arg_type(&subiter), // dbus_message_iter_get_signature(&subiter)); if(dbus_message_iter_get_arg_type(&subiter) != DBUS_TYPE_DICT_ENTRY) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: array value is not an entry\n"); goto error; } dbus_message_iter_recurse(&subiter, &dictiter); if(dbus_message_iter_get_arg_type(&dictiter) != DBUS_TYPE_STRING) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: entry key is not a string\n"); goto error; } dbus_message_iter_get_basic(&dictiter, &key); if(!key) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: failed to get entry key as value\n"); goto error; } if(strcmp(key, "restore_token") == 0) { if(!dbus_message_iter_next(&dictiter)) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: missing restore_token value\n"); goto error; } if(dbus_message_iter_get_arg_type(&dictiter) != DBUS_TYPE_VARIANT) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: restore_token is not a variant\n"); goto error; } DBusMessageIter variant_iter; dbus_message_iter_recurse(&dictiter, &variant_iter); if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_STRING) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: restore_token is not a string\n"); goto error; } char *restore_token_str = NULL; dbus_message_iter_get_basic(&variant_iter, &restore_token_str); if(restore_token_str) { if(self->screencast_restore_token) { free(self->screencast_restore_token); self->screencast_restore_token = NULL; } self->screencast_restore_token = strdup(restore_token_str); //fprintf(stderr, "got restore token: %s\n", self->screencast_restore_token); } } else if(strcmp(key, "streams") == 0) { if(!dbus_message_iter_next(&dictiter)) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: missing streams value\n"); goto error; } if(dbus_message_iter_get_arg_type(&dictiter) != DBUS_TYPE_VARIANT) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: streams value is not a variant\n"); goto error; } DBusMessageIter variant_iter; dbus_message_iter_recurse(&dictiter, &variant_iter); if(dbus_message_iter_get_arg_type(&variant_iter) != DBUS_TYPE_ARRAY) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: streams value is not an array\n"); goto error; } int num_streams = dbus_message_iter_get_element_count(&variant_iter); //fprintf(stderr, "num streams: %d\n", num_streams); /* Skip over all streams except the last one, since kde can return multiple streams even if only 1 is requested. The last one is the valid one */ for(int i = 0; i < num_streams - 1; ++i) { screencast_stream_get_pipewire_node(&variant_iter); } if(num_streams > 0) { *pipewire_node = screencast_stream_get_pipewire_node(&variant_iter); //fprintf(stderr, "pipewire node: %u\n", *pipewire_node); } } dbus_message_iter_next(&subiter); } if(*pipewire_node == 0) { fprintf(stderr, "gsr error: gsr_dbus_screencast_start: no pipewire node returned\n"); goto error; } dbus_message_unref(response_msg); return 0; error: dbus_message_unref(response_msg); return -1; } bool gsr_dbus_screencast_open_pipewire_remote(gsr_dbus *self, const char *session_handle, int *pipewire_fd) { assert(session_handle); *pipewire_fd = -1; return gsr_dbus_call_screencast_method(self, "OpenPipeWireRemote", session_handle, NULL, NULL, 0, pipewire_fd, NULL); } const char* gsr_dbus_screencast_get_restore_token(gsr_dbus *self) { return self->screencast_restore_token; } fsdsfdsfdsfdsf-5.13.8/src/defs.c000066400000000000000000000102321520215207700164570ustar00rootroot00000000000000#include "../include/defs.h" #include bool video_codec_is_hdr(gsr_video_codec video_codec) { switch(video_codec) { case GSR_VIDEO_CODEC_HEVC_HDR: case GSR_VIDEO_CODEC_AV1_HDR: case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: return true; default: return false; } } gsr_video_codec hdr_video_codec_to_sdr_video_codec(gsr_video_codec video_codec) { switch(video_codec) { case GSR_VIDEO_CODEC_HEVC_HDR: return GSR_VIDEO_CODEC_HEVC; case GSR_VIDEO_CODEC_AV1_HDR: return GSR_VIDEO_CODEC_AV1; case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: return GSR_VIDEO_CODEC_HEVC_VULKAN; case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: return GSR_VIDEO_CODEC_AV1_VULKAN; default: return video_codec; } } gsr_color_depth video_codec_to_bit_depth(gsr_video_codec video_codec) { switch(video_codec) { case GSR_VIDEO_CODEC_HEVC_HDR: case GSR_VIDEO_CODEC_HEVC_10BIT: case GSR_VIDEO_CODEC_AV1_HDR: case GSR_VIDEO_CODEC_AV1_10BIT: case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: return GSR_COLOR_DEPTH_10_BITS; default: return GSR_COLOR_DEPTH_8_BITS; } } const char* video_codec_to_string(gsr_video_codec video_codec) { switch(video_codec) { case GSR_VIDEO_CODEC_H264: return "h264"; case GSR_VIDEO_CODEC_HEVC: return "hevc"; case GSR_VIDEO_CODEC_HEVC_HDR: return "hevc_hdr"; case GSR_VIDEO_CODEC_HEVC_10BIT: return "hevc_10bit"; case GSR_VIDEO_CODEC_AV1: return "av1"; case GSR_VIDEO_CODEC_AV1_HDR: return "av1_hdr"; case GSR_VIDEO_CODEC_AV1_10BIT: return "av1_10bit"; case GSR_VIDEO_CODEC_VP8: return "vp8"; case GSR_VIDEO_CODEC_VP9: return "vp9"; case GSR_VIDEO_CODEC_H264_VULKAN: return "h264_vulkan"; case GSR_VIDEO_CODEC_HEVC_VULKAN: return "hevc_vulkan"; case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: return "hevc_hdr_vulkan"; case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: return "hevc_10bit_vulkan"; case GSR_VIDEO_CODEC_AV1_VULKAN: return "av1_vulkan"; case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: return "av1_hdr_vulkan"; case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: return "av1_10bit_vulkan"; } return ""; } // bool video_codec_is_hevc(gsr_video_codec video_codec) { // switch(video_codec) { // case GSR_VIDEO_CODEC_HEVC: // case GSR_VIDEO_CODEC_HEVC_HDR: // case GSR_VIDEO_CODEC_HEVC_10BIT: // case GSR_VIDEO_CODEC_HEVC_VULKAN: // case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: // case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: // return true; // default: // return false; // } // } bool video_codec_is_av1(gsr_video_codec video_codec) { switch(video_codec) { case GSR_VIDEO_CODEC_AV1: case GSR_VIDEO_CODEC_AV1_HDR: case GSR_VIDEO_CODEC_AV1_10BIT: case GSR_VIDEO_CODEC_AV1_VULKAN: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: return true; default: return false; } } bool video_codec_is_vulkan(gsr_video_codec video_codec) { switch(video_codec) { case GSR_VIDEO_CODEC_H264_VULKAN: case GSR_VIDEO_CODEC_HEVC_VULKAN: case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: case GSR_VIDEO_CODEC_AV1_VULKAN: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: return true; default: return false; } } const char* audio_codec_get_name(gsr_audio_codec audio_codec) { switch(audio_codec) { case GSR_AUDIO_CODEC_AAC: return "aac"; case GSR_AUDIO_CODEC_OPUS: return "opus"; case GSR_AUDIO_CODEC_FLAC: return "flac"; } assert(false); return ""; } fsdsfdsfdsfdsf-5.13.8/src/egl.c000066400000000000000000000530501520215207700163120ustar00rootroot00000000000000#include "../include/egl.h" #include "../include/window/window.h" #include "../include/library_loader.h" #include "../include/utils.h" #include #include #include #include #include #include // TODO: rename gsr_egl to something else since this includes both egl and glx and in the future maybe vulkan too #define GLX_DRAWABLE_TYPE 0x8010 #define GLX_RENDER_TYPE 0x8011 #define GLX_RGBA_BIT 0x00000001 #define GLX_WINDOW_BIT 0x00000001 #define GLX_PIXMAP_BIT 0x00000002 #define GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1 #define GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3 #define GLX_TEXTURE_2D_BIT_EXT 0x00000002 #define GLX_DOUBLEBUFFER 5 #define GLX_RED_SIZE 8 #define GLX_GREEN_SIZE 9 #define GLX_BLUE_SIZE 10 #define GLX_ALPHA_SIZE 11 #define GLX_DEPTH_SIZE 12 #define GLX_RGBA_TYPE 0x8014 // TODO: Create egl context without surface (in other words, x11/wayland agnostic, doesn't require x11/wayland dependency) static bool gsr_egl_create_window(gsr_egl *self, bool enable_debug) { EGLConfig ecfg; int32_t num_config = 0; const int32_t attr[] = { EGL_BUFFER_SIZE, 24, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES3_BIT, EGL_NONE, EGL_NONE }; int32_t ctxattr[] = { EGL_CONTEXT_CLIENT_VERSION, 3, EGL_NONE, EGL_NONE, EGL_NONE }; if(enable_debug) { ctxattr[2] = EGL_CONTEXT_OPENGL_DEBUG; ctxattr[3] = EGL_TRUE; } self->eglBindAPI(EGL_OPENGL_ES_API); self->egl_display = self->eglGetDisplay((EGLNativeDisplayType)gsr_window_get_display(self->window)); if(!self->egl_display) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: eglGetDisplay failed\n"); goto fail; } if(!self->eglInitialize(self->egl_display, NULL, NULL)) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: eglInitialize failed\n"); goto fail; } if(!self->eglChooseConfig(self->egl_display, attr, &ecfg, 1, &num_config) || num_config != 1) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: failed to find a matching config\n"); goto fail; } self->egl_context = self->eglCreateContext(self->egl_display, ecfg, NULL, ctxattr); if(!self->egl_context) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: failed to create egl context\n"); goto fail; } self->egl_surface = self->eglCreateWindowSurface(self->egl_display, ecfg, (EGLNativeWindowType)gsr_window_get_window(self->window), NULL); if(!self->egl_surface) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: failed to create window surface\n"); goto fail; } if(!self->eglMakeCurrent(self->egl_display, self->egl_surface, self->egl_surface, self->egl_context)) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: failed to make egl context current\n"); goto fail; } return true; fail: gsr_egl_unload(self); return false; } static GLXFBConfig glx_fb_config_choose(gsr_egl *self, Display *display) { // TODO: OpenGL debug context? const int glx_visual_attribs[] = { GLX_RENDER_TYPE, GLX_RGBA_BIT, GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, // TODO: //GLX_BIND_TO_TEXTURE_RGBA_EXT, 1, //GLX_BIND_TO_TEXTURE_TARGETS_EXT, GLX_TEXTURE_2D_BIT_EXT, GLX_DOUBLEBUFFER, True, GLX_RED_SIZE, 8, GLX_GREEN_SIZE, 8, GLX_BLUE_SIZE, 8, GLX_ALPHA_SIZE, 0, GLX_DEPTH_SIZE, 0, None, None }; // TODO: Cleanup int c = 0; GLXFBConfig *fb_configs = self->glXChooseFBConfig(display, DefaultScreen(display), glx_visual_attribs, &c); if(c == 0 || !fb_configs) return NULL; return fb_configs[0]; } static bool gsr_egl_switch_to_glx_context(gsr_egl *self) { // TODO: Cleanup assert(gsr_window_get_display_server(self->window) == GSR_DISPLAY_SERVER_X11); Display *display = gsr_window_get_display(self->window); const Window window = (Window)gsr_window_get_window(self->window); if(self->egl_context) { self->eglMakeCurrent(self->egl_display, NULL, NULL, NULL); self->eglDestroyContext(self->egl_display, self->egl_context); self->egl_context = NULL; } if(self->egl_surface) { self->eglDestroySurface(self->egl_display, self->egl_surface); self->egl_surface = NULL; } if(self->egl_display) { self->eglTerminate(self->egl_display); self->egl_display = NULL; } self->glx_fb_config = glx_fb_config_choose(self, display); if(!self->glx_fb_config) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: failed to find a suitable fb config\n"); goto fail; } // TODO: //self->glx_context = self->glXCreateContextAttribsARB(display, self->glx_fb_config, NULL, True, context_attrib_list); self->glx_context = self->glXCreateNewContext(display, self->glx_fb_config, GLX_RGBA_TYPE, NULL, True); if(!self->glx_context) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: failed to create glx context\n"); goto fail; } if(!self->glXMakeContextCurrent(display, window, window, self->glx_context)) { fprintf(stderr, "gsr error: gsr_egl_create_window failed: failed to make glx context current\n"); goto fail; } return true; fail: if(self->glx_context) { self->glXMakeContextCurrent(display, None, None, NULL); self->glXDestroyContext(display, self->glx_context); self->glx_context = NULL; self->glx_fb_config = NULL; } return false; } static bool gsr_egl_load_egl(gsr_egl *self, void *library) { const dlsym_assign required_dlsym[] = { { (void**)&self->eglGetError, "eglGetError" }, { (void**)&self->eglGetDisplay, "eglGetDisplay" }, { (void**)&self->eglInitialize, "eglInitialize" }, { (void**)&self->eglTerminate, "eglTerminate" }, { (void**)&self->eglChooseConfig, "eglChooseConfig" }, { (void**)&self->eglCreateWindowSurface, "eglCreateWindowSurface" }, { (void**)&self->eglCreateContext, "eglCreateContext" }, { (void**)&self->eglMakeCurrent, "eglMakeCurrent" }, { (void**)&self->eglCreateImage, "eglCreateImage" }, { (void**)&self->eglDestroyContext, "eglDestroyContext" }, { (void**)&self->eglDestroySurface, "eglDestroySurface" }, { (void**)&self->eglDestroyImage, "eglDestroyImage" }, { (void**)&self->eglSwapInterval, "eglSwapInterval" }, { (void**)&self->eglSwapBuffers, "eglSwapBuffers" }, { (void**)&self->eglBindAPI, "eglBindAPI" }, { (void**)&self->eglGetProcAddress, "eglGetProcAddress" }, { NULL, NULL } }; if(!dlsym_load_list(library, required_dlsym)) { fprintf(stderr, "gsr error: gsr_egl_load failed: missing required symbols in libEGL.so.1\n"); return false; } return true; } static bool gsr_egl_proc_load_egl(gsr_egl *self) { self->eglExportDMABUFImageQueryMESA = (FUNC_eglExportDMABUFImageQueryMESA)self->eglGetProcAddress("eglExportDMABUFImageQueryMESA"); self->eglExportDMABUFImageMESA = (FUNC_eglExportDMABUFImageMESA)self->eglGetProcAddress("eglExportDMABUFImageMESA"); self->glEGLImageTargetTexture2DOES = (FUNC_glEGLImageTargetTexture2DOES)self->eglGetProcAddress("glEGLImageTargetTexture2DOES"); self->eglQueryDisplayAttribEXT = (FUNC_eglQueryDisplayAttribEXT)self->eglGetProcAddress("eglQueryDisplayAttribEXT"); self->eglQueryDeviceStringEXT = (FUNC_eglQueryDeviceStringEXT)self->eglGetProcAddress("eglQueryDeviceStringEXT"); self->eglQueryDmaBufModifiersEXT = (FUNC_eglQueryDmaBufModifiersEXT)self->eglGetProcAddress("eglQueryDmaBufModifiersEXT"); self->glCreateMemoryObjectsEXT = (FUNC_glCreateMemoryObjectsEXT)self->eglGetProcAddress("glCreateMemoryObjectsEXT"); self->glImportMemoryFdEXT = (FUNC_glImportMemoryFdEXT)self->eglGetProcAddress("glImportMemoryFdEXT"); self->glIsMemoryObjectEXT = (FUNC_glIsMemoryObjectEXT)self->eglGetProcAddress("glIsMemoryObjectEXT"); self->glTexStorageMem2DEXT = (FUNC_glTexStorageMem2DEXT)self->eglGetProcAddress("glTexStorageMem2DEXT"); self->glBufferStorageMemEXT = (FUNC_glBufferStorageMemEXT)self->eglGetProcAddress("glBufferStorageMemEXT"); self->glNamedBufferStorageMemEXT = (FUNC_glNamedBufferStorageMemEXT)self->eglGetProcAddress("glNamedBufferStorageMemEXT"); self->glMemoryObjectParameterivEXT = (FUNC_glMemoryObjectParameterivEXT)self->eglGetProcAddress("glMemoryObjectParameterivEXT"); self->glGenSemaphoresEXT = (FUNC_glGenSemaphoresEXT)self->eglGetProcAddress("glGenSemaphoresEXT"); self->glImportSemaphoreFdEXT = (FUNC_glImportSemaphoreFdEXT)self->eglGetProcAddress("glImportSemaphoreFdEXT"); self->glSignalSemaphoreEXT = (FUNC_glSignalSemaphoreEXT)self->eglGetProcAddress("glSignalSemaphoreEXT"); if(!self->eglExportDMABUFImageQueryMESA) { fprintf(stderr, "gsr error: gsr_egl_load failed: could not find eglExportDMABUFImageQueryMESA\n"); return false; } if(!self->eglExportDMABUFImageMESA) { fprintf(stderr, "gsr error: gsr_egl_load failed: could not find eglExportDMABUFImageMESA\n"); return false; } if(!self->glEGLImageTargetTexture2DOES) { fprintf(stderr, "gsr error: gsr_egl_load failed: could not find glEGLImageTargetTexture2DOES\n"); return false; } return true; } static bool gsr_egl_load_glx(gsr_egl *self, void *library) { const dlsym_assign required_dlsym[] = { { (void**)&self->glXGetProcAddress, "glXGetProcAddress" }, { (void**)&self->glXChooseFBConfig, "glXChooseFBConfig" }, { (void**)&self->glXMakeContextCurrent, "glXMakeContextCurrent" }, { (void**)&self->glXCreateNewContext, "glXCreateNewContext" }, { (void**)&self->glXDestroyContext, "glXDestroyContext" }, { (void**)&self->glXSwapBuffers, "glXSwapBuffers" }, { NULL, NULL } }; if(!dlsym_load_list(library, required_dlsym)) { fprintf(stderr, "gsr error: gsr_egl_load failed: missing required symbols in libGLX.so.0\n"); return false; } self->glXCreateContextAttribsARB = (FUNC_glXCreateContextAttribsARB)self->glXGetProcAddress((const unsigned char*)"glXCreateContextAttribsARB"); if(!self->glXCreateContextAttribsARB) { fprintf(stderr, "gsr error: gsr_egl_load_glx failed: could not find glXCreateContextAttribsARB\n"); return false; } self->glXSwapIntervalEXT = (FUNC_glXSwapIntervalEXT)self->glXGetProcAddress((const unsigned char*)"glXSwapIntervalEXT"); self->glXSwapIntervalMESA = (FUNC_glXSwapIntervalMESA)self->glXGetProcAddress((const unsigned char*)"glXSwapIntervalMESA"); self->glXSwapIntervalSGI = (FUNC_glXSwapIntervalSGI)self->glXGetProcAddress((const unsigned char*)"glXSwapIntervalSGI"); return true; } static bool gsr_egl_load_gl(gsr_egl *self, void *library) { const dlsym_assign required_dlsym[] = { { (void**)&self->glGetError, "glGetError" }, { (void**)&self->glGetString, "glGetString" }, { (void**)&self->glFlush, "glFlush" }, { (void**)&self->glFinish, "glFinish" }, { (void**)&self->glClear, "glClear" }, { (void**)&self->glClearColor, "glClearColor" }, { (void**)&self->glGenTextures, "glGenTextures" }, { (void**)&self->glDeleteTextures, "glDeleteTextures" }, { (void**)&self->glActiveTexture, "glActiveTexture" }, { (void**)&self->glBindTexture, "glBindTexture" }, { (void**)&self->glBindImageTexture, "glBindImageTexture" }, { (void**)&self->glTexParameteri, "glTexParameteri" }, { (void**)&self->glTexParameteriv, "glTexParameteriv" }, { (void**)&self->glTexParameterfv, "glTexParameterfv" }, { (void**)&self->glTexImage2D, "glTexImage2D" }, { (void**)&self->glTexSubImage2D, "glTexSubImage2D" }, { (void**)&self->glTexStorage2D, "glTexStorage2D" }, { (void**)&self->glGetTexImage, "glGetTexImage" }, { (void**)&self->glGenFramebuffers, "glGenFramebuffers" }, { (void**)&self->glBindFramebuffer, "glBindFramebuffer" }, { (void**)&self->glDeleteFramebuffers, "glDeleteFramebuffers" }, { (void**)&self->glMemoryBarrier, "glMemoryBarrier" }, { (void**)&self->glViewport, "glViewport" }, { (void**)&self->glFramebufferTexture2D, "glFramebufferTexture2D" }, { (void**)&self->glDrawBuffers, "glDrawBuffers" }, { (void**)&self->glCheckFramebufferStatus, "glCheckFramebufferStatus" }, { (void**)&self->glBindBuffer, "glBindBuffer" }, { (void**)&self->glGenBuffers, "glGenBuffers" }, { (void**)&self->glBufferData, "glBufferData" }, { (void**)&self->glBufferSubData, "glBufferSubData" }, { (void**)&self->glDeleteBuffers, "glDeleteBuffers" }, { (void**)&self->glGenVertexArrays, "glGenVertexArrays" }, { (void**)&self->glBindVertexArray, "glBindVertexArray" }, { (void**)&self->glDeleteVertexArrays, "glDeleteVertexArrays" }, { (void**)&self->glCreateProgram, "glCreateProgram" }, { (void**)&self->glCreateShader, "glCreateShader" }, { (void**)&self->glAttachShader, "glAttachShader" }, { (void**)&self->glBindAttribLocation, "glBindAttribLocation" }, { (void**)&self->glCompileShader, "glCompileShader" }, { (void**)&self->glLinkProgram, "glLinkProgram" }, { (void**)&self->glShaderSource, "glShaderSource" }, { (void**)&self->glUseProgram, "glUseProgram" }, { (void**)&self->glGetProgramInfoLog, "glGetProgramInfoLog" }, { (void**)&self->glGetShaderiv, "glGetShaderiv" }, { (void**)&self->glGetShaderInfoLog, "glGetShaderInfoLog" }, { (void**)&self->glDeleteProgram, "glDeleteProgram" }, { (void**)&self->glDeleteShader, "glDeleteShader" }, { (void**)&self->glGetProgramiv, "glGetProgramiv" }, { (void**)&self->glVertexAttribPointer, "glVertexAttribPointer" }, { (void**)&self->glEnableVertexAttribArray, "glEnableVertexAttribArray" }, { (void**)&self->glDrawArrays, "glDrawArrays" }, { (void**)&self->glEnable, "glEnable" }, { (void**)&self->glDisable, "glDisable" }, { (void**)&self->glBlendFunc, "glBlendFunc" }, { (void**)&self->glPixelStorei, "glPixelStorei" }, { (void**)&self->glGetUniformLocation, "glGetUniformLocation" }, { (void**)&self->glUniform1f, "glUniform1f" }, { (void**)&self->glUniform2f, "glUniform2f" }, { (void**)&self->glUniform1i, "glUniform1i" }, { (void**)&self->glUniform2i, "glUniform2i" }, { (void**)&self->glUniformMatrix2fv, "glUniformMatrix2fv" }, { (void**)&self->glDebugMessageCallback, "glDebugMessageCallback" }, { (void**)&self->glScissor, "glScissor" }, { (void**)&self->glReadPixels, "glReadPixels" }, { (void**)&self->glMapBufferRange, "glMapBufferRange" }, { (void**)&self->glUnmapBuffer, "glUnmapBuffer" }, { (void**)&self->glGetIntegerv, "glGetIntegerv" }, { NULL, NULL } }; if(!dlsym_load_list(library, required_dlsym)) { fprintf(stderr, "gsr error: gsr_egl_load failed: missing required symbols in libGL.so.1\n"); return false; } return true; } #define GL_DEBUG_TYPE_ERROR 0x824C #define GL_DEBUG_SEVERITY_NOTIFICATION 0x826B static void debug_callback(unsigned int source, unsigned int type, unsigned int id, unsigned int severity, int length, const char* message, const void* userParam) { (void)source; (void)id; (void)length; (void)userParam; if(severity != GL_DEBUG_SEVERITY_NOTIFICATION) fprintf(stderr, "gsr info: gl callback: %s type = 0x%x, severity = 0x%x, message = %s\n", type == GL_DEBUG_TYPE_ERROR ? "** GL ERROR **" : "", type, severity, message); } /* TODO: check for glx swap control extension string (GLX_EXT_swap_control, etc) */ static void set_vertical_sync_enabled(gsr_egl *egl, int enabled) { int result = 0; if(egl->glXSwapIntervalEXT) { assert(gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11); Display *display = gsr_window_get_display(egl->window); const Window window = (Window)gsr_window_get_window(egl->window); egl->glXSwapIntervalEXT(display, window, enabled ? 1 : 0); } else if(egl->glXSwapIntervalMESA) { result = egl->glXSwapIntervalMESA(enabled ? 1 : 0); } else if(egl->glXSwapIntervalSGI) { result = egl->glXSwapIntervalSGI(enabled ? 1 : 0); } else { static int warned = 0; if (!warned) { warned = 1; fprintf(stderr, "gsr warning: setting vertical sync not supported\n"); } } if(result != 0) fprintf(stderr, "gsr warning: setting vertical sync failed\n"); } static void gsr_egl_disable_vsync(gsr_egl *self) { switch(self->context_type) { case GSR_GL_CONTEXT_TYPE_EGL: { self->eglSwapInterval(self->egl_display, 0); break; } case GSR_GL_CONTEXT_TYPE_GLX: { set_vertical_sync_enabled(self, 0); break; } } } bool gsr_egl_load(gsr_egl *self, gsr_window *window, bool is_monitor_capture, bool enable_debug) { memset(self, 0, sizeof(gsr_egl)); self->context_type = GSR_GL_CONTEXT_TYPE_EGL; self->window = window; dlerror(); /* clear */ self->egl_library = dlopen("libEGL.so.1", RTLD_LAZY); if(!self->egl_library) { fprintf(stderr, "gsr error: gsr_egl_load: failed to load libEGL.so.1, error: %s\n", dlerror()); goto fail; } self->glx_library = dlopen("libGLX.so.0", RTLD_LAZY); self->gl_library = dlopen("libGL.so.1", RTLD_LAZY); if(!self->gl_library) { fprintf(stderr, "gsr error: gsr_egl_load: failed to load libGL.so.1, error: %s\n", dlerror()); goto fail; } if(!gsr_egl_load_egl(self, self->egl_library)) goto fail; /* In some distros (alpine for example libGLX doesn't exist, but libGL can be used instead) */ if(!gsr_egl_load_glx(self, self->glx_library ? self->glx_library : self->gl_library)) goto fail; if(!gsr_egl_load_gl(self, self->gl_library)) goto fail; if(!gsr_egl_proc_load_egl(self)) goto fail; if(!gsr_egl_create_window(self, enable_debug)) goto fail; if(!gl_get_gpu_info(self, &self->gpu_info)) goto fail; if(self->eglQueryDisplayAttribEXT && self->eglQueryDeviceStringEXT) { intptr_t device = 0; if(self->eglQueryDisplayAttribEXT(self->egl_display, EGL_DEVICE_EXT, &device) && device) self->dri_card_path = self->eglQueryDeviceStringEXT((void*)device, EGL_DRM_DEVICE_FILE_EXT); } /* Nvfbc requires glx */ if(gsr_window_get_display_server(self->window) == GSR_DISPLAY_SERVER_X11 && is_monitor_capture && self->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) { self->context_type = GSR_GL_CONTEXT_TYPE_GLX; if(!gsr_egl_switch_to_glx_context(self)) goto fail; } if(enable_debug) { self->glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS); self->glDebugMessageCallback(debug_callback, NULL); } self->glEnable(GL_BLEND); self->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); self->glPixelStorei(GL_PACK_ALIGNMENT, 1); self->glPixelStorei(GL_UNPACK_ALIGNMENT, 1); gsr_egl_disable_vsync(self); if(self->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) { /* This fixes nvenc codecs unable to load on openSUSE tumbleweed because of a cuda error. Don't ask me why */ const bool inside_flatpak = getenv("FLATPAK_ID") != NULL; if(inside_flatpak) system("flatpak-spawn --host -- sh -c 'grep -q openSUSE /etc/os-release && nvidia-smi -f /dev/null'"); else system("sh -c 'grep -q openSUSE /etc/os-release && nvidia-smi -f /dev/null'"); } return true; fail: gsr_egl_unload(self); return false; } void gsr_egl_unload(gsr_egl *self) { if(self->egl_context) { self->eglMakeCurrent(self->egl_display, NULL, NULL, NULL); self->eglDestroyContext(self->egl_display, self->egl_context); self->egl_context = NULL; } if(self->egl_surface) { self->eglDestroySurface(self->egl_display, self->egl_surface); self->egl_surface = NULL; } if(self->egl_display) { self->eglTerminate(self->egl_display); self->egl_display = NULL; } if(self->glx_context) { assert(gsr_window_get_display_server(self->window) == GSR_DISPLAY_SERVER_X11); Display *display = gsr_window_get_display(self->window); self->glXMakeContextCurrent(display, None, None, NULL); self->glXDestroyContext(display, self->glx_context); self->glx_context = NULL; self->glx_fb_config = NULL; } if(self->egl_library) { dlclose(self->egl_library); self->egl_library = NULL; } if(self->glx_library) { dlclose(self->glx_library); self->glx_library = NULL; } if(self->gl_library) { dlclose(self->gl_library); self->gl_library = NULL; } memset(self, 0, sizeof(gsr_egl)); } void gsr_egl_swap_buffers(gsr_egl *self) { self->glFlush(); // TODO: Use the minimal barrier required self->glMemoryBarrier(GL_ALL_BARRIER_BITS); // GL_SHADER_IMAGE_ACCESS_BARRIER_BIT // TODO: This is needed on nvidia because the cursor can flicker otherwise. Find a better solution if(self->gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) self->glFinish(); } fsdsfdsfdsfdsf-5.13.8/src/encoder/000077500000000000000000000000001520215207700170135ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/src/encoder/encoder.c000066400000000000000000000250251520215207700206020ustar00rootroot00000000000000#include "../../include/encoder/encoder.h" #include "../../include/utils.h" #include #include #include #include #include #include #include #include static uint64_t clock_gettime_microseconds(clockid_t clock_id) { struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = 0; clock_gettime(clock_id, &ts); return (uint64_t)ts.tv_sec * 1000000ULL + (uint64_t)ts.tv_nsec / 1000ULL; } static void gsr_write_first_frame_timestamp_file(const char *filepath) { const uint64_t evdev_compatible_ts = clock_gettime_microseconds(CLOCK_MONOTONIC); const uint64_t unix_time_microsec = clock_gettime_microseconds(CLOCK_REALTIME); FILE *file = fopen(filepath, "w"); if(!file) { fprintf(stderr, "gsr warning: failed to open timestamp file '%s': %s\n", filepath, strerror(errno)); return; } fputs("monotonic_microsec\trealtime_microsec\n", file); fprintf(file, "%" PRIu64 "\t%" PRIu64 "\n", evdev_compatible_ts, unix_time_microsec); fclose(file); } bool gsr_encoder_init(gsr_encoder *self, gsr_replay_storage replay_storage, size_t replay_buffer_num_packets, double replay_buffer_time, const char *replay_directory) { memset(self, 0, sizeof(*self)); self->num_recording_destinations = 0; self->recording_destination_id_counter = 0; self->first_pts = -1; if(pthread_mutex_init(&self->file_write_mutex, NULL) != 0) { fprintf(stderr, "gsr error: gsr_encoder_init: failed to create mutex\n"); gsr_encoder_deinit(self); return false; } self->file_write_mutex_created = true; if(pthread_mutex_init(&self->replay_mutex, NULL) != 0) { fprintf(stderr, "gsr error: gsr_encoder_init: failed to create mutex\n"); gsr_encoder_deinit(self); return false; } self->replay_mutex_created = true; if(replay_buffer_num_packets > 0) { self->replay_buffer = gsr_replay_buffer_create(replay_storage, replay_directory, replay_buffer_time, replay_buffer_num_packets); if(!self->replay_buffer) { fprintf(stderr, "gsr error: gsr_encoder_init: failed to create replay buffer\n"); gsr_encoder_deinit(self); return false; } } return true; } void gsr_encoder_deinit(gsr_encoder *self) { if(self->file_write_mutex_created) pthread_mutex_lock(&self->file_write_mutex); for(size_t i = 0; i < self->num_recording_destinations; ++i) { free(self->recording_destinations[i].first_frame_ts_filepath); self->recording_destinations[i].first_frame_ts_filepath = NULL; self->recording_destinations[i].first_frame_ts_written = false; } if(self->file_write_mutex_created) pthread_mutex_unlock(&self->file_write_mutex); if(self->replay_buffer) { pthread_mutex_lock(&self->replay_mutex); gsr_replay_buffer_destroy(self->replay_buffer); self->replay_buffer = NULL; pthread_mutex_unlock(&self->replay_mutex); } if(self->file_write_mutex_created) { self->file_write_mutex_created = false; pthread_mutex_destroy(&self->file_write_mutex); } if(self->replay_mutex_created) { self->replay_mutex_created = false; pthread_mutex_destroy(&self->replay_mutex); } self->num_recording_destinations = 0; self->recording_destination_id_counter = 0; self->first_pts = -1; } void gsr_encoder_receive_packets(gsr_encoder *self, AVCodecContext *codec_context, int64_t pts, int stream_index) { for(;;) { AVPacket *av_packet = av_packet_alloc(); if(!av_packet) break; av_packet->data = NULL; av_packet->size = 0; int res = avcodec_receive_packet(codec_context, av_packet); if(res == 0) { // we have a packet, send the packet to the muxer if(self->first_pts == -1) self->first_pts = pts; av_packet->stream_index = stream_index; av_packet->pts = pts - self->first_pts; av_packet->dts = av_packet->pts; if(self->replay_buffer) { pthread_mutex_lock(&self->replay_mutex); const double time_now = clock_get_monotonic_seconds(); if(!gsr_replay_buffer_append(self->replay_buffer, av_packet, time_now)) fprintf(stderr, "gsr error: gsr_encoder_receive_packets: failed to add replay buffer data\n"); pthread_mutex_unlock(&self->replay_mutex); } pthread_mutex_lock(&self->file_write_mutex); const bool is_keyframe = av_packet->flags & AV_PKT_FLAG_KEY; for(size_t i = 0; i < self->num_recording_destinations; ++i) { gsr_encoder_recording_destination *recording_destination = &self->recording_destinations[i]; if(recording_destination->codec_context != codec_context) continue; if(is_keyframe) recording_destination->has_received_keyframe = true; else if(!recording_destination->has_received_keyframe) continue; if(recording_destination->first_frame_ts_filepath && !recording_destination->first_frame_ts_written) { gsr_write_first_frame_timestamp_file(recording_destination->first_frame_ts_filepath); recording_destination->first_frame_ts_written = true; } if(recording_destination->first_pts == -1) recording_destination->first_pts = pts - recording_destination->start_pts; av_packet->pts = pts - recording_destination->start_pts - recording_destination->first_pts; av_packet->dts = av_packet->pts; av_packet_rescale_ts(av_packet, codec_context->time_base, recording_destination->stream->time_base); // TODO: Is av_interleaved_write_frame needed?. Answer: might be needed for mkv but dont use it! it causes frames to be inconsistent, skipping frames and duplicating frames. // TODO: av_interleaved_write_frame might be needed for cfr, or always for flv const int ret = av_write_frame(recording_destination->format_context, av_packet); if(ret < 0) { char error_buffer[AV_ERROR_MAX_STRING_SIZE]; if(av_strerror(ret, error_buffer, sizeof(error_buffer)) < 0) snprintf(error_buffer, sizeof(error_buffer), "Unknown error"); fprintf(stderr, "gsr error: gsr_encoder_receive_packets: failed to write frame index %d to muxer, reason: %s (%d)\n", av_packet->stream_index, error_buffer, ret); } } pthread_mutex_unlock(&self->file_write_mutex); av_packet_free(&av_packet); } else if (res == AVERROR(EAGAIN)) { // we have no packet // fprintf(stderr, "No packet!\n"); av_packet_free(&av_packet); break; } else if (res == AVERROR_EOF) { // this is the end of the stream av_packet_free(&av_packet); fprintf(stderr, "End of stream!\n"); break; } else { av_packet_free(&av_packet); fprintf(stderr, "Unexpected error: %d\n", res); break; } } } size_t gsr_encoder_add_recording_destination(gsr_encoder *self, AVCodecContext *codec_context, AVFormatContext *format_context, AVStream *stream, int64_t start_pts) { if(self->num_recording_destinations >= GSR_MAX_RECORDING_DESTINATIONS) { fprintf(stderr, "gsr error: gsr_encoder_add_recording_destination: failed to add destination, reached the max amount of recording destinations (%d)\n", GSR_MAX_RECORDING_DESTINATIONS); return (size_t)-1; } for(size_t i = 0; i < self->num_recording_destinations; ++i) { if(self->recording_destinations[i].stream == stream) { fprintf(stderr, "gsr error: gsr_encoder_add_recording_destination: failed to add destination, the stream %p already exists as an output\n", (void*)stream); return (size_t)-1; } } pthread_mutex_lock(&self->file_write_mutex); gsr_encoder_recording_destination *recording_destination = &self->recording_destinations[self->num_recording_destinations]; recording_destination->id = self->recording_destination_id_counter; recording_destination->codec_context = codec_context; recording_destination->format_context = format_context; recording_destination->stream = stream; recording_destination->start_pts = start_pts; recording_destination->first_pts = -1; recording_destination->has_received_keyframe = false; recording_destination->first_frame_ts_filepath = NULL; recording_destination->first_frame_ts_written = false; ++self->recording_destination_id_counter; ++self->num_recording_destinations; pthread_mutex_unlock(&self->file_write_mutex); return recording_destination->id; } bool gsr_encoder_remove_recording_destination(gsr_encoder *self, size_t id) { bool found = false; pthread_mutex_lock(&self->file_write_mutex); for(size_t i = 0; i < self->num_recording_destinations; ++i) { if(self->recording_destinations[i].id == id) { free(self->recording_destinations[i].first_frame_ts_filepath); self->recording_destinations[i].first_frame_ts_filepath = NULL; self->recording_destinations[i].first_frame_ts_written = false; self->recording_destinations[i] = self->recording_destinations[self->num_recording_destinations - 1]; --self->num_recording_destinations; found = true; break; } } pthread_mutex_unlock(&self->file_write_mutex); return found; } bool gsr_encoder_set_recording_destination_first_frame_ts_filepath(gsr_encoder *self, size_t id, const char *filepath) { if(!filepath) return false; bool found = false; pthread_mutex_lock(&self->file_write_mutex); for(size_t i = 0; i < self->num_recording_destinations; ++i) { if(self->recording_destinations[i].id == id) { char *filepath_copy = strdup(filepath); if(!filepath_copy) break; free(self->recording_destinations[i].first_frame_ts_filepath); self->recording_destinations[i].first_frame_ts_filepath = filepath_copy; self->recording_destinations[i].first_frame_ts_written = false; found = true; break; } } pthread_mutex_unlock(&self->file_write_mutex); return found; } fsdsfdsfdsfdsf-5.13.8/src/encoder/video/000077500000000000000000000000001520215207700201215ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/src/encoder/video/nvenc.c000066400000000000000000000235171520215207700214060ustar00rootroot00000000000000#include "../../../include/encoder/video/nvenc.h" #include "../../../include/egl.h" #include "../../../include/cuda.h" #include "../../../include/utils.h" #include #include #include typedef struct { gsr_video_encoder_nvenc_params params; unsigned int target_textures[2]; vec2i target_texture_size[2]; AVBufferRef *device_ctx; gsr_cuda cuda; CUgraphicsResource cuda_graphics_resources[2]; CUarray mapped_arrays[2]; CUstream cuda_stream; } gsr_video_encoder_nvenc; static bool gsr_video_encoder_nvenc_setup_context(gsr_video_encoder_nvenc *self, AVCodecContext *video_codec_context) { self->device_ctx = av_hwdevice_ctx_alloc(AV_HWDEVICE_TYPE_CUDA); if(!self->device_ctx) { fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_context failed: failed to create hardware device context\n"); return false; } AVHWDeviceContext *hw_device_context = (AVHWDeviceContext*)self->device_ctx->data; AVCUDADeviceContext *cuda_device_context = (AVCUDADeviceContext*)hw_device_context->hwctx; cuda_device_context->cuda_ctx = self->cuda.cu_ctx; if(av_hwdevice_ctx_init(self->device_ctx) < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_context failed: failed to create hardware device context\n"); av_buffer_unref(&self->device_ctx); return false; } AVBufferRef *frame_context = av_hwframe_ctx_alloc(self->device_ctx); if(!frame_context) { fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_context failed: failed to create hwframe context\n"); av_buffer_unref(&self->device_ctx); return false; } AVHWFramesContext *hw_frame_context = (AVHWFramesContext*)frame_context->data; hw_frame_context->width = video_codec_context->width; hw_frame_context->height = video_codec_context->height; hw_frame_context->sw_format = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? AV_PIX_FMT_P010LE : AV_PIX_FMT_NV12; hw_frame_context->format = video_codec_context->pix_fmt; hw_frame_context->device_ctx = (AVHWDeviceContext*)self->device_ctx->data; if (av_hwframe_ctx_init(frame_context) < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_context failed: failed to initialize hardware frame context " "(note: ffmpeg version needs to be > 4.0)\n"); av_buffer_unref(&self->device_ctx); //av_buffer_unref(&frame_context); return false; } self->cuda_stream = cuda_device_context->stream; video_codec_context->hw_frames_ctx = av_buffer_ref(frame_context); av_buffer_unref(&frame_context); return true; } static bool cuda_register_opengl_texture(gsr_cuda *cuda, CUgraphicsResource *cuda_graphics_resource, CUarray *mapped_array, unsigned int texture_id) { CUresult res; res = cuda->cuGraphicsGLRegisterImage(cuda_graphics_resource, texture_id, GL_TEXTURE_2D, CU_GRAPHICS_REGISTER_FLAGS_NONE); if (res != CUDA_SUCCESS) { const char *err_str = "unknown"; cuda->cuGetErrorString(res, &err_str); fprintf(stderr, "gsr error: cuda_register_opengl_texture: cuGraphicsGLRegisterImage failed, error: %s, texture " "id: %u\n", err_str, texture_id); return false; } res = cuda->cuGraphicsResourceSetMapFlags(*cuda_graphics_resource, CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE); res = cuda->cuGraphicsMapResources(1, cuda_graphics_resource, 0); res = cuda->cuGraphicsSubResourceGetMappedArray(mapped_array, *cuda_graphics_resource, 0, 0); return true; } static bool gsr_video_encoder_nvenc_setup_textures(gsr_video_encoder_nvenc *self, AVCodecContext *video_codec_context, AVFrame *frame) { const int res = av_hwframe_get_buffer(video_codec_context->hw_frames_ctx, frame, 0); if(res < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_textures: av_hwframe_get_buffer failed: %d\n", res); return false; } const unsigned int internal_formats_nv12[2] = { GL_R8, GL_RG8 }; const unsigned int internal_formats_p010[2] = { GL_R16, GL_RG16 }; const unsigned int formats[2] = { GL_RED, GL_RG }; const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size for(int i = 0; i < 2; ++i) { self->target_texture_size[i] = (vec2i){ video_codec_context->width / div[i], video_codec_context->height / div[i] }; self->target_textures[i] = gl_create_texture(self->params.egl, self->target_texture_size[i].x, self->target_texture_size[i].y, self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST); if(self->target_textures[i] == 0) { fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_setup_textures: failed to create opengl texture\n"); return false; } if(!cuda_register_opengl_texture(&self->cuda, &self->cuda_graphics_resources[i], &self->mapped_arrays[i], self->target_textures[i])) { return false; } } return true; } static void gsr_video_encoder_nvenc_stop(gsr_video_encoder_nvenc *self, AVCodecContext *video_codec_context); static bool gsr_video_encoder_nvenc_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) { gsr_video_encoder_nvenc *self = encoder->priv; if(!gsr_cuda_load(&self->cuda)) { fprintf(stderr, "gsr error: gsr_video_encoder_nvenc_start: failed to load cuda\n"); gsr_video_encoder_nvenc_stop(self, video_codec_context); return false; } video_codec_context->width = FFALIGN(video_codec_context->width, 2); video_codec_context->height = FFALIGN(video_codec_context->height, 2); if(video_codec_context->width < 128) video_codec_context->width = 128; if(video_codec_context->height < 128) video_codec_context->height = 128; frame->width = video_codec_context->width; frame->height = video_codec_context->height; if(!gsr_video_encoder_nvenc_setup_context(self, video_codec_context)) { gsr_video_encoder_nvenc_stop(self, video_codec_context); return false; } if(!gsr_video_encoder_nvenc_setup_textures(self, video_codec_context, frame)) { gsr_video_encoder_nvenc_stop(self, video_codec_context); return false; } return true; } void gsr_video_encoder_nvenc_stop(gsr_video_encoder_nvenc *self, AVCodecContext *video_codec_context) { self->params.egl->glDeleteTextures(2, self->target_textures); self->target_textures[0] = 0; self->target_textures[1] = 0; if(video_codec_context->hw_frames_ctx) av_buffer_unref(&video_codec_context->hw_frames_ctx); if(self->device_ctx) av_buffer_unref(&self->device_ctx); if(self->cuda.cu_ctx) { for(int i = 0; i < 2; ++i) { if(self->cuda_graphics_resources[i]) { self->cuda.cuGraphicsUnmapResources(1, &self->cuda_graphics_resources[i], 0); self->cuda.cuGraphicsUnregisterResource(self->cuda_graphics_resources[i]); self->cuda_graphics_resources[i] = 0; } } } gsr_cuda_unload(&self->cuda); } static void gsr_video_encoder_nvenc_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) { gsr_video_encoder_nvenc *self = encoder->priv; const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size for(int i = 0; i < 2; ++i) { CUDA_MEMCPY2D memcpy_struct; memcpy_struct.srcXInBytes = 0; memcpy_struct.srcY = 0; memcpy_struct.srcMemoryType = CU_MEMORYTYPE_ARRAY; memcpy_struct.dstXInBytes = 0; memcpy_struct.dstY = 0; memcpy_struct.dstMemoryType = CU_MEMORYTYPE_DEVICE; memcpy_struct.srcArray = self->mapped_arrays[i]; memcpy_struct.srcPitch = frame->width / div[i]; memcpy_struct.dstDevice = (CUdeviceptr)frame->data[i]; memcpy_struct.dstPitch = frame->linesize[i]; memcpy_struct.WidthInBytes = frame->width * (self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? 2 : 1); memcpy_struct.Height = frame->height / div[i]; // TODO: Remove this copy if possible self->cuda.cuMemcpy2DAsync_v2(&memcpy_struct, self->cuda_stream); } // TODO: needed? self->cuda.cuStreamSynchronize(self->cuda_stream); } static void gsr_video_encoder_nvenc_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) { gsr_video_encoder_nvenc *self = encoder->priv; textures[0] = self->target_textures[0]; textures[1] = self->target_textures[1]; texture_sizes[0] = self->target_texture_size[0]; texture_sizes[1] = self->target_texture_size[1]; *num_textures = 2; *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12; } static void gsr_video_encoder_nvenc_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context) { gsr_video_encoder_nvenc_stop(encoder->priv, video_codec_context); free(encoder->priv); free(encoder); } gsr_video_encoder* gsr_video_encoder_nvenc_create(const gsr_video_encoder_nvenc_params *params) { gsr_video_encoder *encoder = calloc(1, sizeof(gsr_video_encoder)); if(!encoder) return NULL; gsr_video_encoder_nvenc *encoder_cuda = calloc(1, sizeof(gsr_video_encoder_nvenc)); if(!encoder_cuda) { free(encoder); return NULL; } encoder_cuda->params = *params; *encoder = (gsr_video_encoder) { .start = gsr_video_encoder_nvenc_start, .copy_textures_to_frame = gsr_video_encoder_nvenc_copy_textures_to_frame, .get_textures = gsr_video_encoder_nvenc_get_textures, .destroy = gsr_video_encoder_nvenc_destroy, .priv = encoder_cuda }; return encoder; } fsdsfdsfdsfdsf-5.13.8/src/encoder/video/software.c000066400000000000000000000124061520215207700221220ustar00rootroot00000000000000#include "../../../include/encoder/video/software.h" #include "../../../include/egl.h" #include "../../../include/utils.h" #include #include #include #define LINESIZE_ALIGNMENT 4 typedef struct { gsr_video_encoder_software_params params; unsigned int target_textures[2]; vec2i texture_sizes[2]; } gsr_video_encoder_software; static bool gsr_video_encoder_software_setup_textures(gsr_video_encoder_software *self, AVCodecContext *video_codec_context, AVFrame *frame) { int res = av_frame_get_buffer(frame, LINESIZE_ALIGNMENT); if(res < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_software_setup_textures: av_frame_get_buffer failed: %d\n", res); return false; } res = av_frame_make_writable(frame); if(res < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_software_setup_textures: av_frame_make_writable failed: %d\n", res); return false; } const unsigned int internal_formats_nv12[2] = { GL_R8, GL_RG8 }; const unsigned int internal_formats_p010[2] = { GL_R16, GL_RG16 }; const unsigned int formats[2] = { GL_RED, GL_RG }; const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size for(int i = 0; i < 2; ++i) { self->texture_sizes[i] = (vec2i){ video_codec_context->width / div[i], video_codec_context->height / div[i] }; self->target_textures[i] = gl_create_texture(self->params.egl, self->texture_sizes[i].x, self->texture_sizes[i].y, self->params.color_depth == GSR_COLOR_DEPTH_8_BITS ? internal_formats_nv12[i] : internal_formats_p010[i], formats[i], GL_NEAREST); if(self->target_textures[i] == 0) { fprintf(stderr, "gsr error: gsr_capture_kms_setup_cuda_textures: failed to create opengl texture\n"); return false; } } return true; } static void gsr_video_encoder_software_stop(gsr_video_encoder_software *self, AVCodecContext *video_codec_context); static bool gsr_video_encoder_software_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) { gsr_video_encoder_software *self = encoder->priv; video_codec_context->width = FFALIGN(video_codec_context->width, LINESIZE_ALIGNMENT); video_codec_context->height = FFALIGN(video_codec_context->height, 2); frame->width = video_codec_context->width; frame->height = video_codec_context->height; if(!gsr_video_encoder_software_setup_textures(self, video_codec_context, frame)) { gsr_video_encoder_software_stop(self, video_codec_context); return false; } return true; } void gsr_video_encoder_software_stop(gsr_video_encoder_software *self, AVCodecContext *video_codec_context) { (void)video_codec_context; self->params.egl->glDeleteTextures(2, self->target_textures); self->target_textures[0] = 0; self->target_textures[1] = 0; } static void gsr_video_encoder_software_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) { (void)encoder; //gsr_video_encoder_software *self = encoder->priv; // TODO: hdr support const unsigned int formats[2] = { GL_RED, GL_RG }; const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size for(int i = 0; i < 2; ++i) { // TODO: Use glPixelStore? gsr_color_conversion_read_destination_texture(color_conversion, i, 0, 0, frame->width / div[i], frame->height / div[i], formats[i], GL_UNSIGNED_BYTE, frame->data[i]); } // cap_kms->kms.base.egl->eglSwapBuffers(cap_kms->kms.base.egl->egl_display, cap_kms->kms.base.egl->egl_surface); //self->params.egl->glFlush(); //self->params.egl->glFinish(); } static void gsr_video_encoder_software_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) { gsr_video_encoder_software *self = encoder->priv; textures[0] = self->target_textures[0]; textures[1] = self->target_textures[1]; texture_sizes[0] = self->texture_sizes[0]; texture_sizes[1] = self->texture_sizes[1]; *num_textures = 2; *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12; } static void gsr_video_encoder_software_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context) { gsr_video_encoder_software_stop(encoder->priv, video_codec_context); free(encoder->priv); free(encoder); } gsr_video_encoder* gsr_video_encoder_software_create(const gsr_video_encoder_software_params *params) { gsr_video_encoder *encoder = calloc(1, sizeof(gsr_video_encoder)); if(!encoder) return NULL; gsr_video_encoder_software *encoder_software = calloc(1, sizeof(gsr_video_encoder_software)); if(!encoder_software) { free(encoder); return NULL; } encoder_software->params = *params; *encoder = (gsr_video_encoder) { .start = gsr_video_encoder_software_start, .copy_textures_to_frame = gsr_video_encoder_software_copy_textures_to_frame, .get_textures = gsr_video_encoder_software_get_textures, .destroy = gsr_video_encoder_software_destroy, .priv = encoder_software }; return encoder; } fsdsfdsfdsfdsf-5.13.8/src/encoder/video/vaapi.c000066400000000000000000000360251520215207700213730ustar00rootroot00000000000000#include "../../../include/encoder/video/vaapi.h" #include "../../../include/utils.h" #include "../../../include/egl.h" #include #include #include #include #include #include #include #include #include typedef struct { gsr_video_encoder_vaapi_params params; unsigned int target_textures[2]; vec2i texture_sizes[2]; AVBufferRef *device_ctx; VADisplay va_dpy; VADRMPRIMESurfaceDescriptor prime; } gsr_video_encoder_vaapi; static bool gsr_video_encoder_vaapi_setup_context(gsr_video_encoder_vaapi *self, AVCodecContext *video_codec_context) { char render_path[128]; if(!gsr_card_path_get_render_path(self->params.egl->card_path, render_path)) { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_context: failed to get /dev/dri/renderDXXX file from %s\n", self->params.egl->card_path); return false; } if(av_hwdevice_ctx_create(&self->device_ctx, AV_HWDEVICE_TYPE_VAAPI, render_path, NULL, 0) < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_context: failed to create hardware device context\n"); return false; } AVBufferRef *frame_context = av_hwframe_ctx_alloc(self->device_ctx); if(!frame_context) { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_context: failed to create hwframe context\n"); av_buffer_unref(&self->device_ctx); return false; } AVHWFramesContext *hw_frame_context = (AVHWFramesContext*)frame_context->data; hw_frame_context->width = video_codec_context->width; hw_frame_context->height = video_codec_context->height; hw_frame_context->sw_format = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? AV_PIX_FMT_P010LE : AV_PIX_FMT_NV12; hw_frame_context->format = video_codec_context->pix_fmt; hw_frame_context->device_ctx = (AVHWDeviceContext*)self->device_ctx->data; //hw_frame_context->initial_pool_size = 20; AVVAAPIDeviceContext *vactx = ((AVHWDeviceContext*)self->device_ctx->data)->hwctx; self->va_dpy = vactx->display; if (av_hwframe_ctx_init(frame_context) < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_context: failed to initialize hardware frame context " "(note: ffmpeg version needs to be > 4.0)\n"); av_buffer_unref(&self->device_ctx); //av_buffer_unref(&frame_context); return false; } video_codec_context->hw_frames_ctx = av_buffer_ref(frame_context); av_buffer_unref(&frame_context); return true; } static uint32_t fourcc(uint32_t a, uint32_t b, uint32_t c, uint32_t d) { return (d << 24) | (c << 16) | (b << 8) | a; } static bool gsr_video_encoder_vaapi_setup_textures(gsr_video_encoder_vaapi *self, AVCodecContext *video_codec_context, AVFrame *frame) { const int res = av_hwframe_get_buffer(video_codec_context->hw_frames_ctx, frame, 0); if(res < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_textures: av_hwframe_get_buffer failed: %d\n", res); return false; } VASurfaceID target_surface_id = (uintptr_t)frame->data[3]; VAStatus va_status = vaExportSurfaceHandle(self->va_dpy, target_surface_id, VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2, VA_EXPORT_SURFACE_WRITE_ONLY | VA_EXPORT_SURFACE_SEPARATE_LAYERS, &self->prime); if(va_status != VA_STATUS_SUCCESS) { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_textures: vaExportSurfaceHandle failed, error: %d\n", va_status); return false; } vaSyncSurface(self->va_dpy, target_surface_id); const uint32_t formats_nv12[2] = { fourcc('R', '8', ' ', ' '), fourcc('G', 'R', '8', '8') }; const uint32_t formats_p010[2] = { fourcc('R', '1', '6', ' '), fourcc('G', 'R', '3', '2') }; if(self->prime.fourcc == VA_FOURCC_NV12 || self->prime.fourcc == VA_FOURCC_P010) { const uint32_t *formats = self->prime.fourcc == VA_FOURCC_NV12 ? formats_nv12 : formats_p010; const int div[2] = {1, 2}; // divide UV texture size by 2 because chroma is half size self->params.egl->glGenTextures(2, self->target_textures); for(int i = 0; i < 2; ++i) { const int layer = i; int fds[4]; uint32_t offsets[4]; uint32_t pitches[4]; uint64_t modifiers[4]; for(uint32_t j = 0; j < self->prime.layers[layer].num_planes; ++j) { // TODO: Close these? in _stop, using self->prime fds[j] = self->prime.objects[self->prime.layers[layer].object_index[j]].fd; offsets[j] = self->prime.layers[layer].offset[j]; pitches[j] = self->prime.layers[layer].pitch[j]; modifiers[j] = self->prime.objects[self->prime.layers[layer].object_index[j]].drm_format_modifier; } intptr_t img_attr[44]; setup_dma_buf_attrs(img_attr, formats[i], self->prime.width / div[i], self->prime.height / div[i], fds, offsets, pitches, modifiers, self->prime.layers[layer].num_planes, true); self->texture_sizes[i] = (vec2i){ self->prime.width / div[i], self->prime.height / div[i] }; while(self->params.egl->eglGetError() != EGL_SUCCESS){} EGLImage image = self->params.egl->eglCreateImage(self->params.egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, img_attr); if(!image) { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_textures: failed to create egl image from drm fd for output drm fd, error: %d\n", self->params.egl->eglGetError()); return false; } self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[i]); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); while(self->params.egl->glGetError()) {} while(self->params.egl->eglGetError() != EGL_SUCCESS){} self->params.egl->glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image); if(self->params.egl->glGetError() != 0 || self->params.egl->eglGetError() != EGL_SUCCESS) { // TODO: Get the error properly fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_textures: failed to bind egl image to gl texture, error: %d\n", self->params.egl->eglGetError()); self->params.egl->eglDestroyImage(self->params.egl->egl_display, image); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); return false; } self->params.egl->eglDestroyImage(self->params.egl->egl_display, image); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); } return true; } else { fprintf(stderr, "gsr error: gsr_video_encoder_vaapi_setup_textures: unexpected fourcc %u for output drm fd, expected nv12 or p010\n", self->prime.fourcc); return false; } } static void gsr_video_encoder_vaapi_stop(gsr_video_encoder_vaapi *self, AVCodecContext *video_codec_context); static bool supports_hevc_without_padding(const char *card_path) { #if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(61, 28, 100) && VA_CHECK_VERSION(1, 21, 0) VAStatus va_status; VAConfigID va_config = 0; unsigned int num_surface_attr = 0; VASurfaceAttrib *surface_attr_list = NULL; bool supports_surface_attrib_alignment_size = false; int va_major = 0; int va_minor = 0; bool initialized = false; char render_path[128]; if(!gsr_card_path_get_render_path(card_path, render_path)) { fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to get /dev/dri/renderDXXX file from %s\n", card_path); return false; } const int drm_fd = open(render_path, O_RDWR); if(drm_fd == -1) { fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to open device %s\n", render_path); return false; } const VADisplay va_dpy = vaGetDisplayDRM(drm_fd); if(!va_dpy) { fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to get vaapi display for device %s\n", render_path); goto done; } vaSetInfoCallback(va_dpy, NULL, NULL); if(vaInitialize(va_dpy, &va_major, &va_minor) != VA_STATUS_SUCCESS) { fprintf(stderr, "gsr error: supports_hevc_without_padding: vaInitialize failed\n"); goto done; } initialized = true; va_status = vaCreateConfig(va_dpy, VAProfileHEVCMain, VAEntrypointEncSlice, NULL, 0, &va_config); if(va_status != VA_STATUS_SUCCESS) { va_status = vaCreateConfig(va_dpy, VAProfileHEVCMain, VAEntrypointEncSliceLP, NULL, 0, &va_config); if(va_status != VA_STATUS_SUCCESS) { fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to create hevc vaapi config, error: %s (%d)\n", vaErrorStr(va_status), va_status); return false; } } va_status = vaQuerySurfaceAttributes(va_dpy, va_config, 0, &num_surface_attr); if(va_status != VA_STATUS_SUCCESS) { fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to query vaapi surface attributes size, error: %s (%d)\n", vaErrorStr(va_status), va_status); goto done; } surface_attr_list = malloc(num_surface_attr * sizeof(VASurfaceAttrib)); if(!surface_attr_list) { fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to allocate memory for %u vaapi surface attributes, error: %s (%d)\n", num_surface_attr, vaErrorStr(va_status), va_status); goto done; } va_status = vaQuerySurfaceAttributes(va_dpy, va_config, surface_attr_list, &num_surface_attr); if(va_status != VA_STATUS_SUCCESS) { fprintf(stderr, "gsr error: supports_hevc_without_padding: failed to query vaapi surface attributes data, error: %s (%d)\n", vaErrorStr(va_status), va_status); goto done; } for(unsigned int i = 0; i < num_surface_attr; ++i) { if(surface_attr_list[i].type == VASurfaceAttribAlignmentSize) { supports_surface_attrib_alignment_size = true; break; } } done: free(surface_attr_list); if(va_config > 0) vaDestroyConfig(va_dpy, va_config); if(initialized) vaTerminate(va_dpy); if(drm_fd > 0) close(drm_fd); return supports_surface_attrib_alignment_size; #else return false; #endif } static bool gsr_video_encoder_vaapi_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) { gsr_video_encoder_vaapi *self = encoder->priv; if(self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && video_codec_context->codec_id == AV_CODEC_ID_HEVC) { if(supports_hevc_without_padding(self->params.egl->card_path)) { video_codec_context->width = FFALIGN(video_codec_context->width, 2); video_codec_context->height = FFALIGN(video_codec_context->height, 2); } else { video_codec_context->width = FFALIGN(video_codec_context->width, 64); video_codec_context->height = FFALIGN(video_codec_context->height, 16); } } else if(self->params.egl->gpu_info.vendor == GSR_GPU_VENDOR_AMD && video_codec_context->codec_id == AV_CODEC_ID_AV1) { // TODO: Dont do this for VCN 5 and forward which should fix this hardware bug video_codec_context->width = FFALIGN(video_codec_context->width, 64); // AMD driver has special case handling for 1080 height to set it to 1082 instead of 1088 (1080 aligned to 16). // TODO: Set height to 1082 in this case, but it wont work because it will be aligned to 1088. if(video_codec_context->height == 1080) { video_codec_context->height = 1080; } else { video_codec_context->height = FFALIGN(video_codec_context->height, 16); } } else { video_codec_context->width = FFALIGN(video_codec_context->width, 2); video_codec_context->height = FFALIGN(video_codec_context->height, 2); } if(FFALIGN(video_codec_context->width, 2) != FFALIGN(frame->width, 2) || FFALIGN(video_codec_context->height, 2) != FFALIGN(frame->height, 2)) { fprintf(stderr, "gsr warning: gsr_video_encoder_vaapi_start: black bars have been added to the video because of a bug in AMD drivers/hardware. Record with h264 codec instead (-k h264) to get around this issue\n"); } if(video_codec_context->width < 128) video_codec_context->width = 128; if(video_codec_context->height < 128) video_codec_context->height = 128; frame->width = video_codec_context->width; frame->height = video_codec_context->height; if(!gsr_video_encoder_vaapi_setup_context(self, video_codec_context)) { gsr_video_encoder_vaapi_stop(self, video_codec_context); return false; } if(!gsr_video_encoder_vaapi_setup_textures(self, video_codec_context, frame)) { gsr_video_encoder_vaapi_stop(self, video_codec_context); return false; } return true; } void gsr_video_encoder_vaapi_stop(gsr_video_encoder_vaapi *self, AVCodecContext *video_codec_context) { self->params.egl->glDeleteTextures(2, self->target_textures); self->target_textures[0] = 0; self->target_textures[1] = 0; if(video_codec_context->hw_frames_ctx) av_buffer_unref(&video_codec_context->hw_frames_ctx); if(self->device_ctx) av_buffer_unref(&self->device_ctx); for(uint32_t i = 0; i < self->prime.num_objects; ++i) { if(self->prime.objects[i].fd > 0) { close(self->prime.objects[i].fd); self->prime.objects[i].fd = 0; } } } static void gsr_video_encoder_vaapi_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) { gsr_video_encoder_vaapi *self = encoder->priv; textures[0] = self->target_textures[0]; textures[1] = self->target_textures[1]; texture_sizes[0] = self->texture_sizes[0]; texture_sizes[1] = self->texture_sizes[1]; *num_textures = 2; *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12; } static void gsr_video_encoder_vaapi_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context) { gsr_video_encoder_vaapi_stop(encoder->priv, video_codec_context); free(encoder->priv); free(encoder); } gsr_video_encoder* gsr_video_encoder_vaapi_create(const gsr_video_encoder_vaapi_params *params) { gsr_video_encoder *encoder = calloc(1, sizeof(gsr_video_encoder)); if(!encoder) return NULL; gsr_video_encoder_vaapi *encoder_vaapi = calloc(1, sizeof(gsr_video_encoder_vaapi)); if(!encoder_vaapi) { free(encoder); return NULL; } encoder_vaapi->params = *params; *encoder = (gsr_video_encoder) { .start = gsr_video_encoder_vaapi_start, .get_textures = gsr_video_encoder_vaapi_get_textures, .destroy = gsr_video_encoder_vaapi_destroy, .priv = encoder_vaapi }; return encoder; } fsdsfdsfdsfdsf-5.13.8/src/encoder/video/video.c000066400000000000000000000021631520215207700213750ustar00rootroot00000000000000#include "../../../include/encoder/video/video.h" #include bool gsr_video_encoder_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) { assert(!encoder->started); bool res = encoder->start(encoder, video_codec_context, frame); if(res) encoder->started = true; return res; } void gsr_video_encoder_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context) { assert(encoder->started); encoder->started = false; encoder->destroy(encoder, video_codec_context); } void gsr_video_encoder_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) { assert(encoder->started); if(encoder->copy_textures_to_frame) encoder->copy_textures_to_frame(encoder, frame, color_conversion); } void gsr_video_encoder_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) { assert(encoder->started); encoder->get_textures(encoder, textures, texture_sizes, num_textures, destination_color); } fsdsfdsfdsfdsf-5.13.8/src/encoder/video/vulkan.c000066400000000000000000001125641520215207700215760ustar00rootroot00000000000000#include "../../../include/encoder/video/vulkan.h" #include "../../../include/utils.h" #include "../../../include/egl.h" #include #define VK_NO_PROTOTYPES #include #include #define GL_HANDLE_TYPE_OPAQUE_FD_EXT 0x9586 #define GL_TEXTURE_TILING_EXT 0x9580 #define GL_OPTIMAL_TILING_EXT 0x9584 #define GL_LINEAR_TILING_EXT 0x9585 #define GL_DEDICATED_MEMORY_OBJECT_EXT 0x9581 #define GL_LAYOUT_GENERAL_EXT 0x958D typedef struct { PFN_vkCreateImage vkCreateImage; PFN_vkDestroyImage vkDestroyImage; PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; PFN_vkAllocateMemory vkAllocateMemory; PFN_vkFreeMemory vkFreeMemory; PFN_vkBindImageMemory vkBindImageMemory; PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR; PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; PFN_vkCreateCommandPool vkCreateCommandPool; PFN_vkDestroyCommandPool vkDestroyCommandPool; PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; PFN_vkBeginCommandBuffer vkBeginCommandBuffer; PFN_vkEndCommandBuffer vkEndCommandBuffer; PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; PFN_vkCmdCopyImage vkCmdCopyImage; PFN_vkCreateFence vkCreateFence; PFN_vkDestroyFence vkDestroyFence; PFN_vkResetFences vkResetFences; PFN_vkWaitForFences vkWaitForFences; PFN_vkGetDeviceQueue vkGetDeviceQueue; PFN_vkQueueSubmit vkQueueSubmit; PFN_vkResetCommandBuffer vkResetCommandBuffer; PFN_vkCreateSemaphore vkCreateSemaphore; PFN_vkDestroySemaphore vkDestroySemaphore; PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR; } gsr_vk_funcs; typedef struct { gsr_video_encoder_vulkan_params params; unsigned int target_textures[2]; vec2i texture_sizes[2]; AVBufferRef *device_ctx; gsr_vk_funcs vk; VkDevice vk_device; VkQueue vk_queue; /* Exportable images that GL renders into */ VkImage export_images[2]; VkDeviceMemory export_memory[2]; VkDeviceSize export_memory_size[2]; unsigned int gl_memory_objects[2]; /* Vulkan command infrastructure for copying to encoder frame */ VkCommandPool command_pool; VkCommandBuffer command_buffer; VkFence fence; bool fence_submitted; /* true if the fence was submitted and not yet waited on */ /* GL→Vulkan semaphore (binary, exported to GL via GL_EXT_semaphore_fd) */ VkSemaphore gl_ready_semaphore; unsigned int gl_semaphore; } gsr_video_encoder_vulkan; static bool gsr_vk_funcs_load(gsr_vk_funcs *vk, PFN_vkGetInstanceProcAddr get_inst_proc, VkInstance inst, VkDevice dev) { PFN_vkGetDeviceProcAddr get_dev_proc = (PFN_vkGetDeviceProcAddr)get_inst_proc(inst, "vkGetDeviceProcAddr"); if(!get_dev_proc) { fprintf(stderr, "gsr error: gsr_vk_funcs_load: failed to load vkGetDeviceProcAddr\n"); return false; } #define LOAD_INST(name) vk->name = (PFN_##name)get_inst_proc(inst, #name); if(!vk->name) { fprintf(stderr, "gsr error: gsr_vk_funcs_load: failed to load " #name "\n"); return false; } #define LOAD_DEV(name) vk->name = (PFN_##name)get_dev_proc(dev, #name); if(!vk->name) { fprintf(stderr, "gsr error: gsr_vk_funcs_load: failed to load " #name "\n"); return false; } LOAD_INST(vkGetPhysicalDeviceMemoryProperties) LOAD_DEV(vkCreateImage) LOAD_DEV(vkDestroyImage) LOAD_DEV(vkGetImageMemoryRequirements) LOAD_DEV(vkAllocateMemory) LOAD_DEV(vkFreeMemory) LOAD_DEV(vkBindImageMemory) LOAD_DEV(vkGetMemoryFdKHR) LOAD_DEV(vkCreateCommandPool) LOAD_DEV(vkDestroyCommandPool) LOAD_DEV(vkAllocateCommandBuffers) LOAD_DEV(vkBeginCommandBuffer) LOAD_DEV(vkEndCommandBuffer) LOAD_DEV(vkCmdPipelineBarrier) LOAD_DEV(vkCmdCopyImage) LOAD_DEV(vkCreateFence) LOAD_DEV(vkDestroyFence) LOAD_DEV(vkResetFences) LOAD_DEV(vkWaitForFences) LOAD_DEV(vkGetDeviceQueue) LOAD_DEV(vkQueueSubmit) LOAD_DEV(vkResetCommandBuffer) LOAD_DEV(vkCreateSemaphore) LOAD_DEV(vkDestroySemaphore) LOAD_DEV(vkGetSemaphoreFdKHR) #undef LOAD_INST #undef LOAD_DEV return true; } static bool gsr_video_encoder_vulkan_setup_context(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context) { AVDictionary *options = NULL; char device_index_str[32]; snprintf(device_index_str, sizeof(device_index_str), "%d", self->params.egl->vulkan_device_index); if(av_hwdevice_ctx_create(&self->device_ctx, AV_HWDEVICE_TYPE_VULKAN, device_index_str, options, 0) < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_context: failed to create hardware device context\n"); return false; } AVBufferRef *frame_context = av_hwframe_ctx_alloc(self->device_ctx); if(!frame_context) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_context: failed to create hwframe context\n"); av_buffer_unref(&self->device_ctx); return false; } AVHWFramesContext *hw_frame_context = (AVHWFramesContext*)frame_context->data; hw_frame_context->width = video_codec_context->width; hw_frame_context->height = video_codec_context->height; hw_frame_context->sw_format = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? AV_PIX_FMT_P010LE : AV_PIX_FMT_NV12; hw_frame_context->format = video_codec_context->pix_fmt; hw_frame_context->device_ctx = (AVHWDeviceContext*)self->device_ctx->data; if (av_hwframe_ctx_init(frame_context) < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_context: failed to initialize hardware frame context " "(note: ffmpeg version needs to be > 4.0)\n"); av_buffer_unref(&self->device_ctx); return false; } video_codec_context->hw_frames_ctx = av_buffer_ref(frame_context); av_buffer_unref(&frame_context); return true; } static AVVulkanDeviceContext* video_codec_context_get_vulkan_data(AVCodecContext *video_codec_context) { AVBufferRef *hw_frames_ctx = video_codec_context->hw_frames_ctx; if(!hw_frames_ctx) return NULL; AVHWFramesContext *hw_frame_context = (AVHWFramesContext*)hw_frames_ctx->data; AVHWDeviceContext *device_context = (AVHWDeviceContext*)hw_frame_context->device_ctx; if(device_context->type != AV_HWDEVICE_TYPE_VULKAN) return NULL; return (AVVulkanDeviceContext*)device_context->hwctx; } static int get_graphics_queue_family(AVVulkanDeviceContext *vv) { #if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(59, 39, 100) for(int i = 0; i < vv->nb_qf; i++) { if(vv->qf[i].flags & VK_QUEUE_GRAPHICS_BIT) return vv->qf[i].idx; } /* Fall back to any queue that supports transfer */ for(int i = 0; i < vv->nb_qf; i++) { if(vv->qf[i].flags & VK_QUEUE_TRANSFER_BIT) return vv->qf[i].idx; } return -1; #else if(vv->queue_family_index >= 0) return vv->queue_family_index; if(vv->queue_family_tx_index >= 0) return vv->queue_family_tx_index; return -1; #endif } static uint32_t get_memory_type_idx(VkPhysicalDevice pdev, const VkMemoryRequirements *mem_reqs, VkMemoryPropertyFlagBits prop_flags, PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties) { VkPhysicalDeviceMemoryProperties pdev_mem_props; vkGetPhysicalDeviceMemoryProperties(pdev, &pdev_mem_props); for(uint32_t i = 0; i < pdev_mem_props.memoryTypeCount; i++) { if((mem_reqs->memoryTypeBits & (1 << i)) && (pdev_mem_props.memoryTypes[i].propertyFlags & prop_flags) == prop_flags) { return i; } } return UINT32_MAX; } static bool create_exportable_image( const gsr_vk_funcs *vk, VkDevice dev, VkPhysicalDevice phys_dev, int width, int height, VkFormat format, VkImage *out_image, VkDeviceMemory *out_memory, VkDeviceSize *out_size) { VkExternalMemoryImageCreateInfo ext_img_info = { .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, }; VkImageCreateInfo img_info = { .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, .pNext = &ext_img_info, .imageType = VK_IMAGE_TYPE_2D, .format = format, .extent = { (uint32_t)width, (uint32_t)height, 1 }, .mipLevels = 1, .arrayLayers = 1, .samples = VK_SAMPLE_COUNT_1_BIT, .tiling = VK_IMAGE_TILING_OPTIMAL, .usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_STORAGE_BIT, .flags = VK_IMAGE_CREATE_ALIAS_BIT | VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, .sharingMode = VK_SHARING_MODE_EXCLUSIVE, .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED, }; if(vk->vkCreateImage(dev, &img_info, NULL, out_image) != VK_SUCCESS) { fprintf(stderr, "gsr error: create_exportable_image: vkCreateImage failed\n"); return false; } VkMemoryRequirements mem_reqs; vk->vkGetImageMemoryRequirements(dev, *out_image, &mem_reqs); uint32_t mem_type_idx = get_memory_type_idx(phys_dev, &mem_reqs, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, vk->vkGetPhysicalDeviceMemoryProperties); if(mem_type_idx == UINT32_MAX) { fprintf(stderr, "gsr error: create_exportable_image: no suitable memory type\n"); vk->vkDestroyImage(dev, *out_image, NULL); *out_image = VK_NULL_HANDLE; return false; } VkMemoryDedicatedAllocateInfo ded_info = { .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, .image = *out_image, }; VkExportMemoryAllocateInfo exp_mem_info = { .sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, .pNext = &ded_info, .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, }; VkMemoryAllocateInfo mem_alloc_info = { .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, .pNext = &exp_mem_info, .allocationSize = mem_reqs.size, .memoryTypeIndex = mem_type_idx, }; if(vk->vkAllocateMemory(dev, &mem_alloc_info, NULL, out_memory) != VK_SUCCESS) { fprintf(stderr, "gsr error: create_exportable_image: vkAllocateMemory failed\n"); vk->vkDestroyImage(dev, *out_image, NULL); *out_image = VK_NULL_HANDLE; return false; } if(vk->vkBindImageMemory(dev, *out_image, *out_memory, 0) != VK_SUCCESS) { fprintf(stderr, "gsr error: create_exportable_image: vkBindImageMemory failed\n"); vk->vkFreeMemory(dev, *out_memory, NULL); vk->vkDestroyImage(dev, *out_image, NULL); *out_memory = VK_NULL_HANDLE; *out_image = VK_NULL_HANDLE; return false; } *out_size = mem_reqs.size; return true; } static bool gsr_video_encoder_vulkan_setup_textures(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context, AVFrame *frame) { const int res = av_hwframe_get_buffer(video_codec_context->hw_frames_ctx, frame, 0); if(res < 0) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: av_hwframe_get_buffer failed: %d\n", res); return false; } while(self->params.egl->glGetError()) {} AVVulkanDeviceContext *vv = video_codec_context_get_vulkan_data(video_codec_context); if(!vv) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: failed to get vulkan device context\n"); return false; } if(!gsr_vk_funcs_load(&self->vk, vv->get_proc_addr, vv->inst, vv->act_dev)) return false; self->vk_device = vv->act_dev; const bool is_p010 = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS; const VkFormat fmt_y = is_p010 ? VK_FORMAT_R16_UNORM : VK_FORMAT_R8_UNORM; const VkFormat fmt_uv = is_p010 ? VK_FORMAT_R16G16_UNORM : VK_FORMAT_R8G8_UNORM; const unsigned int gl_fmt_y = is_p010 ? GL_R16 : GL_R8; const unsigned int gl_fmt_uv = is_p010 ? GL_RG16 : GL_RG8; if(!create_exportable_image(&self->vk, vv->act_dev, vv->phys_dev, frame->width, frame->height, fmt_y, &self->export_images[0], &self->export_memory[0], &self->export_memory_size[0])) return false; if(!create_exportable_image(&self->vk, vv->act_dev, vv->phys_dev, frame->width / 2, frame->height / 2, fmt_uv, &self->export_images[1], &self->export_memory[1], &self->export_memory_size[1])) return false; /* Export Vulkan memory as FDs and import into GL */ for(int i = 0; i < 2; i++) { VkMemoryGetFdInfoKHR fd_info = { .sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR, .memory = self->export_memory[i], .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, }; int fd = -1; if(self->vk.vkGetMemoryFdKHR(vv->act_dev, &fd_info, &fd) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkGetMemoryFdKHR failed for plane %d\n", i); return false; } self->params.egl->glCreateMemoryObjectsEXT(1, &self->gl_memory_objects[i]); const int dedicated = 1; self->params.egl->glMemoryObjectParameterivEXT(self->gl_memory_objects[i], GL_DEDICATED_MEMORY_OBJECT_EXT, &dedicated); self->params.egl->glImportMemoryFdEXT(self->gl_memory_objects[i], self->export_memory_size[i], GL_HANDLE_TYPE_OPAQUE_FD_EXT, fd); if(!self->params.egl->glIsMemoryObjectEXT(self->gl_memory_objects[i])) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: failed to import memory FD for plane %d\n", i); return false; } } /* Create GL textures backed by the exportable images */ self->params.egl->glGenTextures(2, self->target_textures); self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[0]); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, GL_OPTIMAL_TILING_EXT); self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, gl_fmt_y, frame->width, frame->height, self->gl_memory_objects[0], 0); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); self->params.egl->glBindTexture(GL_TEXTURE_2D, self->target_textures[1]); self->params.egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, GL_OPTIMAL_TILING_EXT); self->params.egl->glTexStorageMem2DEXT(GL_TEXTURE_2D, 1, gl_fmt_uv, frame->width / 2, frame->height / 2, self->gl_memory_objects[1], 0); self->params.egl->glBindTexture(GL_TEXTURE_2D, 0); self->texture_sizes[0] = (vec2i){ frame->width, frame->height }; self->texture_sizes[1] = (vec2i){ frame->width / 2, frame->height / 2 }; /* Set up Vulkan command infrastructure */ VkCommandPoolCreateInfo pool_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, .flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, .queueFamilyIndex = (uint32_t)get_graphics_queue_family(vv), }; if(self->vk.vkCreateCommandPool(vv->act_dev, &pool_info, NULL, &self->command_pool) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkCreateCommandPool failed\n"); return false; } VkCommandBufferAllocateInfo cb_alloc_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, .commandPool = self->command_pool, .level = VK_COMMAND_BUFFER_LEVEL_PRIMARY, .commandBufferCount = 1, }; if(self->vk.vkAllocateCommandBuffers(vv->act_dev, &cb_alloc_info, &self->command_buffer) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkAllocateCommandBuffers failed\n"); return false; } VkFenceCreateInfo fence_info = { .sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, }; if(self->vk.vkCreateFence(vv->act_dev, &fence_info, NULL, &self->fence) != VK_SUCCESS) { fprintf(stderr, "gsr error: gsr_video_encoder_vulkan_setup_textures: vkCreateFence failed\n"); return false; } self->vk.vkGetDeviceQueue(vv->act_dev, (uint32_t)get_graphics_queue_family(vv), 0, &self->vk_queue); /* Transition export images UNDEFINED → GENERAL so GL can use them */ VkCommandBufferBeginInfo begin_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, }; self->vk.vkBeginCommandBuffer(self->command_buffer, &begin_info); VkImageMemoryBarrier init_barriers[2]; for(int i = 0; i < 2; i++) { init_barriers[i] = (VkImageMemoryBarrier){ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = 0, .dstAccessMask = 0, .oldLayout = VK_IMAGE_LAYOUT_UNDEFINED, .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = self->export_images[i], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1, }, }; } self->vk.vkCmdPipelineBarrier(self->command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 2, init_barriers); self->vk.vkEndCommandBuffer(self->command_buffer); VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, .commandBufferCount = 1, .pCommandBuffers = &self->command_buffer, }; self->vk.vkQueueSubmit(self->vk_queue, 1, &submit_info, self->fence); self->vk.vkWaitForFences(vv->act_dev, 1, &self->fence, VK_TRUE, UINT64_MAX); self->vk.vkResetFences(vv->act_dev, 1, &self->fence); self->vk.vkResetCommandBuffer(self->command_buffer, 0); /* Create GL→Vulkan sync semaphore (binary, exported via OPAQUE_FD) */ if(self->params.egl->glGenSemaphoresEXT && self->params.egl->glImportSemaphoreFdEXT) { VkExportSemaphoreCreateInfo exp_sem_info = { .sType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, .handleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, }; VkSemaphoreCreateInfo sem_info = { .sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, .pNext = &exp_sem_info, }; if(self->vk.vkCreateSemaphore(vv->act_dev, &sem_info, NULL, &self->gl_ready_semaphore) == VK_SUCCESS) { VkSemaphoreGetFdInfoKHR get_fd_info = { .sType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR, .semaphore = self->gl_ready_semaphore, .handleType = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, }; int sem_fd = -1; if(self->vk.vkGetSemaphoreFdKHR(vv->act_dev, &get_fd_info, &sem_fd) == VK_SUCCESS) { self->params.egl->glGenSemaphoresEXT(1, &self->gl_semaphore); self->params.egl->glImportSemaphoreFdEXT(self->gl_semaphore, GL_HANDLE_TYPE_OPAQUE_FD_EXT, sem_fd); } else { self->vk.vkDestroySemaphore(vv->act_dev, self->gl_ready_semaphore, NULL); self->gl_ready_semaphore = VK_NULL_HANDLE; } } } return true; } static void gsr_video_encoder_vulkan_stop(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context); static bool gsr_video_encoder_vulkan_start(gsr_video_encoder *encoder, AVCodecContext *video_codec_context, AVFrame *frame) { gsr_video_encoder_vulkan *self = encoder->priv; video_codec_context->width = FFALIGN(video_codec_context->width, 2); video_codec_context->height = FFALIGN(video_codec_context->height, 2); if(video_codec_context->width < 128) video_codec_context->width = 128; if(video_codec_context->height < 128) video_codec_context->height = 128; frame->width = video_codec_context->width; frame->height = video_codec_context->height; if(!gsr_video_encoder_vulkan_setup_context(self, video_codec_context)) { gsr_video_encoder_vulkan_stop(self, video_codec_context); return false; } if(!gsr_video_encoder_vulkan_setup_textures(self, video_codec_context, frame)) { gsr_video_encoder_vulkan_stop(self, video_codec_context); return false; } return true; } static void gsr_video_encoder_vulkan_copy_textures_to_frame(gsr_video_encoder *encoder, AVFrame *frame, gsr_color_conversion *color_conversion) { (void)color_conversion; gsr_video_encoder_vulkan *self = encoder->priv; AVVkFrame *vk_frame = (AVVkFrame*)frame->data[0]; /* Wait for the previous frame's copy to finish before reusing the command buffer */ // if(self->fence_submitted) { // self->vk.vkWaitForFences(self->vk_device, 1, &self->fence, VK_TRUE, UINT64_MAX); self->vk.vkResetFences(self->vk_device, 1, &self->fence); self->fence_submitted = false; // } if(self->gl_ready_semaphore != VK_NULL_HANDLE && self->params.egl->glSignalSemaphoreEXT) { /* GPU-side GL→Vulkan sync: signal the semaphore from GL, then flush (no CPU stall) */ unsigned int gl_textures[2] = { self->target_textures[0], self->target_textures[1] }; unsigned int dst_layouts[2] = { GL_LAYOUT_GENERAL_EXT, GL_LAYOUT_GENERAL_EXT }; self->params.egl->glSignalSemaphoreEXT(self->gl_semaphore, 0, NULL, 2, gl_textures, dst_layouts); self->params.egl->glFlush(); } else { /* Fallback: CPU stall to ensure GL has finished */ self->params.egl->glFinish(); } self->vk.vkResetCommandBuffer(self->command_buffer, 0); VkCommandBufferBeginInfo begin_info = { .sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, .flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, }; self->vk.vkBeginCommandBuffer(self->command_buffer, &begin_info); /* Transition export images: GENERAL → TRANSFER_SRC_OPTIMAL */ VkImageMemoryBarrier src_barriers[2]; for(int i = 0; i < 2; i++) { src_barriers[i] = (VkImageMemoryBarrier){ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT, .dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT, .oldLayout = VK_IMAGE_LAYOUT_GENERAL, .newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = self->export_images[i], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1, }, }; } self->vk.vkCmdPipelineBarrier(self->command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 2, src_barriers); /* * Detect whether the encoder frame uses one multi-plane image (default NV12/P010 * in FFmpeg) or two separate single-plane images. * Multi-plane: img[1] == VK_NULL_HANDLE or img[1] == img[0] */ const bool multiplane = (vk_frame->img[1] == VK_NULL_HANDLE || vk_frame->img[1] == vk_frame->img[0]); if(multiplane) { /* Transition the encoder's multi-plane image to TRANSFER_DST_OPTIMAL */ VkImageMemoryBarrier dst_barrier = { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, .oldLayout = vk_frame->layout[0], .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = vk_frame->img[0], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT, .levelCount = 1, .layerCount = 1, }, }; self->vk.vkCmdPipelineBarrier(self->command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 1, &dst_barrier); /* Copy Y plane: export_images[0] (R8/R16) → encoder img PLANE_0 */ VkImageCopy copy_y = { .srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }, .dstSubresource = { VK_IMAGE_ASPECT_PLANE_0_BIT, 0, 0, 1 }, .extent = { (uint32_t)frame->width, (uint32_t)frame->height, 1 }, }; self->vk.vkCmdCopyImage(self->command_buffer, self->export_images[0], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, vk_frame->img[0], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_y); /* Copy UV plane: export_images[1] (RG8/RG16) → encoder img PLANE_1 */ VkImageCopy copy_uv = { .srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }, .dstSubresource = { VK_IMAGE_ASPECT_PLANE_1_BIT, 0, 0, 1 }, .extent = { (uint32_t)frame->width / 2, (uint32_t)frame->height / 2, 1 }, }; self->vk.vkCmdCopyImage(self->command_buffer, self->export_images[1], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, vk_frame->img[0], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©_uv); /* Transition encoder image to GENERAL and update tracked layout */ VkImageMemoryBarrier dst_barrier_back = { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = vk_frame->img[0], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_PLANE_0_BIT | VK_IMAGE_ASPECT_PLANE_1_BIT, .levelCount = 1, .layerCount = 1, }, }; self->vk.vkCmdPipelineBarrier(self->command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 1, &dst_barrier_back); vk_frame->layout[0] = VK_IMAGE_LAYOUT_GENERAL; vk_frame->layout[1] = VK_IMAGE_LAYOUT_GENERAL; } else { /* Two separate single-plane images */ VkImageMemoryBarrier dst_barriers[2] = { { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, .oldLayout = vk_frame->layout[0], .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = vk_frame->img[0], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1, }, }, { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, .oldLayout = vk_frame->layout[1], .newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = vk_frame->img[1], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1, }, }, }; self->vk.vkCmdPipelineBarrier(self->command_buffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 2, dst_barriers); for(int i = 0; i < 2; i++) { VkImageCopy copy = { .srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }, .dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 }, .extent = { (uint32_t)(i == 0 ? frame->width : frame->width / 2), (uint32_t)(i == 0 ? frame->height : frame->height / 2), 1 }, }; self->vk.vkCmdCopyImage(self->command_buffer, self->export_images[i], VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, vk_frame->img[i], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©); } VkImageMemoryBarrier dst_barriers_back[2] = { { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = vk_frame->img[0], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1, }, }, { .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT, .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = vk_frame->img[1], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1, }, }, }; self->vk.vkCmdPipelineBarrier(self->command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 2, dst_barriers_back); vk_frame->layout[0] = VK_IMAGE_LAYOUT_GENERAL; vk_frame->layout[1] = VK_IMAGE_LAYOUT_GENERAL; } /* Transition export images back: TRANSFER_SRC_OPTIMAL → GENERAL for next GL frame */ VkImageMemoryBarrier src_barriers_back[2]; for(int i = 0; i < 2; i++) { src_barriers_back[i] = (VkImageMemoryBarrier){ .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT, .dstAccessMask = VK_ACCESS_MEMORY_WRITE_BIT, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, .newLayout = VK_IMAGE_LAYOUT_GENERAL, .srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .image = self->export_images[i], .subresourceRange = { .aspectMask = VK_IMAGE_ASPECT_COLOR_BIT, .levelCount = 1, .layerCount = 1, }, }; } self->vk.vkCmdPipelineBarrier(self->command_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, NULL, 0, NULL, 2, src_barriers_back); self->vk.vkEndCommandBuffer(self->command_buffer); /* * Detect whether the encoder frame is multiplane to know how many timeline * semaphores need to be signaled. */ const bool mp = (vk_frame->img[1] == VK_NULL_HANDLE || vk_frame->img[1] == vk_frame->img[0]); const int num_sems = mp ? 1 : 2; if(self->gl_ready_semaphore != VK_NULL_HANDLE) { /* * GPU-side sync path: * - Wait on the GL binary semaphore before executing the copy. * - Signal each AVVkFrame timeline semaphore so FFmpeg knows the frame is ready. */ uint64_t signal_values[2]; VkSemaphore signal_sems[2]; for(int i = 0; i < num_sems; i++) { signal_values[i] = vk_frame->sem_value[i] + 1; signal_sems[i] = vk_frame->sem[i]; } VkTimelineSemaphoreSubmitInfo timeline_info = { .sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, .signalSemaphoreValueCount = (uint32_t)num_sems, .pSignalSemaphoreValues = signal_values, }; const VkPipelineStageFlags wait_stage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, .pNext = &timeline_info, .waitSemaphoreCount = 1, .pWaitSemaphores = &self->gl_ready_semaphore, .pWaitDstStageMask = &wait_stage, .commandBufferCount = 1, .pCommandBuffers = &self->command_buffer, .signalSemaphoreCount = (uint32_t)num_sems, .pSignalSemaphores = signal_sems, }; self->vk.vkQueueSubmit(self->vk_queue, 1, &submit_info, self->fence); for(int i = 0; i < num_sems; i++) vk_frame->sem_value[i]++; } else { /* Fallback: plain submit, we already stalled via glFinish() */ VkSubmitInfo submit_info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, .commandBufferCount = 1, .pCommandBuffers = &self->command_buffer, }; self->vk.vkQueueSubmit(self->vk_queue, 1, &submit_info, self->fence); } self->fence_submitted = true; } void gsr_video_encoder_vulkan_stop(gsr_video_encoder_vulkan *self, AVCodecContext *video_codec_context) { self->params.egl->glDeleteTextures(2, self->target_textures); self->target_textures[0] = 0; self->target_textures[1] = 0; if(self->vk_device) { /* Drain any in-flight copy before freeing resources */ if(self->fence_submitted) { self->vk.vkWaitForFences(self->vk_device, 1, &self->fence, VK_TRUE, UINT64_MAX); self->fence_submitted = false; } if(self->gl_ready_semaphore) self->vk.vkDestroySemaphore(self->vk_device, self->gl_ready_semaphore, NULL); if(self->fence) self->vk.vkDestroyFence(self->vk_device, self->fence, NULL); /* Destroying the command pool also frees the command buffer */ if(self->command_pool) self->vk.vkDestroyCommandPool(self->vk_device, self->command_pool, NULL); for(int i = 0; i < 2; i++) { if(self->export_images[i]) self->vk.vkDestroyImage(self->vk_device, self->export_images[i], NULL); if(self->export_memory[i]) self->vk.vkFreeMemory(self->vk_device, self->export_memory[i], NULL); } } if(video_codec_context->hw_frames_ctx) av_buffer_unref(&video_codec_context->hw_frames_ctx); if(self->device_ctx) av_buffer_unref(&self->device_ctx); } static void gsr_video_encoder_vulkan_get_textures(gsr_video_encoder *encoder, unsigned int *textures, vec2i *texture_sizes, int *num_textures, gsr_destination_color *destination_color) { gsr_video_encoder_vulkan *self = encoder->priv; textures[0] = self->target_textures[0]; textures[1] = self->target_textures[1]; texture_sizes[0] = self->texture_sizes[0]; texture_sizes[1] = self->texture_sizes[1]; *num_textures = 2; *destination_color = self->params.color_depth == GSR_COLOR_DEPTH_10_BITS ? GSR_DESTINATION_COLOR_P010 : GSR_DESTINATION_COLOR_NV12; } static void gsr_video_encoder_vulkan_destroy(gsr_video_encoder *encoder, AVCodecContext *video_codec_context) { gsr_video_encoder_vulkan_stop(encoder->priv, video_codec_context); free(encoder->priv); free(encoder); } gsr_video_encoder* gsr_video_encoder_vulkan_create(const gsr_video_encoder_vulkan_params *params) { gsr_video_encoder *encoder = calloc(1, sizeof(gsr_video_encoder)); if(!encoder) return NULL; gsr_video_encoder_vulkan *encoder_vulkan = calloc(1, sizeof(gsr_video_encoder_vulkan)); if(!encoder_vulkan) { free(encoder); return NULL; } encoder_vulkan->params = *params; *encoder = (gsr_video_encoder) { .start = gsr_video_encoder_vulkan_start, .copy_textures_to_frame = gsr_video_encoder_vulkan_copy_textures_to_frame, .get_textures = gsr_video_encoder_vulkan_get_textures, .destroy = gsr_video_encoder_vulkan_destroy, .priv = encoder_vulkan }; return encoder; } fsdsfdsfdsfdsf-5.13.8/src/image_writer.c000066400000000000000000000057301520215207700202230ustar00rootroot00000000000000#include "../include/image_writer.h" #include "../include/egl.h" #include "../include/utils.h" #define STB_IMAGE_WRITE_IMPLEMENTATION #include "../external/stb_image_write.h" #include #include #include #include /* TODO: Support hdr/10-bit */ bool gsr_image_writer_init_opengl(gsr_image_writer *self, gsr_egl *egl, int width, int height) { memset(self, 0, sizeof(*self)); self->egl = egl; self->width = width; self->height = height; self->texture = gl_create_texture(self->egl, self->width, self->height, GL_RGBA8, GL_RGBA, GL_NEAREST); /* TODO: use GL_RGB16 instead of GL_RGB8 for hdr/10-bit */ if(self->texture == 0) { fprintf(stderr, "gsr error: gsr_image_writer_init: failed to create texture\n"); return false; } return true; } void gsr_image_writer_deinit(gsr_image_writer *self) { if(self->texture) { self->egl->glDeleteTextures(1, &self->texture); self->texture = 0; } } static bool gsr_image_writer_write_memory_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality, const void *data) { if(quality < 1) quality = 1; else if(quality > 100) quality = 100; bool success = false; switch(image_format) { case GSR_IMAGE_FORMAT_JPEG: success = stbi_write_jpg(filepath, self->width, self->height, 4, data, quality); break; case GSR_IMAGE_FORMAT_PNG: success = stbi_write_png(filepath, self->width, self->height, 4, data, 0); break; } if(!success) fprintf(stderr, "gsr error: gsr_image_writer_write_to_file: failed to write image data to output file %s\n", filepath); return success; } static bool gsr_image_writer_write_opengl_texture_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality) { uint8_t *frame_data = malloc(self->width * self->height * 4); if(!frame_data) { fprintf(stderr, "gsr error: gsr_image_writer_write_to_file: failed to allocate memory for image frame\n"); return false; } unsigned int fbo = 0; self->egl->glGenFramebuffers(1, &fbo); self->egl->glBindFramebuffer(GL_FRAMEBUFFER, fbo); self->egl->glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self->texture, 0); self->egl->glReadPixels(0, 0, self->width, self->height, GL_RGBA, GL_UNSIGNED_BYTE, frame_data); self->egl->glBindFramebuffer(GL_FRAMEBUFFER, 0); self->egl->glDeleteFramebuffers(1, &fbo); self->egl->glFlush(); self->egl->glFinish(); const bool success = gsr_image_writer_write_memory_to_file(self, filepath, image_format, quality, frame_data); free(frame_data); return success; } bool gsr_image_writer_write_to_file(gsr_image_writer *self, const char *filepath, gsr_image_format image_format, int quality) { return gsr_image_writer_write_opengl_texture_to_file(self, filepath, image_format, quality); } fsdsfdsfdsfdsf-5.13.8/src/library_loader.c000066400000000000000000000017551520215207700205420ustar00rootroot00000000000000#include "../include/library_loader.h" #include #include #include void* dlsym_print_fail(void *handle, const char *name, bool required) { dlerror(); void *sym = dlsym(handle, name); char *err_str = dlerror(); if(!sym) fprintf(stderr, "%s: dlsym(handle, \"%s\") failed, error: %s\n", required ? "error" : "warning", name, err_str ? err_str : "(null)"); return sym; } /* |dlsyms| should be null terminated */ bool dlsym_load_list(void *handle, const dlsym_assign *dlsyms) { bool success = true; for(int i = 0; dlsyms[i].func; ++i) { *dlsyms[i].func = dlsym_print_fail(handle, dlsyms[i].name, true); if(!*dlsyms[i].func) success = false; } return success; } /* |dlsyms| should be null terminated */ void dlsym_load_list_optional(void *handle, const dlsym_assign *dlsyms) { for(int i = 0; dlsyms[i].func; ++i) { *dlsyms[i].func = dlsym_print_fail(handle, dlsyms[i].name, false); } } fsdsfdsfdsfdsf-5.13.8/src/main.cpp000066400000000000000000006336671520215207700170510ustar00rootroot00000000000000extern "C" { #include "../include/capture/nvfbc.h" #include "../include/capture/xcomposite.h" #include "../include/capture/ximage.h" #include "../include/capture/kms.h" #include "../include/capture/v4l2.h" #ifdef GSR_PORTAL #include "../include/capture/portal.h" #include "../include/dbus.h" #endif #ifdef GSR_APP_AUDIO #include "../include/pipewire_audio.h" #endif #include "../include/encoder/encoder.h" #include "../include/encoder/video/nvenc.h" #include "../include/encoder/video/vaapi.h" #include "../include/encoder/video/vulkan.h" #include "../include/encoder/video/software.h" #include "../include/codec_query/nvenc.h" #include "../include/codec_query/vaapi.h" #include "../include/codec_query/vulkan.h" #include "../include/window/x11.h" #include "../include/window/wayland.h" #include "../include/egl.h" #include "../include/utils.h" #include "../include/damage.h" #include "../include/color_conversion.h" #include "../include/image_writer.h" #include "../include/args_parser.h" #include "../include/plugins.h" #include "../kms/client/kms_client.h" } #include #include #include #include #include #include #include #include #include #include #include #include #include #include "../include/sound.hpp" extern "C" { #include #include #include #include #include #include #include #include #include #include #include } #include #ifndef GSR_VERSION #define GSR_VERSION "unknown" #endif // TODO: If options are not supported then they are returned (allocated) in the options. This should be free'd. // TODO: Remove LIBAVUTIL_VERSION_MAJOR checks in the future when ubuntu, pop os LTS etc update ffmpeg to >= 5.0 static const int AUDIO_SAMPLE_RATE = 48000; static const int VIDEO_STREAM_INDEX = 0; static thread_local char av_error_buffer[AV_ERROR_MAX_STRING_SIZE]; typedef struct { const gsr_window *window; } MonitorOutputCallbackUserdata; static void monitor_output_callback_print(const gsr_monitor *monitor, void *userdata) { const MonitorOutputCallbackUserdata *options = (MonitorOutputCallbackUserdata*)userdata; vec2i monitor_position = monitor->pos; vec2i monitor_size = monitor->size; if(gsr_window_get_display_server(options->window) == GSR_DISPLAY_SERVER_WAYLAND) { gsr_monitor_rotation monitor_rotation = GSR_MONITOR_ROT_0; drm_monitor_get_display_server_data(options->window, monitor, &monitor_rotation, &monitor_position); if(monitor_rotation == GSR_MONITOR_ROT_90 || monitor_rotation == GSR_MONITOR_ROT_270) std::swap(monitor_size.x, monitor_size.y); } fprintf(stderr, " \"%.*s\" (%dx%d+%d+%d)\n", monitor->name_len, monitor->name, monitor_size.x, monitor_size.y, monitor_position.x, monitor_position.y); } typedef struct { char *output_name; } FirstOutputCallback; static void get_first_output_callback(const gsr_monitor *monitor, void *userdata) { FirstOutputCallback *data = (FirstOutputCallback*)userdata; if(!data->output_name) data->output_name = strdup(monitor->name); } typedef struct { gsr_window *window; vec2i position; char *output_name; vec2i monitor_pos; vec2i monitor_size; double monitor_scale_inverted; } MonitorByPositionCallback; static void get_monitor_by_position_callback(const gsr_monitor *monitor, void *userdata) { MonitorByPositionCallback *data = (MonitorByPositionCallback*)userdata; const vec2i monitor_position = monitor->logical_pos; const vec2i monitor_size = monitor->size; const vec2i monitor_logical_size = monitor->logical_size; if(!data->output_name && data->position.x >= monitor_position.x && data->position.x <= monitor_position.x + monitor_logical_size.x && data->position.y >= monitor_position.y && data->position.y <= monitor_position.y + monitor_logical_size.y) { data->output_name = strdup(monitor->name); data->monitor_pos = monitor_position; data->monitor_size = monitor_size; data->monitor_scale_inverted = (double)monitor_size.x / (double)monitor_logical_size.x; } } static char* av_error_to_string(int err) { if(av_strerror(err, av_error_buffer, sizeof(av_error_buffer)) < 0) strcpy(av_error_buffer, "Unknown error"); return av_error_buffer; } static int x11_error_handler(Display*, XErrorEvent*) { return 0; } static int x11_io_error_handler(Display*) { return 0; } static AVCodecID audio_codec_get_id(gsr_audio_codec audio_codec) { switch(audio_codec) { case GSR_AUDIO_CODEC_AAC: return AV_CODEC_ID_AAC; case GSR_AUDIO_CODEC_OPUS: return AV_CODEC_ID_OPUS; case GSR_AUDIO_CODEC_FLAC: return AV_CODEC_ID_FLAC; } assert(false); return AV_CODEC_ID_AAC; } static AVSampleFormat audio_codec_get_sample_format(AVCodecContext *audio_codec_context, gsr_audio_codec audio_codec, const AVCodec *codec, bool mix_audio) { (void)audio_codec_context; switch(audio_codec) { case GSR_AUDIO_CODEC_AAC: { return AV_SAMPLE_FMT_FLTP; } case GSR_AUDIO_CODEC_OPUS: { bool supports_s16 = false; bool supports_flt = false; #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(61, 15, 0) for(size_t i = 0; codec->sample_fmts && codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; ++i) { if(codec->sample_fmts[i] == AV_SAMPLE_FMT_S16) { supports_s16 = true; } else if(codec->sample_fmts[i] == AV_SAMPLE_FMT_FLT) { supports_flt = true; } } #else const enum AVSampleFormat *sample_fmts = NULL; if(avcodec_get_supported_config(audio_codec_context, codec, AV_CODEC_CONFIG_SAMPLE_FORMAT, 0, (const void**)&sample_fmts, NULL) >= 0) { if(sample_fmts) { for(size_t i = 0; sample_fmts[i] != AV_SAMPLE_FMT_NONE; ++i) { if(sample_fmts[i] == AV_SAMPLE_FMT_S16) { supports_s16 = true; } else if(sample_fmts[i] == AV_SAMPLE_FMT_FLT) { supports_flt = true; } } } else { // What a dumb API. It returns NULL if all formats are supported supports_s16 = true; supports_flt = true; } } #endif // Amix only works with float audio if(mix_audio) supports_s16 = false; if(!supports_s16 && !supports_flt) { fprintf(stderr, "gsr warning: opus audio codec is chosen but your ffmpeg version does not support s16/flt sample format and performance might be slightly worse.\n"); fprintf(stderr, " You can either rebuild ffmpeg with libopus instead of the built-in opus, use the flatpak version of gpu screen recorder or record with aac audio codec instead (-ac aac).\n"); fprintf(stderr, " Falling back to fltp audio sample format instead.\n"); } if(supports_s16) return AV_SAMPLE_FMT_S16; else if(supports_flt) return AV_SAMPLE_FMT_FLT; else return AV_SAMPLE_FMT_FLTP; } case GSR_AUDIO_CODEC_FLAC: { return AV_SAMPLE_FMT_S32; } } assert(false); return AV_SAMPLE_FMT_FLTP; } static int64_t audio_codec_get_get_bitrate(gsr_audio_codec audio_codec) { switch(audio_codec) { case GSR_AUDIO_CODEC_AAC: return 160000; case GSR_AUDIO_CODEC_OPUS: return 128000; case GSR_AUDIO_CODEC_FLAC: return 128000; } assert(false); return 128000; } static AudioFormat audio_codec_context_get_audio_format(const AVCodecContext *audio_codec_context) { switch(audio_codec_context->sample_fmt) { case AV_SAMPLE_FMT_FLT: return F32; case AV_SAMPLE_FMT_FLTP: return S32; case AV_SAMPLE_FMT_S16: return S16; case AV_SAMPLE_FMT_S32: return S32; default: return S16; } } static AVSampleFormat audio_format_to_sample_format(const AudioFormat audio_format) { switch(audio_format) { case S16: return AV_SAMPLE_FMT_S16; case S32: return AV_SAMPLE_FMT_S32; case F32: return AV_SAMPLE_FMT_FLT; } assert(false); return AV_SAMPLE_FMT_S16; } static AVCodecContext* create_audio_codec_context(int fps, gsr_audio_codec audio_codec, bool mix_audio, int64_t audio_bitrate) { (void)fps; const AVCodec *codec = avcodec_find_encoder(audio_codec_get_id(audio_codec)); if (!codec) { fprintf(stderr, "gsr error: Could not find %s audio encoder\n", audio_codec_get_name(audio_codec)); _exit(1); } AVCodecContext *codec_context = avcodec_alloc_context3(codec); assert(codec->type == AVMEDIA_TYPE_AUDIO); codec_context->codec_id = codec->id; codec_context->sample_fmt = audio_codec_get_sample_format(codec_context, audio_codec, codec, mix_audio); codec_context->bit_rate = audio_bitrate == 0 ? audio_codec_get_get_bitrate(audio_codec) : audio_bitrate; codec_context->sample_rate = AUDIO_SAMPLE_RATE; if(audio_codec == GSR_AUDIO_CODEC_AAC) { #if LIBAVCODEC_VERSION_MAJOR < 62 codec_context->profile = FF_PROFILE_AAC_LOW; #else codec_context->profile = AV_PROFILE_AAC_LOW; #endif } #if LIBAVCODEC_VERSION_MAJOR < 60 codec_context->channel_layout = AV_CH_LAYOUT_STEREO; codec_context->channels = 2; #else av_channel_layout_default(&codec_context->ch_layout, 2); #endif codec_context->time_base.num = 1; codec_context->time_base.den = codec_context->sample_rate; codec_context->thread_count = 1; codec_context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; return codec_context; } static int vbr_get_quality_parameter(AVCodecContext *codec_context, gsr_video_quality video_quality, bool hdr) { // 8 bit / 10 bit = 80% const float qp_multiply = hdr ? 8.0f/10.0f : 1.0f; if(codec_context->codec_id == AV_CODEC_ID_AV1) { switch(video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: return 160 * qp_multiply; case GSR_VIDEO_QUALITY_HIGH: return 130 * qp_multiply; case GSR_VIDEO_QUALITY_VERY_HIGH: return 110 * qp_multiply; case GSR_VIDEO_QUALITY_ULTRA: return 90 * qp_multiply; } } else if(codec_context->codec_id == AV_CODEC_ID_H264) { switch(video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: return 35 * qp_multiply; case GSR_VIDEO_QUALITY_HIGH: return 30 * qp_multiply; case GSR_VIDEO_QUALITY_VERY_HIGH: return 25 * qp_multiply; case GSR_VIDEO_QUALITY_ULTRA: return 22 * qp_multiply; } } else if(codec_context->codec_id == AV_CODEC_ID_HEVC) { switch(video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: return 35 * qp_multiply; case GSR_VIDEO_QUALITY_HIGH: return 30 * qp_multiply; case GSR_VIDEO_QUALITY_VERY_HIGH: return 25 * qp_multiply; case GSR_VIDEO_QUALITY_ULTRA: return 22 * qp_multiply; } } else if(codec_context->codec_id == AV_CODEC_ID_VP8 || codec_context->codec_id == AV_CODEC_ID_VP9) { switch(video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: return 35 * qp_multiply; case GSR_VIDEO_QUALITY_HIGH: return 30 * qp_multiply; case GSR_VIDEO_QUALITY_VERY_HIGH: return 25 * qp_multiply; case GSR_VIDEO_QUALITY_ULTRA: return 22 * qp_multiply; } } assert(false); return 22 * qp_multiply; } static AVCodecContext *create_video_codec_context(AVPixelFormat pix_fmt, const AVCodec *codec, const gsr_egl &egl, const args_parser &arg_parser, int width, int height) { const bool use_software_video_encoder = arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU; const bool hdr = video_codec_is_hdr(arg_parser.video_codec); AVCodecContext *codec_context = avcodec_alloc_context3(codec); //double fps_ratio = (double)fps / 30.0; assert(codec->type == AVMEDIA_TYPE_VIDEO); codec_context->codec_id = codec->id; codec_context->width = width; codec_context->height = height; // Timebase: This is the fundamental unit of time (in seconds) in terms // of which frame timestamps are represented. For fixed-fps content, // timebase should be 1/framerate and timestamp increments should be // identical to 1 codec_context->time_base.num = 1; codec_context->time_base.den = arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONSTANT ? arg_parser.fps : AV_TIME_BASE; codec_context->framerate.num = arg_parser.fps; codec_context->framerate.den = 1; codec_context->sample_aspect_ratio.num = 0; codec_context->sample_aspect_ratio.den = 0; if(arg_parser.low_latency_recording) { codec_context->flags |= (AV_CODEC_FLAG_CLOSED_GOP | AV_CODEC_FLAG_LOW_DELAY); codec_context->flags2 |= AV_CODEC_FLAG2_FAST; //codec_context->gop_size = std::numeric_limits::max(); //codec_context->keyint_min = std::numeric_limits::max(); codec_context->gop_size = arg_parser.fps * arg_parser.keyint; } else { // High values reduce file size but increases time it takes to seek codec_context->gop_size = arg_parser.fps * arg_parser.keyint; } codec_context->max_b_frames = 0; codec_context->pix_fmt = pix_fmt; codec_context->color_range = arg_parser.color_range == GSR_COLOR_RANGE_LIMITED ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG; if(hdr) { codec_context->color_primaries = AVCOL_PRI_BT2020; codec_context->color_trc = AVCOL_TRC_SMPTE2084; codec_context->colorspace = AVCOL_SPC_BT2020_NCL; } else { codec_context->color_primaries = AVCOL_PRI_BT709; codec_context->color_trc = AVCOL_TRC_BT709; codec_context->colorspace = AVCOL_SPC_BT709; } //codec_context->chroma_sample_location = AVCHROMA_LOC_CENTER; // Can't use this because it's fucking broken in ffmpeg 8 or new mesa. It produces garbage output //if(codec->id == AV_CODEC_ID_HEVC) // codec_context->codec_tag = MKTAG('h', 'v', 'c', '1'); // QuickTime on MacOS requires this or the video wont be playable if(arg_parser.bitrate_mode == GSR_BITRATE_MODE_CBR) { codec_context->bit_rate = arg_parser.video_bitrate; codec_context->rc_max_rate = codec_context->bit_rate; //codec_context->rc_min_rate = codec_context->bit_rate; codec_context->rc_buffer_size = codec_context->bit_rate;//codec_context->bit_rate / 10; codec_context->rc_initial_buffer_occupancy = 0;//codec_context->bit_rate;//codec_context->bit_rate * 1000; } else if(arg_parser.bitrate_mode == GSR_BITRATE_MODE_VBR) { const int quality = vbr_get_quality_parameter(codec_context, arg_parser.video_quality, hdr); switch(arg_parser.video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: codec_context->qmin = quality; codec_context->qmax = quality; codec_context->bit_rate = 100000;//4500000 + (codec_context->width * codec_context->height)*0.75; break; case GSR_VIDEO_QUALITY_HIGH: codec_context->qmin = quality; codec_context->qmax = quality; codec_context->bit_rate = 100000;//10000000-9000000 + (codec_context->width * codec_context->height)*0.75; break; case GSR_VIDEO_QUALITY_VERY_HIGH: codec_context->qmin = quality; codec_context->qmax = quality; codec_context->bit_rate = 100000;//10000000-9000000 + (codec_context->width * codec_context->height)*0.75; break; case GSR_VIDEO_QUALITY_ULTRA: codec_context->qmin = quality; codec_context->qmax = quality; codec_context->bit_rate = 100000;//10000000-9000000 + (codec_context->width * codec_context->height)*0.75; break; } codec_context->rc_max_rate = codec_context->bit_rate; //codec_context->rc_min_rate = codec_context->bit_rate; codec_context->rc_buffer_size = codec_context->bit_rate;//codec_context->bit_rate / 10; codec_context->rc_initial_buffer_occupancy = codec_context->bit_rate;//codec_context->bit_rate * 1000; } else { //codec_context->rc_buffer_size = 50000 * 1000; } //codec_context->profile = FF_PROFILE_H264_MAIN; if (codec_context->codec_id == AV_CODEC_ID_MPEG1VIDEO) codec_context->mb_decision = 2; if(!use_software_video_encoder && (egl.gpu_info.vendor != GSR_GPU_VENDOR_NVIDIA || video_codec_is_vulkan(arg_parser.video_codec)) && arg_parser.bitrate_mode != GSR_BITRATE_MODE_CBR) { // 8 bit / 10 bit = 80%, and increase it even more const float quality_multiply = hdr ? (8.0f/10.0f * 0.7f) : 1.0f; if(codec_context->codec_id == AV_CODEC_ID_AV1 || codec_context->codec_id == AV_CODEC_ID_H264 || codec_context->codec_id == AV_CODEC_ID_HEVC) { switch(arg_parser.video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: codec_context->global_quality = 130 * quality_multiply; break; case GSR_VIDEO_QUALITY_HIGH: codec_context->global_quality = 110 * quality_multiply; break; case GSR_VIDEO_QUALITY_VERY_HIGH: codec_context->global_quality = 95 * quality_multiply; break; case GSR_VIDEO_QUALITY_ULTRA: codec_context->global_quality = 85 * quality_multiply; break; } } else if(codec_context->codec_id == AV_CODEC_ID_VP8) { switch(arg_parser.video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: codec_context->global_quality = 35 * quality_multiply; break; case GSR_VIDEO_QUALITY_HIGH: codec_context->global_quality = 30 * quality_multiply; break; case GSR_VIDEO_QUALITY_VERY_HIGH: codec_context->global_quality = 25 * quality_multiply; break; case GSR_VIDEO_QUALITY_ULTRA: codec_context->global_quality = 10 * quality_multiply; break; } } else if(codec_context->codec_id == AV_CODEC_ID_VP9) { switch(arg_parser.video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: codec_context->global_quality = 35 * quality_multiply; break; case GSR_VIDEO_QUALITY_HIGH: codec_context->global_quality = 30 * quality_multiply; break; case GSR_VIDEO_QUALITY_VERY_HIGH: codec_context->global_quality = 25 * quality_multiply; break; case GSR_VIDEO_QUALITY_ULTRA: codec_context->global_quality = 10 * quality_multiply; break; } } } av_opt_set_int(codec_context->priv_data, "b_ref_mode", 0, 0); //av_opt_set_int(codec_context->priv_data, "cbr", true, 0); if(egl.gpu_info.vendor != GSR_GPU_VENDOR_NVIDIA || video_codec_is_vulkan(arg_parser.video_codec)) { // TODO: More options, better options //codec_context->bit_rate = codec_context->width * codec_context->height; switch(arg_parser.bitrate_mode) { case GSR_BITRATE_MODE_QP: { if(video_codec_is_vulkan(arg_parser.video_codec)) av_opt_set(codec_context->priv_data, "rc_mode", "cqp", 0); else if(egl.gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) av_opt_set(codec_context->priv_data, "rc", "constqp", 0); else av_opt_set(codec_context->priv_data, "rc_mode", "CQP", 0); break; } case GSR_BITRATE_MODE_VBR: { if(video_codec_is_vulkan(arg_parser.video_codec)) av_opt_set(codec_context->priv_data, "rc_mode", "vbr", 0); else if(egl.gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) av_opt_set(codec_context->priv_data, "rc", "vbr", 0); else av_opt_set(codec_context->priv_data, "rc_mode", "VBR", 0); break; } case GSR_BITRATE_MODE_CBR: { if(video_codec_is_vulkan(arg_parser.video_codec)) av_opt_set(codec_context->priv_data, "rc_mode", "cbr", 0); else if(egl.gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) av_opt_set(codec_context->priv_data, "rc", "cbr", 0); else av_opt_set(codec_context->priv_data, "rc_mode", "CBR", 0); break; } } //codec_context->global_quality = 4; //codec_context->compression_level = 2; } //av_opt_set(codec_context->priv_data, "bsf", "hevc_metadata=colour_primaries=9:transfer_characteristics=16:matrix_coefficients=9", 0); if(arg_parser.tune == GSR_TUNE_QUALITY) codec_context->max_b_frames = 2; codec_context->flags |= AV_CODEC_FLAG_GLOBAL_HEADER; return codec_context; } static void open_audio(AVCodecContext *audio_codec_context, const char *ffmpeg_audio_opts) { AVDictionary *options = nullptr; av_dict_set(&options, "strict", "experimental", 0); if(ffmpeg_audio_opts) av_dict_parse_string(&options, ffmpeg_audio_opts, "=", ";", 0); int ret; ret = avcodec_open2(audio_codec_context, audio_codec_context->codec, &options); if(ret < 0) { fprintf(stderr, "failed to open codec, reason: %s\n", av_error_to_string(ret)); _exit(1); } } static AVFrame* create_audio_frame(AVCodecContext *audio_codec_context) { AVFrame *frame = av_frame_alloc(); if(!frame) { fprintf(stderr, "failed to allocate audio frame\n"); _exit(1); } frame->sample_rate = audio_codec_context->sample_rate; frame->nb_samples = audio_codec_context->frame_size; frame->format = audio_codec_context->sample_fmt; #if LIBAVCODEC_VERSION_MAJOR < 60 frame->channels = audio_codec_context->channels; frame->channel_layout = audio_codec_context->channel_layout; #else av_channel_layout_copy(&frame->ch_layout, &audio_codec_context->ch_layout); #endif int ret = av_frame_get_buffer(frame, 0); if(ret < 0) { fprintf(stderr, "failed to allocate audio data buffers, reason: %s\n", av_error_to_string(ret)); _exit(1); } return frame; } static void dict_set_profile(AVCodecContext *codec_context, gsr_gpu_vendor vendor, gsr_color_depth color_depth, gsr_video_codec video_codec, AVDictionary **options) { #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(61, 17, 100) if(codec_context->codec_id == AV_CODEC_ID_H264) { // TODO: Only for vaapi //if(color_depth == GSR_COLOR_DEPTH_10_BITS) // av_dict_set(options, "profile", "high10", 0); //else av_dict_set(options, "profile", "high", 0); } else if(codec_context->codec_id == AV_CODEC_ID_AV1) { if(vendor == GSR_GPU_VENDOR_NVIDIA) { if(color_depth == GSR_COLOR_DEPTH_10_BITS) av_dict_set_int(options, "highbitdepth", 1, 0); } else { av_dict_set(options, "profile", "main", 0); // TODO: use professional instead? } } else if(codec_context->codec_id == AV_CODEC_ID_HEVC) { if(color_depth == GSR_COLOR_DEPTH_10_BITS) av_dict_set(options, "profile", "main10", 0); else av_dict_set(options, "profile", "main", 0); } #else const bool use_nvidia_values = vendor == GSR_GPU_VENDOR_NVIDIA && !video_codec_is_vulkan(video_codec); if(codec_context->codec_id == AV_CODEC_ID_H264) { // TODO: Only for vaapi //if(color_depth == GSR_COLOR_DEPTH_10_BITS) // av_dict_set_int(options, "profile", AV_PROFILE_H264_HIGH_10, 0); //else av_dict_set_int(options, "profile", use_nvidia_values ? 2 : AV_PROFILE_H264_HIGH, 0); } else if(codec_context->codec_id == AV_CODEC_ID_AV1) { if(use_nvidia_values) { if(color_depth == GSR_COLOR_DEPTH_10_BITS) av_dict_set_int(options, "highbitdepth", 1, 0); } else { av_dict_set_int(options, "profile", AV_PROFILE_AV1_MAIN, 0); // TODO: use professional instead? } } else if(codec_context->codec_id == AV_CODEC_ID_HEVC) { if(color_depth == GSR_COLOR_DEPTH_10_BITS) av_dict_set_int(options, "profile", use_nvidia_values ? 1 : AV_PROFILE_HEVC_MAIN_10, 0); else av_dict_set_int(options, "profile", use_nvidia_values ? 0 : AV_PROFILE_HEVC_MAIN, 0); } #endif } static void video_software_set_qp(AVCodecContext *codec_context, gsr_video_quality video_quality, bool hdr, AVDictionary **options) { // 8 bit / 10 bit = 80% const float qp_multiply = hdr ? 8.0f/10.0f : 1.0f; switch(video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: av_dict_set_int(options, "qp", 35 * qp_multiply, 0); break; case GSR_VIDEO_QUALITY_HIGH: av_dict_set_int(options, "qp", 30 * qp_multiply, 0); break; case GSR_VIDEO_QUALITY_VERY_HIGH: av_dict_set_int(options, "qp", 25 * qp_multiply, 0); break; case GSR_VIDEO_QUALITY_ULTRA: av_dict_set_int(options, "qp", 22 * qp_multiply, 0); break; } } static void open_video_software(AVCodecContext *codec_context, const args_parser &arg_parser) { const bool hdr = video_codec_is_hdr(arg_parser.video_codec); AVDictionary *options = nullptr; if(arg_parser.bitrate_mode == GSR_BITRATE_MODE_QP) video_software_set_qp(codec_context, arg_parser.video_quality, hdr, &options); av_dict_set(&options, "preset", "veryfast", 0); av_dict_set(&options, "tune", "film", 0); av_dict_set_int(&options, "forced-idr", 1, 0); if(codec_context->codec_id == AV_CODEC_ID_H264) { av_dict_set(&options, "coder", "cabac", 0); // TODO: cavlc is faster than cabac but worse compression. Which to use? } av_dict_set(&options, "strict", "experimental", 0); if(arg_parser.ffmpeg_video_opts) av_dict_parse_string(&options, arg_parser.ffmpeg_video_opts, "=", ";", 0); int ret = avcodec_open2(codec_context, codec_context->codec, &options); if (ret < 0) { fprintf(stderr, "gsr error: Could not open video codec: %s\n", av_error_to_string(ret)); _exit(1); } } static void video_set_rc(gsr_video_codec video_codec, gsr_gpu_vendor vendor, gsr_bitrate_mode bitrate_mode, AVDictionary **options) { switch(bitrate_mode) { case GSR_BITRATE_MODE_QP: { if(video_codec_is_vulkan(video_codec)) av_dict_set(options, "rc_mode", "cqp", 0); else if(vendor == GSR_GPU_VENDOR_NVIDIA) av_dict_set(options, "rc", "constqp", 0); else av_dict_set(options, "rc_mode", "CQP", 0); break; } case GSR_BITRATE_MODE_VBR: { if(video_codec_is_vulkan(video_codec)) av_dict_set(options, "rc_mode", "vbr", 0); else if(vendor == GSR_GPU_VENDOR_NVIDIA) av_dict_set(options, "rc", "vbr", 0); else av_dict_set(options, "rc_mode", "VBR", 0); break; } case GSR_BITRATE_MODE_CBR: { if(video_codec_is_vulkan(video_codec)) av_dict_set(options, "rc_mode", "cbr", 0); else if(vendor == GSR_GPU_VENDOR_NVIDIA) av_dict_set(options, "rc", "cbr", 0); else av_dict_set(options, "rc_mode", "CBR", 0); break; } } } static void video_hardware_set_qp(AVCodecContext *codec_context, gsr_video_quality video_quality, gsr_gpu_vendor vendor, bool hdr, AVDictionary **options) { // 8 bit / 10 bit = 80% const float qp_multiply = hdr ? 8.0f/10.0f : 1.0f; switch(video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: av_dict_set_int(options, "qp", 35 * qp_multiply, 0); break; case GSR_VIDEO_QUALITY_HIGH: av_dict_set_int(options, "qp", 30 * qp_multiply, 0); break; case GSR_VIDEO_QUALITY_VERY_HIGH: av_dict_set_int(options, "qp", 25 * qp_multiply, 0); break; case GSR_VIDEO_QUALITY_ULTRA: av_dict_set_int(options, "qp", 22 * qp_multiply, 0); break; } } static void open_video_hardware(AVCodecContext *codec_context, bool low_power, const gsr_egl &egl, const args_parser &arg_parser) { const gsr_color_depth color_depth = video_codec_to_bit_depth(arg_parser.video_codec); const bool hdr = video_codec_is_hdr(arg_parser.video_codec); AVDictionary *options = nullptr; if(arg_parser.bitrate_mode == GSR_BITRATE_MODE_QP) video_hardware_set_qp(codec_context, arg_parser.video_quality, egl.gpu_info.vendor, hdr, &options); video_set_rc(arg_parser.video_codec, egl.gpu_info.vendor, arg_parser.bitrate_mode, &options); // TODO: Enable multipass dict_set_profile(codec_context, egl.gpu_info.vendor, color_depth, arg_parser.video_codec, &options); if(video_codec_is_vulkan(arg_parser.video_codec)) { av_dict_set_int(&options, "async_depth", 3, 0); av_dict_set(&options, "tune", "ll", 0); // Low latency av_dict_set(&options, "usage", arg_parser.is_livestream ? "stream" : "record", 0); av_dict_set(&options, "content", "rendered", 0); // Game or 3D content if(codec_context->codec_id == AV_CODEC_ID_H264) { // Removed because it causes stutter in games for some people //av_dict_set_int(&options, "quality", 5, 0); // quality preset } else if(codec_context->codec_id == AV_CODEC_ID_AV1) { av_dict_set(&options, "tier", "main", 0); } else if(codec_context->codec_id == AV_CODEC_ID_HEVC) { if(hdr) av_dict_set(&options, "sei", "hdr", 0); } } else if(egl.gpu_info.vendor == GSR_GPU_VENDOR_NVIDIA) { // TODO: These dont seem to be necessary // av_dict_set_int(&options, "zerolatency", 1, 0); // if(codec_context->codec_id == AV_CODEC_ID_AV1) { // av_dict_set(&options, "tune", "ll", 0); // } else if(codec_context->codec_id == AV_CODEC_ID_H264 || codec_context->codec_id == AV_CODEC_ID_HEVC) { // av_dict_set(&options, "preset", "llhq", 0); // av_dict_set(&options, "tune", "ll", 0); // } av_dict_set(&options, "tune", "ll", 0); av_dict_set_int(&options, "forced-idr", 1, 0); switch(arg_parser.tune) { case GSR_TUNE_PERFORMANCE: //av_dict_set(&options, "multipass", "qres", 0); break; case GSR_TUNE_QUALITY: av_dict_set(&options, "multipass", "fullres", 0); av_dict_set(&options, "preset", "p6", 0); av_dict_set_int(&options, "rc-lookahead", 0, 0); break; } if(codec_context->codec_id == AV_CODEC_ID_H264) { // TODO: h264 10bit? // TODO: // switch(pixel_format) { // case GSR_PIXEL_FORMAT_YUV420: // av_dict_set_int(&options, "profile", AV_PROFILE_H264_HIGH, 0); // break; // case GSR_PIXEL_FORMAT_YUV444: // av_dict_set_int(&options, "profile", AV_PROFILE_H264_HIGH_444, 0); // break; // } } else if(codec_context->codec_id == AV_CODEC_ID_AV1) { switch(arg_parser.pixel_format) { case GSR_PIXEL_FORMAT_YUV420: av_dict_set(&options, "rgb_mode", "yuv420", 0); break; case GSR_PIXEL_FORMAT_YUV444: av_dict_set(&options, "rgb_mode", "yuv444", 0); break; } } else if(codec_context->codec_id == AV_CODEC_ID_HEVC) { //av_dict_set(&options, "pix_fmt", "yuv420p16le", 0); } } else { // TODO: More quality options if(low_power) av_dict_set_int(&options, "low_power", 1, 0); // Improves performance but increases vram. // TODO: Might need a different async_depth for optimal performance on different amd/intel gpus av_dict_set_int(&options, "async_depth", 3, 0); if(codec_context->codec_id == AV_CODEC_ID_H264) { // Removed because it causes stutter in games for some people //av_dict_set_int(&options, "quality", 5, 0); // quality preset } else if(codec_context->codec_id == AV_CODEC_ID_AV1) { av_dict_set(&options, "tier", "main", 0); } else if(codec_context->codec_id == AV_CODEC_ID_HEVC) { if(hdr) av_dict_set(&options, "sei", "hdr", 0); } // TODO: vp8/vp9 10bit } if(codec_context->codec_id == AV_CODEC_ID_H264) { av_dict_set(&options, "coder", "cabac", 0); // TODO: cavlc is faster than cabac but worse compression. Which to use? } av_dict_set(&options, "strict", "experimental", 0); if(arg_parser.ffmpeg_video_opts) av_dict_parse_string(&options, arg_parser.ffmpeg_video_opts, "=", ";", 0); int ret = avcodec_open2(codec_context, codec_context->codec, &options); if (ret < 0) { fprintf(stderr, "gsr error: Could not open video codec: %s\n", av_error_to_string(ret)); _exit(1); } } static const int save_replay_seconds_full = -1; static sig_atomic_t running = 1; static sig_atomic_t toggle_pause = 0; static sig_atomic_t toggle_replay_recording = 0; static sig_atomic_t save_replay_seconds = 0; static void stop_handler(int) { running = 0; } static void toggle_pause_handler(int) { toggle_pause = 1; } static void toggle_replay_recording_handler(int) { toggle_replay_recording = 1; } static void save_replay_handler(int) { save_replay_seconds = save_replay_seconds_full; } static void save_replay_10_seconds_handler(int) { save_replay_seconds = 10; } static void save_replay_30_seconds_handler(int) { save_replay_seconds = 30; } static void save_replay_1_minute_handler(int) { save_replay_seconds = 60; } static void save_replay_5_minutes_handler(int) { save_replay_seconds = 60*5; } static void save_replay_10_minutes_handler(int) { save_replay_seconds = 60*10; } static void save_replay_30_minutes_handler(int) { save_replay_seconds = 60*30; } static std::string get_date_str() { char str[128]; time_t now = time(NULL); struct tm *t = localtime(&now); strftime(str, sizeof(str)-1, "%Y-%m-%d_%H-%M-%S", t); return str; } static std::string get_date_only_str() { char str[128]; time_t now = time(NULL); struct tm *t = localtime(&now); strftime(str, sizeof(str)-1, "%Y-%m-%d", t); return str; } static std::string get_time_only_str() { char str[128]; time_t now = time(NULL); struct tm *t = localtime(&now); strftime(str, sizeof(str)-1, "%H-%M-%S", t); return str; } static AVStream* create_stream(AVFormatContext *av_format_context, AVCodecContext *codec_context) { AVStream *stream = avformat_new_stream(av_format_context, nullptr); if (!stream) { fprintf(stderr, "gsr error: Could not allocate stream\n"); _exit(1); } stream->id = av_format_context->nb_streams - 1; stream->time_base = codec_context->time_base; stream->avg_frame_rate = codec_context->framerate; //stream->r_frame_rate = codec_context->framerate; return stream; } static void run_recording_saved_script_async(const char *script_file, const char *video_file, const char *type) { char script_file_full[PATH_MAX]; script_file_full[0] = '\0'; if(!realpath(script_file, script_file_full)) { fprintf(stderr, "gsr error: script file not found: %s\n", script_file); return; } const char *args[7]; const bool inside_flatpak = getenv("FLATPAK_ID") != NULL; if(inside_flatpak) { args[0] = "flatpak-spawn"; args[1] = "--host"; args[2] = "--"; args[3] = script_file_full; args[4] = video_file; args[5] = type; args[6] = NULL; } else { args[0] = script_file_full; args[1] = video_file; args[2] = type; args[3] = NULL; } pid_t pid = fork(); if(pid == -1) { perror(script_file_full); return; } else if(pid == 0) { // child setsid(); signal(SIGHUP, SIG_IGN); pid_t second_child = fork(); if(second_child == 0) { // child execvp(args[0], (char* const*)args); perror(script_file_full); _exit(127); } else if(second_child != -1) { // parent _exit(0); } } else { // parent waitpid(pid, NULL, 0); } } static double audio_codec_get_desired_delay(gsr_audio_codec audio_codec, int fps) { const double fps_inv = 1.0 / (double)fps; const double base = 0.01 + 1.0/165.0; switch(audio_codec) { case GSR_AUDIO_CODEC_OPUS: return std::max(0.0, base - fps_inv); case GSR_AUDIO_CODEC_AAC: return std::max(0.0, (base + 0.008) * 2.0 - fps_inv); case GSR_AUDIO_CODEC_FLAC: // TODO: Test return std::max(0.0, base - fps_inv); } assert(false); return std::max(0.0, base - fps_inv); } struct AudioDeviceData { SoundDevice sound_device; AudioInput audio_input; AVFilterContext *src_filter_ctx = nullptr; AVFrame *frame = nullptr; std::thread thread; // TODO: Instead of having a thread for each track, have one thread for all threads and read the data with non-blocking read }; // TODO: Cleanup struct AudioTrack { std::string name; AVCodecContext *codec_context = nullptr; std::vector audio_devices; AVFilterGraph *graph = nullptr; AVFilterContext *sink = nullptr; int stream_index = 0; int64_t pts = 0; }; static bool add_hdr_metadata_to_video_stream(gsr_capture *cap, AVStream *video_stream) { size_t light_metadata_size = 0; size_t mastering_display_metadata_size = 0; AVContentLightMetadata *light_metadata = av_content_light_metadata_alloc(&light_metadata_size); #if LIBAVUTIL_VERSION_INT < AV_VERSION_INT(59, 37, 100) AVMasteringDisplayMetadata *mastering_display_metadata = av_mastering_display_metadata_alloc(); mastering_display_metadata_size = sizeof(*mastering_display_metadata); #else AVMasteringDisplayMetadata *mastering_display_metadata = av_mastering_display_metadata_alloc_size(&mastering_display_metadata_size); #endif if(!light_metadata || !mastering_display_metadata) { if(light_metadata) av_freep(&light_metadata); if(mastering_display_metadata) av_freep(&mastering_display_metadata); return false; } if(!gsr_capture_set_hdr_metadata(cap, mastering_display_metadata, light_metadata)) { av_freep(&light_metadata); av_freep(&mastering_display_metadata); return false; } // TODO: More error checking #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102) const bool content_light_level_added = av_stream_add_side_data(video_stream, AV_PKT_DATA_CONTENT_LIGHT_LEVEL, (uint8_t*)light_metadata, light_metadata_size) == 0; #else const bool content_light_level_added = av_packet_side_data_add(&video_stream->codecpar->coded_side_data, &video_stream->codecpar->nb_coded_side_data, AV_PKT_DATA_CONTENT_LIGHT_LEVEL, light_metadata, light_metadata_size, 0) != NULL; #endif #if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(60, 31, 102) const bool mastering_display_metadata_added = av_stream_add_side_data(video_stream, AV_PKT_DATA_MASTERING_DISPLAY_METADATA, (uint8_t*)mastering_display_metadata, mastering_display_metadata_size) == 0; #else const bool mastering_display_metadata_added = av_packet_side_data_add(&video_stream->codecpar->coded_side_data, &video_stream->codecpar->nb_coded_side_data, AV_PKT_DATA_MASTERING_DISPLAY_METADATA, mastering_display_metadata, mastering_display_metadata_size, 0) != NULL; #endif if(!content_light_level_added) av_freep(&light_metadata); if(!mastering_display_metadata_added) av_freep(&mastering_display_metadata); // Return true even on failure because we dont want to retry adding hdr metadata on failure return true; } static void set_format_context_options(AVFormatContext *av_format_context) { bool hybrid_fragmented_available = false; av_opt_set(av_format_context->priv_data, "use_editlist", "1", 0); const AVOption *opt = av_opt_find(av_format_context->priv_data, "movflags", NULL, 0, 0); if (opt && opt->unit) { const AVOption *flag = av_opt_find(av_format_context->priv_data, "hybrid_fragmented", opt->unit, 0, 0); if (flag) { hybrid_fragmented_available = true; av_opt_set(av_format_context->priv_data, "movflags", "+hybrid_fragmented", 0); } } if(!hybrid_fragmented_available) fprintf(stderr, "gsr warning: hybrid_fragmented movflags is not available in your FFmpeg version. If you experience stutter in the mp4 file then update your FFmpeg or record to a mkv file\n"); } struct RecordingStartAudio { const AudioTrack *audio_track; AVStream *stream; }; struct RecordingStartResult { AVFormatContext *av_format_context = nullptr; AVStream *video_stream = nullptr; std::vector audio_inputs; }; typedef enum { VVEC2I_TYPE_PIXELS, VVEC2I_TYPE_SCALAR } vvec2i_type; typedef struct { int x, y; vvec2i_type x_type; vvec2i_type y_type; } vvec2i; struct CaptureSource { std::string name; CaptureSourceType type = GSR_CAPTURE_SOURCE_TYPE_WINDOW; gsr_capture_alignment halign = GSR_CAPTURE_ALIGN_CENTER; gsr_capture_alignment valign = GSR_CAPTURE_ALIGN_CENTER; gsr_capture_v4l2_pixfmt v4l2_pixfmt = GSR_CAPTURE_V4L2_PIXFMT_AUTO; uint32_t flip = GSR_FLIP_NONE; vvec2i pos = {0, 0, VVEC2I_TYPE_PIXELS, VVEC2I_TYPE_PIXELS}; vvec2i size = {100, 100, VVEC2I_TYPE_SCALAR, VVEC2I_TYPE_SCALAR}; vec2i region_pos = {0, 0}; vec2i region_size = {0, 0}; bool region_set = false; int64_t window_id = 0; int camera_fps = 0; vec2i camera_resolution = {0, 0}; }; struct VideoSource { gsr_capture *capture; gsr_capture_metadata metadata; CaptureSource *capture_source; }; static RecordingStartResult start_recording_create_streams(const char *filename, const args_parser &arg_parser, AVCodecContext *video_codec_context, const std::vector &audio_tracks, bool hdr, std::vector &video_sources) { AVFormatContext *av_format_context; avformat_alloc_output_context2(&av_format_context, nullptr, arg_parser.container_format, filename); set_format_context_options(av_format_context); AVStream *video_stream = create_stream(av_format_context, video_codec_context); avcodec_parameters_from_context(video_stream->codecpar, video_codec_context); RecordingStartResult result; result.audio_inputs.reserve(audio_tracks.size()); for(const AudioTrack &audio_track : audio_tracks) { AVStream *audio_stream = create_stream(av_format_context, audio_track.codec_context); if(!audio_track.name.empty()) av_dict_set(&audio_stream->metadata, "title", audio_track.name.c_str(), 0); avcodec_parameters_from_context(audio_stream->codecpar, audio_track.codec_context); result.audio_inputs.push_back({&audio_track, audio_stream}); } const int open_ret = avio_open(&av_format_context->pb, filename, AVIO_FLAG_WRITE); if(open_ret < 0) { fprintf(stderr, "gsr error: start: could not open '%s': %s\n", filename, av_error_to_string(open_ret)); return result; } AVDictionary *options = nullptr; av_dict_set(&options, "strict", "experimental", 0); if(arg_parser.ffmpeg_opts) av_dict_parse_string(&options, arg_parser.ffmpeg_opts, "=", ";", 0); const int header_write_ret = avformat_write_header(av_format_context, &options); av_dict_free(&options); if(header_write_ret < 0) { fprintf(stderr, "gsr error: start: error occurred when writing header to output file: %s\n", av_error_to_string(header_write_ret)); avio_close(av_format_context->pb); avformat_free_context(av_format_context); return result; } for(VideoSource &video_source : video_sources) { if(hdr && add_hdr_metadata_to_video_stream(video_source.capture, video_stream)) break; } result.av_format_context = av_format_context; result.video_stream = video_stream; return result; } static bool stop_recording_close_streams(AVFormatContext *av_format_context) { bool trailer_written = true; if(av_write_trailer(av_format_context) != 0) { //fprintf(stderr, "gsr error: end: failed to write trailer\n"); //trailer_written = false; } const bool closed = avio_close(av_format_context->pb) == 0; avformat_free_context(av_format_context); return trailer_written && closed; } static std::future save_replay_thread; static std::string save_replay_output_filepath; static std::string create_new_recording_filepath_from_timestamp(std::string directory, const char *filename_prefix, const std::string &file_extension, bool date_folders) { std::string output_filepath; if(date_folders) { std::string output_folder = directory + '/' + get_date_only_str(); if(create_directory_recursive(&output_folder[0]) != 0) fprintf(stderr, "gsr error: failed to create directory: %s\n", output_folder.c_str()); output_filepath = output_folder + "/" + filename_prefix + "_" + get_time_only_str() + "." + file_extension; } else { if(create_directory_recursive(&directory[0]) != 0) fprintf(stderr, "gsr error: failed to create directory: %s\n", directory.c_str()); output_filepath = directory + "/" + filename_prefix + "_" + get_date_str() + "." + file_extension; } return output_filepath; } static RecordingStartAudio* get_recording_start_item_by_stream_index(RecordingStartResult &result, int stream_index) { for(auto &audio_input : result.audio_inputs) { if(audio_input.stream->index == stream_index) return &audio_input; } return nullptr; } struct AudioPtsOffset { int64_t pts_offset = 0; int stream_index = 0; }; static void save_replay_async(AVCodecContext *video_codec_context, int video_stream_index, const std::vector &audio_tracks, gsr_encoder *encoder, const args_parser &arg_parser, const std::string &file_extension, bool date_folders, bool hdr, std::vector &video_sources, int current_save_replay_seconds) { if(save_replay_thread.valid()) return; pthread_mutex_lock(&encoder->replay_mutex); gsr_replay_buffer *cloned_replay_buffer = gsr_replay_buffer_clone(encoder->replay_buffer); pthread_mutex_unlock(&encoder->replay_mutex); if(!cloned_replay_buffer) { // TODO: Return this error to mark the replay as failed fprintf(stderr, "gsr error: failed to save replay: failed to clone replay buffer\n"); return; } const gsr_replay_buffer_iterator search_start_iterator = current_save_replay_seconds == save_replay_seconds_full ? gsr_replay_buffer_iterator{0, 0} : gsr_replay_buffer_find_packet_index_by_time_passed(cloned_replay_buffer, current_save_replay_seconds); const gsr_replay_buffer_iterator video_start_iterator = gsr_replay_buffer_find_keyframe(cloned_replay_buffer, search_start_iterator, video_stream_index, false); if(video_start_iterator.packet_index == (size_t)-1) { fprintf(stderr, "gsr error: failed to save replay: failed to find a video keyframe. perhaps replay was saved too fast, before anything has been recorded\n"); pthread_mutex_lock(&encoder->replay_mutex); gsr_replay_buffer_destroy(cloned_replay_buffer); pthread_mutex_unlock(&encoder->replay_mutex); return; } const int64_t video_pts_offset = gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, video_start_iterator)->pts; std::vector audio_pts_offsets; audio_pts_offsets.reserve(audio_tracks.size()); for(const AudioTrack &audio_track : audio_tracks) { const gsr_replay_buffer_iterator audio_start_iterator = gsr_replay_buffer_find_keyframe(cloned_replay_buffer, video_start_iterator, audio_track.stream_index, false); const int64_t audio_pts_offset = audio_start_iterator.packet_index == (size_t)-1 ? 0 : gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, audio_start_iterator)->pts; audio_pts_offsets.push_back(AudioPtsOffset{audio_pts_offset, audio_track.stream_index}); } std::string output_filepath = create_new_recording_filepath_from_timestamp(arg_parser.filename, "Replay", file_extension, date_folders); RecordingStartResult recording_start_result = start_recording_create_streams(output_filepath.c_str(), arg_parser, video_codec_context, audio_tracks, hdr, video_sources); if(!recording_start_result.av_format_context) { pthread_mutex_lock(&encoder->replay_mutex); gsr_replay_buffer_destroy(cloned_replay_buffer); pthread_mutex_unlock(&encoder->replay_mutex); return; } save_replay_output_filepath = std::move(output_filepath); save_replay_thread = std::async(std::launch::async, [video_stream_index, recording_start_result, video_start_iterator, video_pts_offset, audio_pts_offsets{std::move(audio_pts_offsets)}, video_codec_context, cloned_replay_buffer, encoder]() mutable { gsr_replay_buffer_iterator replay_iterator = video_start_iterator; for(;;) { AVPacket *replay_packet = gsr_replay_buffer_iterator_get_packet(cloned_replay_buffer, replay_iterator); uint8_t *replay_packet_data = NULL; if(replay_packet) { pthread_mutex_lock(&encoder->replay_mutex); replay_packet_data = gsr_replay_buffer_iterator_get_packet_data(cloned_replay_buffer, replay_iterator); pthread_mutex_unlock(&encoder->replay_mutex); } if(!replay_packet) { fprintf(stderr, "gsr error: save_replay_async: no replay packet\n"); break; } if(!replay_packet->data && !replay_packet_data) { fprintf(stderr, "gsr error: save_replay_async: no replay packet data\n"); break; } // TODO: Check if successful AVPacket av_packet; memset(&av_packet, 0, sizeof(av_packet)); //av_packet_from_data(av_packet, replay_packet->data, replay_packet->size); av_packet.data = replay_packet->data ? replay_packet->data : replay_packet_data; av_packet.size = replay_packet->size; av_packet.stream_index = replay_packet->stream_index; av_packet.pts = replay_packet->pts; av_packet.dts = replay_packet->pts; av_packet.flags = replay_packet->flags; //av_packet.duration = replay_packet->duration; AVStream *stream = recording_start_result.video_stream; AVCodecContext *codec_context = video_codec_context; if(av_packet.stream_index == video_stream_index) { av_packet.pts -= video_pts_offset; av_packet.dts -= video_pts_offset; } else { RecordingStartAudio *recording_start_audio = get_recording_start_item_by_stream_index(recording_start_result, av_packet.stream_index); if(!recording_start_audio) { fprintf(stderr, "gsr error: save_replay_async: failed to find audio stream by index: %d\n", av_packet.stream_index); free(replay_packet_data); continue; } const AudioTrack *audio_track = recording_start_audio->audio_track; stream = recording_start_audio->stream; codec_context = audio_track->codec_context; const AudioPtsOffset &audio_pts_offset = audio_pts_offsets[av_packet.stream_index - 1]; assert(audio_pts_offset.stream_index == av_packet.stream_index); av_packet.pts -= audio_pts_offset.pts_offset; av_packet.dts -= audio_pts_offset.pts_offset; } //av_packet.stream_index = stream->index; av_packet_rescale_ts(&av_packet, codec_context->time_base, stream->time_base); const int ret = av_write_frame(recording_start_result.av_format_context, &av_packet); if(ret < 0) fprintf(stderr, "gsr error: Failed to write frame index %d to muxer, reason: %s (%d)\n", av_packet.stream_index, av_error_to_string(ret), ret); free(replay_packet_data); //av_packet_free(&av_packet); if(!gsr_replay_buffer_iterator_next(cloned_replay_buffer, &replay_iterator)) break; } stop_recording_close_streams(recording_start_result.av_format_context); pthread_mutex_lock(&encoder->replay_mutex); gsr_replay_buffer_destroy(cloned_replay_buffer); pthread_mutex_unlock(&encoder->replay_mutex); }); } static void split_string(const std::string &str, char delimiter, std::function callback) { size_t index = 0; while(index < str.size()) { size_t end_index = str.find(delimiter, index); if(end_index == std::string::npos) end_index = str.size(); if(!callback(&str[index], end_index - index)) break; index = end_index + 1; } } static bool string_starts_with(const char *str, size_t str_size, const char *substr) { int len = strlen(substr); return (int)str_size >= len && memcmp(str, substr, len) == 0; } static bool string_starts_with(const std::string &str, const char *substr) { return string_starts_with(str.data(), str.size(), substr); } static bool string_ends_with(const char *str, const char *substr) { int str_len = strlen(str); int substr_len = strlen(substr); return str_len >= substr_len && memcmp(str + str_len - substr_len, substr, substr_len) == 0; } static const AudioDevice* get_audio_device_by_name(const std::vector &audio_devices, const char *name) { for(const auto &audio_device : audio_devices) { if(strcmp(audio_device.name.c_str(), name) == 0) return &audio_device; } return nullptr; } static MergedAudioInputs parse_audio_input_arg(const char *str) { MergedAudioInputs result; result.track_name = str; split_string(str, '|', [&](const char *sub, size_t size) { if(size == 0) return true; AudioInput audio_input; audio_input.name.assign(sub, size); if(string_starts_with(audio_input.name.c_str(), "app:")) { audio_input.name.erase(audio_input.name.begin(), audio_input.name.begin() + 4); audio_input.type = AudioInputType::APPLICATION; audio_input.inverted = false; result.audio_inputs.push_back(std::move(audio_input)); return true; } else if(string_starts_with(audio_input.name.c_str(), "app-inverse:")) { audio_input.name.erase(audio_input.name.begin(), audio_input.name.begin() + 12); audio_input.type = AudioInputType::APPLICATION; audio_input.inverted = true; result.audio_inputs.push_back(std::move(audio_input)); return true; } else if(string_starts_with(audio_input.name.c_str(), "device:")) { audio_input.name.erase(audio_input.name.begin(), audio_input.name.begin() + 7); audio_input.type = AudioInputType::DEVICE; result.audio_inputs.push_back(std::move(audio_input)); return true; } else { audio_input.type = AudioInputType::DEVICE; result.audio_inputs.push_back(std::move(audio_input)); return true; } }); return result; } static int init_filter_graph(AVCodecContext* audio_codec_context, AVFilterGraph** graph, AVFilterContext** sink, std::vector& src_filter_ctx, size_t num_sources) { char ch_layout[64]; int err = 0; ch_layout[0] = '\0'; // C89-style variable declaration to // avoid problems because of goto AVFilterGraph* filter_graph = nullptr; AVFilterContext* mix_ctx = nullptr; const AVFilter* mix_filter = nullptr; const AVFilter* abuffersink = nullptr; AVFilterContext* abuffersink_ctx = nullptr; char args[512] = { 0 }; #if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(7, 107, 100) bool normalize = false; #endif filter_graph = avfilter_graph_alloc(); if (!filter_graph) { fprintf(stderr, "Unable to create filter graph.\n"); err = AVERROR(ENOMEM); goto fail; } for(size_t i = 0; i < num_sources; ++i) { const AVFilter *abuffer = avfilter_get_by_name("abuffer"); if (!abuffer) { fprintf(stderr, "Could not find the abuffer filter.\n"); err = AVERROR_FILTER_NOT_FOUND; goto fail; } AVFilterContext *abuffer_ctx = avfilter_graph_alloc_filter(filter_graph, abuffer, NULL); if (!abuffer_ctx) { fprintf(stderr, "Could not allocate the abuffer instance.\n"); err = AVERROR(ENOMEM); goto fail; } #if LIBAVCODEC_VERSION_MAJOR < 60 av_get_channel_layout_string(ch_layout, sizeof(ch_layout), 0, AV_CH_LAYOUT_STEREO); #else av_channel_layout_describe(&audio_codec_context->ch_layout, ch_layout, sizeof(ch_layout)); #endif av_opt_set (abuffer_ctx, "channel_layout", ch_layout, AV_OPT_SEARCH_CHILDREN); av_opt_set (abuffer_ctx, "sample_fmt", av_get_sample_fmt_name(audio_codec_context->sample_fmt), AV_OPT_SEARCH_CHILDREN); av_opt_set_q (abuffer_ctx, "time_base", audio_codec_context->time_base, AV_OPT_SEARCH_CHILDREN); av_opt_set_int(abuffer_ctx, "sample_rate", audio_codec_context->sample_rate, AV_OPT_SEARCH_CHILDREN); av_opt_set_int(abuffer_ctx, "bit_rate", audio_codec_context->bit_rate, AV_OPT_SEARCH_CHILDREN); err = avfilter_init_str(abuffer_ctx, NULL); if (err < 0) { fprintf(stderr, "Could not initialize the abuffer filter.\n"); goto fail; } src_filter_ctx.push_back(abuffer_ctx); } mix_filter = avfilter_get_by_name("amix"); if (!mix_filter) { av_log(NULL, AV_LOG_ERROR, "Could not find the mix filter.\n"); err = AVERROR_FILTER_NOT_FOUND; goto fail; } #if LIBAVFILTER_VERSION_INT >= AV_VERSION_INT(7, 107, 100) snprintf(args, sizeof(args), "inputs=%d:normalize=%s", (int)num_sources, normalize ? "true" : "false"); #else snprintf(args, sizeof(args), "inputs=%d", (int)num_sources); fprintf(stderr, "gsr warning: your ffmpeg version doesn't support disabling normalizing of mixed audio. Volume might be lower than expected\n"); #endif err = avfilter_graph_create_filter(&mix_ctx, mix_filter, "amix", args, NULL, filter_graph); if (err < 0) { av_log(NULL, AV_LOG_ERROR, "Cannot create audio amix filter\n"); goto fail; } abuffersink = avfilter_get_by_name("abuffersink"); if (!abuffersink) { fprintf(stderr, "Could not find the abuffersink filter.\n"); err = AVERROR_FILTER_NOT_FOUND; goto fail; } abuffersink_ctx = avfilter_graph_alloc_filter(filter_graph, abuffersink, "sink"); if (!abuffersink_ctx) { fprintf(stderr, "Could not allocate the abuffersink instance.\n"); err = AVERROR(ENOMEM); goto fail; } err = avfilter_init_str(abuffersink_ctx, NULL); if (err < 0) { fprintf(stderr, "Could not initialize the abuffersink instance.\n"); goto fail; } err = 0; for(size_t i = 0; i < src_filter_ctx.size(); ++i) { AVFilterContext *src_ctx = src_filter_ctx[i]; if (err >= 0) err = avfilter_link(src_ctx, 0, mix_ctx, i); } if (err >= 0) err = avfilter_link(mix_ctx, 0, abuffersink_ctx, 0); if (err < 0) { av_log(NULL, AV_LOG_ERROR, "Error connecting filters\n"); goto fail; } err = avfilter_graph_config(filter_graph, NULL); if (err < 0) { av_log(NULL, AV_LOG_ERROR, "Error configuring the filter graph\n"); goto fail; } *graph = filter_graph; *sink = abuffersink_ctx; return 0; fail: avfilter_graph_free(&filter_graph); src_filter_ctx.clear(); // possibly unnecessary? return err; } static gsr_video_encoder* create_video_encoder(gsr_egl *egl, const args_parser &arg_parser) { const gsr_color_depth color_depth = video_codec_to_bit_depth(arg_parser.video_codec); gsr_video_encoder *video_encoder = nullptr; if(arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU) { gsr_video_encoder_software_params params; params.egl = egl; params.color_depth = color_depth; video_encoder = gsr_video_encoder_software_create(¶ms); return video_encoder; } if(video_codec_is_vulkan(arg_parser.video_codec)) { gsr_video_encoder_vulkan_params params; params.egl = egl; params.color_depth = color_depth; video_encoder = gsr_video_encoder_vulkan_create(¶ms); return video_encoder; } switch(egl->gpu_info.vendor) { case GSR_GPU_VENDOR_AMD: case GSR_GPU_VENDOR_INTEL: case GSR_GPU_VENDOR_BROADCOM: { gsr_video_encoder_vaapi_params params; params.egl = egl; params.color_depth = color_depth; video_encoder = gsr_video_encoder_vaapi_create(¶ms); break; } case GSR_GPU_VENDOR_NVIDIA: { gsr_video_encoder_nvenc_params params; params.egl = egl; params.color_depth = color_depth; video_encoder = gsr_video_encoder_nvenc_create(¶ms); break; } } return video_encoder; } static bool get_supported_video_codecs(gsr_egl *egl, gsr_video_codec video_codec, bool use_software_video_encoder, bool cleanup, gsr_supported_video_codecs *video_codecs) { memset(video_codecs, 0, sizeof(*video_codecs)); if(use_software_video_encoder) { video_codecs->h264.supported = avcodec_find_encoder_by_name("libx264"); video_codecs->h264.max_resolution = {4096, 2304}; return true; } if(video_codec_is_vulkan(video_codec)) return gsr_get_supported_video_codecs_vulkan(video_codecs, egl->card_path, &egl->vulkan_device_index, cleanup); switch(egl->gpu_info.vendor) { case GSR_GPU_VENDOR_AMD: case GSR_GPU_VENDOR_INTEL: case GSR_GPU_VENDOR_BROADCOM: return gsr_get_supported_video_codecs_vaapi(video_codecs, egl->card_path, cleanup); case GSR_GPU_VENDOR_NVIDIA: return gsr_get_supported_video_codecs_nvenc(video_codecs, cleanup); } return false; } static void xwayland_check_callback(const gsr_monitor *monitor, void *userdata) { bool *xwayland_found = (bool*)userdata; if(monitor->name_len >= 8 && strncmp(monitor->name, "XWAYLAND", 8) == 0) *xwayland_found = true; else if(memmem(monitor->name, monitor->name_len, "X11", 3)) *xwayland_found = true; } static bool is_xwayland(Display *display) { int opcode, event, error; if(XQueryExtension(display, "XWAYLAND", &opcode, &event, &error)) return true; bool xwayland_found = false; for_each_active_monitor_output_x11_not_cached(display, xwayland_check_callback, &xwayland_found); return xwayland_found; } static bool is_using_prime_run() { const char *prime_render_offload = getenv("__NV_PRIME_RENDER_OFFLOAD"); return (prime_render_offload && strcmp(prime_render_offload, "1") == 0) || getenv("DRI_PRIME"); } static void disable_prime_run() { unsetenv("__NV_PRIME_RENDER_OFFLOAD"); unsetenv("__NV_PRIME_RENDER_OFFLOAD_PROVIDER"); unsetenv("__GLX_VENDOR_LIBRARY_NAME"); unsetenv("__VK_LAYER_NV_optimus"); unsetenv("DRI_PRIME"); } static gsr_window* gsr_window_create(Display *display, bool wayland) { if(wayland) return gsr_window_wayland_create(); else return gsr_window_x11_create(display); } static void list_system_info(bool wayland) { printf("display_server|%s\n", wayland ? "wayland" : "x11"); bool supports_app_audio = false; #ifdef GSR_APP_AUDIO supports_app_audio = pulseaudio_server_is_pipewire(); if(supports_app_audio) { gsr_pipewire_audio audio; if(gsr_pipewire_audio_init(&audio)) gsr_pipewire_audio_deinit(&audio); else supports_app_audio = false; } #endif printf("supports_app_audio|%s\n", supports_app_audio ? "yes" : "no"); } static void list_gpu_info(gsr_egl *egl) { switch(egl->gpu_info.vendor) { case GSR_GPU_VENDOR_AMD: printf("vendor|amd\n"); break; case GSR_GPU_VENDOR_INTEL: printf("vendor|intel\n"); break; case GSR_GPU_VENDOR_NVIDIA: printf("vendor|nvidia\n"); break; case GSR_GPU_VENDOR_BROADCOM: printf("vendor|broadcom\n"); break; } printf("card_path|%s\n", egl->card_path); } static const AVCodec* get_ffmpeg_video_codec(gsr_video_codec video_codec, gsr_gpu_vendor vendor) { switch(video_codec) { case GSR_VIDEO_CODEC_H264: return avcodec_find_encoder_by_name(vendor == GSR_GPU_VENDOR_NVIDIA ? "h264_nvenc" : "h264_vaapi"); case GSR_VIDEO_CODEC_HEVC: case GSR_VIDEO_CODEC_HEVC_HDR: case GSR_VIDEO_CODEC_HEVC_10BIT: return avcodec_find_encoder_by_name(vendor == GSR_GPU_VENDOR_NVIDIA ? "hevc_nvenc" : "hevc_vaapi"); case GSR_VIDEO_CODEC_AV1: case GSR_VIDEO_CODEC_AV1_HDR: case GSR_VIDEO_CODEC_AV1_10BIT: return avcodec_find_encoder_by_name(vendor == GSR_GPU_VENDOR_NVIDIA ? "av1_nvenc" : "av1_vaapi"); case GSR_VIDEO_CODEC_VP8: return avcodec_find_encoder_by_name(vendor == GSR_GPU_VENDOR_NVIDIA ? "vp8_nvenc" : "vp8_vaapi"); case GSR_VIDEO_CODEC_VP9: return avcodec_find_encoder_by_name(vendor == GSR_GPU_VENDOR_NVIDIA ? "vp9_nvenc" : "vp9_vaapi"); case GSR_VIDEO_CODEC_H264_VULKAN: return avcodec_find_encoder_by_name("h264_vulkan"); case GSR_VIDEO_CODEC_HEVC_VULKAN: case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: return avcodec_find_encoder_by_name("hevc_vulkan"); case GSR_VIDEO_CODEC_AV1_VULKAN: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: return avcodec_find_encoder_by_name("av1_vulkan"); } return nullptr; } static void set_supported_video_codecs_ffmpeg(gsr_supported_video_codecs *supported_video_codecs, gsr_supported_video_codecs *supported_video_codecs_vulkan, gsr_gpu_vendor vendor) { if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_H264, vendor)) { supported_video_codecs->h264.supported = false; } if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_HEVC, vendor)) { supported_video_codecs->hevc.supported = false; supported_video_codecs->hevc_hdr.supported = false; supported_video_codecs->hevc_10bit.supported = false; } if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_AV1, vendor)) { supported_video_codecs->av1.supported = false; supported_video_codecs->av1_hdr.supported = false; supported_video_codecs->av1_10bit.supported = false; } if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_VP8, vendor)) { supported_video_codecs->vp8.supported = false; } if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_VP9, vendor)) { supported_video_codecs->vp9.supported = false; } if(supported_video_codecs_vulkan) { if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_H264_VULKAN, vendor)) { supported_video_codecs_vulkan->h264.supported = false; } if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_HEVC_VULKAN, vendor)) { supported_video_codecs_vulkan->hevc.supported = false; supported_video_codecs_vulkan->hevc_hdr.supported = false; supported_video_codecs_vulkan->hevc_10bit.supported = false; } if(!get_ffmpeg_video_codec(GSR_VIDEO_CODEC_AV1_VULKAN, vendor)) { supported_video_codecs_vulkan->av1.supported = false; supported_video_codecs_vulkan->av1_hdr.supported = false; supported_video_codecs_vulkan->av1_10bit.supported = false; } } } static void list_supported_video_codecs(gsr_egl *egl, bool wayland) { // Dont clean it up on purpose to increase shutdown speed gsr_supported_video_codecs supported_video_codecs; get_supported_video_codecs(egl, GSR_VIDEO_CODEC_H264, false, false, &supported_video_codecs); gsr_supported_video_codecs supported_video_codecs_vulkan; get_supported_video_codecs(egl, GSR_VIDEO_CODEC_H264_VULKAN, false, false, &supported_video_codecs_vulkan); set_supported_video_codecs_ffmpeg(&supported_video_codecs, &supported_video_codecs_vulkan, egl->gpu_info.vendor); if(supported_video_codecs.h264.supported) puts("h264"); if(avcodec_find_encoder_by_name("libx264")) puts("h264_software"); if(supported_video_codecs.hevc.supported) puts("hevc"); if(supported_video_codecs.hevc_hdr.supported && wayland) puts("hevc_hdr"); if(supported_video_codecs.hevc_10bit.supported) puts("hevc_10bit"); if(supported_video_codecs.av1.supported) puts("av1"); if(supported_video_codecs.av1_hdr.supported && wayland) puts("av1_hdr"); if(supported_video_codecs.av1_10bit.supported) puts("av1_10bit"); if(supported_video_codecs.vp8.supported) puts("vp8"); if(supported_video_codecs.vp9.supported) puts("vp9"); if(supported_video_codecs_vulkan.h264.supported) puts("h264_vulkan"); if(supported_video_codecs_vulkan.hevc.supported) puts("hevc_vulkan"); if(supported_video_codecs_vulkan.hevc_hdr.supported && wayland) puts("hevc_hdr_vulkan"); if(supported_video_codecs_vulkan.hevc_10bit.supported) puts("hevc_10bit_vulkan"); if(supported_video_codecs_vulkan.av1.supported) puts("av1_vulkan"); if(supported_video_codecs_vulkan.av1_hdr.supported && wayland) puts("av1_hdr_vulkan"); if(supported_video_codecs_vulkan.av1_10bit.supported) puts("av1_10bit_vulkan"); } static bool monitor_capture_use_drm(const gsr_window *window, gsr_gpu_vendor vendor) { return gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_WAYLAND || vendor != GSR_GPU_VENDOR_NVIDIA; } typedef struct { const gsr_window *window; int num_monitors; } capture_options_callback; static void output_monitor_info(const gsr_monitor *monitor, void *userdata) { capture_options_callback *options = (capture_options_callback*)userdata; if(gsr_window_get_display_server(options->window) == GSR_DISPLAY_SERVER_WAYLAND) { vec2i monitor_size = monitor->size; gsr_monitor_rotation monitor_rotation = GSR_MONITOR_ROT_0; vec2i monitor_position = {0, 0}; drm_monitor_get_display_server_data(options->window, monitor, &monitor_rotation, &monitor_position); if(monitor_rotation == GSR_MONITOR_ROT_90 || monitor_rotation == GSR_MONITOR_ROT_270) std::swap(monitor_size.x, monitor_size.y); printf("%.*s|%dx%d\n", monitor->name_len, monitor->name, monitor_size.x, monitor_size.y); } else { printf("%.*s|%dx%d\n", monitor->name_len, monitor->name, monitor->size.x, monitor->size.y); } ++options->num_monitors; } static void camera_query_callback(const char *path, const gsr_capture_v4l2_supported_setup *setup, void *userdata) { (void)userdata; printf("%s|%ux%u@%uhz|%s\n", path, setup->resolution.width, setup->resolution.height, gsr_capture_v4l2_framerate_to_number(setup->framerate), gsr_capture_v4l2_pixfmt_to_string(setup->pixfmt)); } // Returns the number of monitors found static int list_monitors(const gsr_window *window, const char *card_path) { capture_options_callback options; options.window = window; options.num_monitors = 0; const bool is_x11 = gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_X11; const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM; for_each_active_monitor_output(window, card_path, connection_type, output_monitor_info, &options); return options.num_monitors; } static void list_supported_capture_options(const gsr_window *window, const char *card_path, bool do_list_monitors) { const bool wayland = gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_WAYLAND; if(!wayland) { puts("window"); puts("focused"); } int num_monitors = 0; if(do_list_monitors) num_monitors = list_monitors(window, card_path); if(num_monitors > 0) puts("region"); gsr_capture_v4l2_list_devices(camera_query_callback, NULL); #ifdef GSR_PORTAL // Desktop portal capture on x11 doesn't seem to be hardware accelerated if(!wayland) return; gsr_dbus dbus; if(!gsr_dbus_init(&dbus, NULL)) return; char *session_handle = NULL; if(gsr_dbus_screencast_create_session(&dbus, &session_handle) == 0) puts("portal"); gsr_dbus_deinit(&dbus); #endif } static void version_command(void *userdata) { (void)userdata; puts(GSR_VERSION); fflush(stdout); _exit(0); } struct WindowingSetup { Display *dpy; gsr_window *window; gsr_egl egl; bool list_monitors; }; static WindowingSetup setup_windowing(bool setup_egl) { WindowingSetup setup; memset(&setup, 0, sizeof(setup)); bool wayland = false; setup.dpy = XOpenDisplay(nullptr); if (!setup.dpy) { wayland = true; fprintf(stderr, "gsr warning: failed to connect to the X server. Assuming wayland is running without Xwayland\n"); } XSetErrorHandler(x11_error_handler); XSetIOErrorHandler(x11_io_error_handler); if(!wayland) wayland = is_xwayland(setup.dpy); if(!wayland && is_using_prime_run()) { // Disable prime-run and similar options as it doesn't work, the monitor to capture has to be run on the same device. // This is fine on wayland since nvidia uses drm interface there and the monitor query checks the monitors connected // to the drm device. fprintf(stderr, "gsr warning: use of prime-run on X11 is not supported. Disabling prime-run\n"); disable_prime_run(); } setup.window = gsr_window_create(setup.dpy, wayland); if(!setup.window) { fprintf(stderr, "gsr error: failed to create window\n"); _exit(1); } setup.list_monitors = true; if(setup_egl) { if(!gsr_egl_load(&setup.egl, setup.window, false, false)) { fprintf(stderr, "gsr error: failed to load opengl\n"); _exit(22); } setup.egl.card_path[0] = '\0'; if(monitor_capture_use_drm(setup.window, setup.egl.gpu_info.vendor)) { // TODO: Allow specifying another card, and in other places if(!gsr_get_valid_card_path(&setup.egl, setup.egl.card_path, true)) { fprintf(stderr, "gsr error: no /dev/dri/cardX device found. Make sure that you have at least one monitor connected\n"); setup.list_monitors = false; } } else { gsr_get_valid_card_path(&setup.egl, setup.egl.card_path, false); } } return setup; } static void info_command(void *userdata) { (void)userdata; WindowingSetup windowing_setup = setup_windowing(true); const bool wayland = gsr_window_get_display_server(windowing_setup.window) == GSR_DISPLAY_SERVER_WAYLAND; av_log_set_level(AV_LOG_FATAL); puts("section=system_info"); list_system_info(wayland); if(windowing_setup.egl.gpu_info.is_steam_deck) puts("is_steam_deck|yes"); else puts("is_steam_deck|no"); printf("gsr_version|%s\n", GSR_VERSION); puts("section=gpu_info"); list_gpu_info(&windowing_setup.egl); puts("section=video_codecs"); list_supported_video_codecs(&windowing_setup.egl, wayland); puts("section=image_formats"); puts("jpeg"); puts("png"); puts("section=capture_options"); list_supported_capture_options(windowing_setup.window, windowing_setup.egl.card_path, windowing_setup.list_monitors); fflush(stdout); // Not needed as this will just slow down shutdown //gsr_egl_unload(&egl); //gsr_window_destroy(&window); //if(dpy) // XCloseDisplay(dpy); _exit(0); } static void list_audio_devices_command(void *userdata) { (void)userdata; const AudioDevices audio_devices = get_pulseaudio_inputs(); if(!audio_devices.default_output.empty()) puts("default_output|Default output"); if(!audio_devices.default_input.empty()) puts("default_input|Default input"); for(const auto &audio_input : audio_devices.audio_inputs) { printf("%s|%s\n", audio_input.name.c_str(), audio_input.description.c_str()); } fflush(stdout); _exit(0); } static bool app_audio_query_callback(const char *app_name, void*) { puts(app_name); return true; } static void list_application_audio_command(void *userdata) { (void)userdata; #ifdef GSR_APP_AUDIO if(pulseaudio_server_is_pipewire()) { gsr_pipewire_audio audio; if(gsr_pipewire_audio_init(&audio)) { gsr_pipewire_audio_for_each_app(&audio, app_audio_query_callback, NULL); gsr_pipewire_audio_deinit(&audio); } } #endif fflush(stdout); _exit(0); } static void list_v4l2_devices(void *userdata) { (void)userdata; gsr_capture_v4l2_list_devices(camera_query_callback, NULL); fflush(stdout); _exit(0); } // |card_path| can be NULL. If not NULL then |vendor| has to be valid static void list_capture_options_command(const char *card_path, void *userdata) { (void)userdata; WindowingSetup windowing_setup = setup_windowing(card_path != nullptr); if(card_path) list_supported_capture_options(windowing_setup.window, card_path, true); else list_supported_capture_options(windowing_setup.window, windowing_setup.egl.card_path, windowing_setup.list_monitors); fflush(stdout); // Not needed as this will just slow down shutdown //gsr_egl_unload(&egl); //gsr_window_destroy(&window); //if(dpy) // XCloseDisplay(dpy); _exit(0); } static void list_monitors_command(void *userdata) { (void)userdata; WindowingSetup windowing_setup = setup_windowing(true); if(windowing_setup.list_monitors) list_monitors(windowing_setup.window, windowing_setup.egl.card_path); fflush(stdout); // Not needed as this will just slow down shutdown //gsr_egl_unload(&egl); //gsr_window_destroy(&window); //if(dpy) // XCloseDisplay(dpy); _exit(0); } static std::string validate_monitor_get_valid(const gsr_egl *egl, const char* window) { const bool is_x11 = gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11; const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_DRM; const bool capture_use_drm = monitor_capture_use_drm(egl->window, egl->gpu_info.vendor); std::string capture_source_result = window; if(strcmp(capture_source_result.c_str(), "screen") == 0) { FirstOutputCallback data; data.output_name = NULL; for_each_active_monitor_output(egl->window, egl->card_path, connection_type, get_first_output_callback, &data); if(data.output_name) { capture_source_result = data.output_name; free(data.output_name); } else { fprintf(stderr, "gsr error: no usable output found\n"); _exit(51); } } else if(capture_use_drm || (strcmp(capture_source_result.c_str(), "screen-direct") != 0 && strcmp(capture_source_result.c_str(), "screen-direct-force") != 0)) { gsr_monitor gmon; if(!get_monitor_by_name(egl, connection_type, capture_source_result.c_str(), &gmon)) { fprintf(stderr, "gsr error: display \"%s\" not found, expected one of:\n", capture_source_result.c_str()); fprintf(stderr, " \"screen\"\n"); if(!capture_use_drm) fprintf(stderr, " \"screen-direct\"\n"); MonitorOutputCallbackUserdata userdata; userdata.window = egl->window; for_each_active_monitor_output(egl->window, egl->card_path, connection_type, monitor_output_callback_print, &userdata); _exit(51); } } return capture_source_result; } static std::string get_monitor_by_region_center(const gsr_egl *egl, vec2i region_position, vec2i region_size, vec2i *monitor_pos, vec2i *monitor_size, double *monitor_scale_inverted) { const bool is_x11 = gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11; const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_WAYLAND; MonitorByPositionCallback data; data.window = egl->window; data.position = { region_position.x + region_size.x / 2, region_position.y + region_size.y / 2 }; data.output_name = NULL; data.monitor_pos = {0, 0}; data.monitor_size = {0, 0}; data.monitor_scale_inverted = 1.0; for_each_active_monitor_output(egl->window, egl->card_path, connection_type, get_monitor_by_position_callback, &data); std::string result; if(data.output_name) { result = data.output_name; free(data.output_name); } *monitor_pos = data.monitor_pos; *monitor_size = data.monitor_size; *monitor_scale_inverted = data.monitor_scale_inverted; return result; } static gsr_kms_client kms_client; static bool kms_client_initialized = false; static gsr_kms_response kms_response; static gsr_cursor x11_cursor; static Display *x11_cursor_display = NULL; static gsr_capture* create_monitor_capture(const args_parser &arg_parser, gsr_egl *egl, const CaptureSource &capture_source, bool prefer_ximage) { if(gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11 && prefer_ximage) { gsr_capture_ximage_params ximage_params; memset(&ximage_params, 0, sizeof(ximage_params)); ximage_params.egl = egl; ximage_params.cursor = &x11_cursor; ximage_params.display_to_capture = capture_source.name.c_str(); ximage_params.record_cursor = arg_parser.record_cursor; ximage_params.output_resolution = arg_parser.output_resolution; ximage_params.region_size = capture_source.region_size; ximage_params.region_position = capture_source.region_pos; return gsr_capture_ximage_create(&ximage_params); } if(monitor_capture_use_drm(egl->window, egl->gpu_info.vendor)) { if(!kms_client_initialized) { kms_client_initialized = true; const int kms_init_res = gsr_kms_client_init(&kms_client, egl->card_path); if(kms_init_res != 0) _exit(kms_init_res < 0 ? 1 : kms_init_res); } gsr_capture_kms_params kms_params; memset(&kms_params, 0, sizeof(kms_params)); kms_params.egl = egl; kms_params.x11_cursor = &x11_cursor; kms_params.kms_response = &kms_response; kms_params.display_to_capture = capture_source.name.c_str(); kms_params.record_cursor = arg_parser.record_cursor; kms_params.hdr = video_codec_is_hdr(arg_parser.video_codec); kms_params.fps = arg_parser.fps; kms_params.output_resolution = arg_parser.output_resolution; kms_params.region_size = capture_source.region_size; kms_params.region_position = capture_source.region_pos; return gsr_capture_kms_create(&kms_params); } else { const char *capture_source_real = capture_source.name.c_str(); const bool direct_capture = strcmp(capture_source.name.c_str(), "screen-direct") == 0 || strcmp(capture_source.name.c_str(), "screen-direct-force") == 0; if(direct_capture) { capture_source_real = "screen"; fprintf(stderr, "gsr warning: %s capture option is not recommended unless you use G-SYNC as Nvidia has driver issues that can cause your system or games to freeze/crash.\n", capture_source.name.c_str()); } gsr_capture_nvfbc_params nvfbc_params; memset(&nvfbc_params, 0, sizeof(nvfbc_params)); nvfbc_params.egl = egl; nvfbc_params.display_to_capture = capture_source_real; nvfbc_params.fps = arg_parser.fps; nvfbc_params.direct_capture = direct_capture; nvfbc_params.record_cursor = arg_parser.record_cursor; nvfbc_params.output_resolution = arg_parser.output_resolution; nvfbc_params.region_size = capture_source.region_size; nvfbc_params.region_position = capture_source.region_pos; return gsr_capture_nvfbc_create(&nvfbc_params); } } static void monitor_output_callback_print_region(const gsr_monitor *monitor, void *userdata) { const vec2i monitor_position = monitor->logical_pos; const vec2i monitor_size = monitor->logical_size; fprintf(stderr, " \"%.*s\" (%dx%d+%d+%d)\n", monitor->name_len, monitor->name, monitor_size.x, monitor_size.y, monitor_position.x, monitor_position.y); } static std::string region_get_data(gsr_egl *egl, vec2i *region_size, vec2i *region_position) { vec2i monitor_pos = {0, 0}; vec2i monitor_size = {0, 0}; double monitor_scale_inverted = 1.0; std::string window = get_monitor_by_region_center(egl, *region_position, *region_size, &monitor_pos, &monitor_size, &monitor_scale_inverted); if(window.empty()) { const bool is_x11 = gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_X11; const gsr_connection_type connection_type = is_x11 ? GSR_CONNECTION_X11 : GSR_CONNECTION_WAYLAND; fprintf(stderr, "gsr error: the region %dx%d+%d+%d doesn't match any monitor. Available monitors and their regions:\n", region_size->x, region_size->y, region_position->x, region_position->y); MonitorOutputCallbackUserdata userdata; userdata.window = egl->window; for_each_active_monitor_output(egl->window, egl->card_path, connection_type, monitor_output_callback_print_region, &userdata); _exit(51); } // Capture whole monitor when region size is set to 0x0 if(region_size->x == 0 && region_size->y == 0) { region_position->x = 0; region_position->y = 0; } else { region_position->x -= monitor_pos.x; region_position->y -= monitor_pos.y; // Match drm plane coordinate space (1x scaling) to wayland coordinate space (which may have scaling set by user) region_position->x *= monitor_scale_inverted; region_position->y *= monitor_scale_inverted; region_size->x *= monitor_scale_inverted; region_size->y *= monitor_scale_inverted; } return window; } static gsr_capture* create_capture_impl(const args_parser &arg_parser, gsr_egl *egl, CaptureSource &capture_source, bool prefer_ximage) { bool follow_focused = false; const bool wayland = gsr_window_get_display_server(egl->window) == GSR_DISPLAY_SERVER_WAYLAND; gsr_capture *capture = nullptr; if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_FOCUSED_WINDOW) { if(wayland) { fprintf(stderr, "gsr error: GPU Screen Recorder window capture only works in a pure X11 session. Xwayland is not supported. You can record a monitor instead on wayland\n"); _exit(2); } if(arg_parser.output_resolution.x <= 0 || arg_parser.output_resolution.y <= 0) { fprintf(stderr, "gsr error: invalid value for option -s '%dx%d' when using -w focused option. expected width and height to be greater than 0\n", arg_parser.output_resolution.x, arg_parser.output_resolution.y); args_parser_print_usage(); _exit(1); } follow_focused = true; } else if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_PORTAL) { #ifdef GSR_PORTAL // Desktop portal capture on x11 doesn't seem to be hardware accelerated if(!wayland) { fprintf(stderr, "gsr error: desktop portal capture is not supported on X11\n"); _exit(1); } gsr_capture_portal_params portal_params; memset(&portal_params, 0, sizeof(portal_params)); portal_params.egl = egl; portal_params.record_cursor = arg_parser.record_cursor; portal_params.restore_portal_session = arg_parser.restore_portal_session; portal_params.portal_session_token_filepath = arg_parser.portal_session_token_filepath; portal_params.output_resolution = arg_parser.output_resolution; capture = gsr_capture_portal_create(&portal_params); if(!capture) _exit(1); #else fprintf(stderr, "gsr error: option '-w portal' used but GPU Screen Recorder was compiled without desktop portal support. Please recompile GPU Screen recorder with the -Dportal=true option\n"); _exit(2); #endif } else if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_REGION) { capture_source.name = region_get_data(egl, &capture_source.region_size, &capture_source.region_pos); capture = create_monitor_capture(arg_parser, egl, capture_source, prefer_ximage); if(!capture) _exit(1); } else if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_MONITOR) { capture_source.name = validate_monitor_get_valid(egl, capture_source.name.c_str()); capture = create_monitor_capture(arg_parser, egl, capture_source, prefer_ximage); if(!capture) _exit(1); } else if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_V4L2) { gsr_capture_v4l2_params v4l2_params; memset(&v4l2_params, 0, sizeof(v4l2_params)); v4l2_params.egl = egl; v4l2_params.output_resolution = arg_parser.output_resolution; v4l2_params.device_path = capture_source.name.c_str(); v4l2_params.pixfmt = capture_source.v4l2_pixfmt; v4l2_params.camera_fps = capture_source.camera_fps; v4l2_params.camera_resolution.width = capture_source.camera_resolution.x; v4l2_params.camera_resolution.height = capture_source.camera_resolution.y; capture = gsr_capture_v4l2_create(&v4l2_params); if(!capture) _exit(1); } else { if(wayland) { fprintf(stderr, "gsr error: GPU Screen Recorder window capture only works in a pure X11 session. Xwayland is not supported. You can record a monitor instead on wayland or use -w portal option which supports window capture if your wayland compositor supports window capture\n"); _exit(2); } } if(!capture) { gsr_capture_xcomposite_params xcomposite_params; memset(&xcomposite_params, 0, sizeof(xcomposite_params)); xcomposite_params.egl = egl; xcomposite_params.cursor = &x11_cursor; xcomposite_params.window = capture_source.window_id; xcomposite_params.follow_focused = follow_focused; xcomposite_params.record_cursor = arg_parser.record_cursor; xcomposite_params.output_resolution = arg_parser.output_resolution; capture = gsr_capture_xcomposite_create(&xcomposite_params); if(!capture) _exit(1); } return capture; } static gsr_color_range image_format_to_color_range(gsr_image_format image_format, int image_quality) { switch(image_format) { case GSR_IMAGE_FORMAT_JPEG: return image_quality >= 91 ? GSR_COLOR_RANGE_FULL : GSR_COLOR_RANGE_LIMITED; case GSR_IMAGE_FORMAT_PNG: return GSR_COLOR_RANGE_FULL; } assert(false); return GSR_COLOR_RANGE_FULL; } static int video_quality_to_image_quality_value(gsr_video_quality video_quality) { switch(video_quality) { case GSR_VIDEO_QUALITY_MEDIUM: return 75; case GSR_VIDEO_QUALITY_HIGH: return 85; case GSR_VIDEO_QUALITY_VERY_HIGH: return 91; // Quality above 90 makes the jpeg image encoder (stb_image_writer) use yuv444 instead of yuv420, which greatly improves small colored text quality on dark background case GSR_VIDEO_QUALITY_ULTRA: return 97; } assert(false); return 90; } static bool any_video_sources_uses_external_image(std::vector &video_sources) { for(VideoSource &video_source : video_sources) { if(gsr_capture_uses_external_image(video_source.capture)) return true; } return false; } static std::vector create_video_sources(const args_parser &arg_parser, gsr_egl *egl, bool prefer_ximage, std::vector &capture_sources, vec2i &video_size) { std::vector video_sources; video_sources.reserve(capture_sources.size()); for(CaptureSource &capture_source : capture_sources) { gsr_capture_metadata capture_metadata; memset(&capture_metadata, 0, sizeof(capture_metadata)); capture_metadata.fps = arg_parser.fps; capture_metadata.halign = capture_source.halign; capture_metadata.valign = capture_source.valign; capture_metadata.flip = (gsr_flip)capture_source.flip; video_sources.push_back(VideoSource{create_capture_impl(arg_parser, egl, capture_source, prefer_ximage), capture_metadata, &capture_source}); } for(VideoSource &video_source : video_sources) { int capture_result = gsr_capture_start(video_source.capture, &video_source.metadata); if(capture_result != 0) { fprintf(stderr, "gsr error: gsr_capture_start failed\n"); _exit(capture_result); } } vec2i start_pos = {99999, 99999}; vec2i end_pos = {-99999, -99999}; for(const VideoSource &video_source : video_sources) { // TODO: Skip scalar positions for now, but this should be handled in a better way. // Maybe handle scalars at the next loop by multiplying video size by the scalar. if(video_source.capture_source->pos.x_type == VVEC2I_TYPE_SCALAR || video_source.capture_source->pos.y_type == VVEC2I_TYPE_SCALAR || (video_source.capture_source->size.x_type == VVEC2I_TYPE_SCALAR && video_source.capture_source->size.x != 100) || (video_source.capture_source->size.y_type == VVEC2I_TYPE_SCALAR && video_source.capture_source->size.y != 100)) { continue; } const vec2i video_source_start_pos = {video_source.capture_source->pos.x, video_source.capture_source->pos.y}; const vec2i video_source_end_pos = {video_source_start_pos.x + video_source.metadata.video_size.x, video_source_start_pos.y + video_source.metadata.video_size.y}; start_pos.x = std::min(start_pos.x, video_source_start_pos.x); start_pos.y = std::min(start_pos.y, video_source_start_pos.y); end_pos.x = std::max(end_pos.x, video_source_end_pos.x); end_pos.y = std::max(end_pos.y, video_source_end_pos.y); } video_size.x = std::max(0, end_pos.x - start_pos.x); video_size.y = std::max(0, end_pos.y - start_pos.y); for(VideoSource &video_source : video_sources) { video_source.metadata.video_size = video_size; } return video_sources; } static void video_sources_update_with_real_video_size(std::vector &capture_sources, std::vector &video_sources, vec2i video_size) { assert(capture_sources.size() == video_sources.size()); for(size_t i = 0; i < capture_sources.size(); ++i) { CaptureSource &capture_source = capture_sources[i]; VideoSource &video_source = video_sources[i]; video_source.metadata.recording_size = video_source.metadata.video_size; // TODO: What if this updated resolution is above max resolution? video_source.metadata.video_size = video_size; if(capture_source.pos.x != 0 || capture_source.pos.y != 0) { video_source.metadata.position.x = capture_source.pos.x; video_source.metadata.position.y = capture_source.pos.y; if(capture_source.pos.x_type == VVEC2I_TYPE_SCALAR) video_source.metadata.position.x = video_source.metadata.video_size.x * ((double)video_source.metadata.position.x / 100.0); if(capture_source.pos.y_type == VVEC2I_TYPE_SCALAR) video_source.metadata.position.y = video_source.metadata.video_size.y * ((double)video_source.metadata.position.y / 100.0); } if(capture_source.size.x != 0 || capture_source.size.y != 0) { video_source.metadata.recording_size.x = capture_source.size.x; video_source.metadata.recording_size.y = capture_source.size.y; if(capture_source.size.x_type == VVEC2I_TYPE_SCALAR) video_source.metadata.recording_size.x = video_source.metadata.video_size.x * ((double)video_source.metadata.recording_size.x / 100.0); if(capture_source.size.y_type == VVEC2I_TYPE_SCALAR) video_source.metadata.recording_size.y = video_source.metadata.video_size.y * ((double)video_source.metadata.recording_size.y / 100.0); } } } static void gsr_capture_kms_cleanup_kms_fds() { for(int i = 0; i < kms_response.num_items; ++i) { for(int j = 0; j < kms_response.items[i].num_dma_bufs; ++j) { gsr_kms_response_dma_buf *dma_buf = &kms_response.items[i].dma_buf[j]; if(dma_buf->fd > 0) { close(dma_buf->fd); dma_buf->fd = -1; } } kms_response.items[i].num_dma_bufs = 0; } kms_response.num_items = 0; } static void load_plugins(gsr_plugins *plugins, args_parser &arg_parser, gsr_egl *egl, vec2i video_size) { const Arg *plugin_arg = args_parser_get_arg(&arg_parser, "-p"); assert(plugin_arg); if(plugin_arg->num_values > 0) { const gsr_color_depth color_depth = video_codec_to_bit_depth(arg_parser.video_codec); assert(color_depth == GSR_COLOR_DEPTH_8_BITS || color_depth == GSR_COLOR_DEPTH_10_BITS); const gsr_plugin_init_params plugin_init_params = { (unsigned int)video_size.x, (unsigned int)video_size.y, (unsigned int)arg_parser.fps, color_depth == GSR_COLOR_DEPTH_8_BITS ? GSR_PLUGIN_COLOR_DEPTH_8_BITS : GSR_PLUGIN_COLOR_DEPTH_10_BITS, egl->context_type == GSR_GL_CONTEXT_TYPE_GLX ? GSR_PLUGIN_GRAPHICS_API_GLX : GSR_PLUGIN_GRAPHICS_API_EGL_ES, }; if(!gsr_plugins_init(plugins, plugin_init_params, egl)) _exit(1); for(int i = 0; i < plugin_arg->num_values; ++i) { if(!gsr_plugins_load_plugin(plugins, plugin_arg->values[i])) _exit(1); } } } // TODO: 10-bit and hdr. static void capture_image_to_file(args_parser &arg_parser, gsr_egl *egl, gsr_window *window, gsr_image_format image_format, std::vector &capture_sources) { const int image_quality = video_quality_to_image_quality_value(arg_parser.video_quality); const gsr_color_range color_range = image_format_to_color_range(image_format, image_quality); arg_parser.fps = 60; // We want to capture an image as soon as possible vec2i video_size = {0, 0}; std::vector video_sources = create_video_sources(arg_parser, egl, true, capture_sources, video_size); video_sources_update_with_real_video_size(capture_sources, video_sources, video_size); const Arg *plugin_arg = args_parser_get_arg(&arg_parser, "-p"); assert(plugin_arg); gsr_plugins plugins; memset(&plugins, 0, sizeof(plugins)); if(plugin_arg->num_values > 0) load_plugins(&plugins, arg_parser, egl, video_size); gsr_image_writer image_writer; if(!gsr_image_writer_init_opengl(&image_writer, egl, video_size.x, video_size.y)) { fprintf(stderr, "gsr error: capture_image_to_file: gsr_image_write_gl_init failed\n"); _exit(1); } gsr_color_conversion_params color_conversion_params; memset(&color_conversion_params, 0, sizeof(color_conversion_params)); color_conversion_params.color_range = color_range; color_conversion_params.egl = egl; color_conversion_params.load_external_image_shader = any_video_sources_uses_external_image(video_sources); color_conversion_params.destination_textures[0] = image_writer.texture; color_conversion_params.destination_textures_size[0] = video_size; color_conversion_params.num_destination_textures = 1; color_conversion_params.destination_color = GSR_DESTINATION_COLOR_RGB; gsr_color_conversion color_conversion; if(gsr_color_conversion_init(&color_conversion, &color_conversion_params) != 0) { fprintf(stderr, "gsr error: capture_image_to_file: failed to create color conversion\n"); _exit(1); } gsr_color_conversion_clear(&color_conversion); gsr_color_conversion *output_color_conversion = plugins.num_plugins > 0 ? &plugins.color_conversion : &color_conversion; bool should_stop_error = false; egl->glClear(0); while(running) { while(gsr_window_process_event(window)) { if(x11_cursor_display && arg_parser.record_cursor) gsr_cursor_on_event(&x11_cursor, gsr_window_get_event_data(window)); for(VideoSource &video_source : video_sources) { gsr_capture_on_event(video_source.capture, egl); } } if(x11_cursor_display && arg_parser.record_cursor) gsr_cursor_tick(&x11_cursor, DefaultRootWindow(x11_cursor_display)); gsr_capture_kms_cleanup_kms_fds(); if(kms_client_initialized) { if(gsr_kms_client_get_kms(&kms_client, &kms_response) != 0) fprintf(stderr, "gsr error: failed to get kms, error: %d (%s)\n", kms_response.result, kms_response.err_msg); } should_stop_error = false; for(VideoSource &video_source : video_sources) { gsr_capture_tick(video_source.capture); if(gsr_capture_should_stop(video_source.capture, &should_stop_error)) { running = 0; break; } } for(VideoSource &video_source : video_sources) { if(video_source.capture->pre_capture) video_source.capture->pre_capture(video_source.capture, &video_source.metadata, output_color_conversion); } if(output_color_conversion->schedule_clear) { output_color_conversion->schedule_clear = false; gsr_color_conversion_clear(output_color_conversion); } bool all_sources_captured = true; for(VideoSource &video_source : video_sources) { // It can fail, for example when capturing portal and the target is a monitor that hasn't been updated. // This can also happen for example if the system suspends and the monitor to capture's framebuffer is gone, or if the target window disappeared. if(gsr_capture_capture(video_source.capture, &video_source.metadata, output_color_conversion) != 0) all_sources_captured = false; } gsr_capture_kms_cleanup_kms_fds(); if(all_sources_captured) break; if(running) usleep(30 * 1000); // 30 ms } if(plugins.num_plugins > 0) { gsr_plugins_draw(&plugins); gsr_color_conversion_draw(&color_conversion, plugins.texture, {0, 0}, video_size, {0, 0}, video_size, video_size, GSR_ROT_0, GSR_FLIP_NONE, GSR_SOURCE_COLOR_RGB, false); } gsr_egl_swap_buffers(egl); if(!should_stop_error) { if(!gsr_image_writer_write_to_file(&image_writer, arg_parser.filename, image_format, image_quality)) { fprintf(stderr, "gsr error: capture_image_to_file: failed to write opengl texture to image output file %s\n", arg_parser.filename); _exit(1); } if(arg_parser.recording_saved_script) run_recording_saved_script_async(arg_parser.recording_saved_script, arg_parser.filename, "screenshot"); } gsr_plugins_deinit(&plugins); gsr_image_writer_deinit(&image_writer); for(VideoSource &video_source : video_sources) { gsr_capture_destroy(video_source.capture); } _exit(should_stop_error ? 3 : 0); } static AVPixelFormat get_pixel_format(gsr_video_codec video_codec, gsr_gpu_vendor vendor, bool use_software_video_encoder) { if(use_software_video_encoder) { return AV_PIX_FMT_NV12; } else { if(video_codec_is_vulkan(video_codec)) return AV_PIX_FMT_VULKAN; else return vendor == GSR_GPU_VENDOR_NVIDIA ? AV_PIX_FMT_CUDA : AV_PIX_FMT_VAAPI; } } static void match_app_audio_input_to_available_apps(const std::vector &requested_audio_inputs, const std::vector &app_audio_names) { for(const AudioInput &request_audio_input : requested_audio_inputs) { if(request_audio_input.type != AudioInputType::APPLICATION || request_audio_input.inverted) continue; bool match = false; for(const std::string &app_name : app_audio_names) { if(strcasecmp(app_name.c_str(), request_audio_input.name.c_str()) == 0) { match = true; break; } } if(!match) { fprintf(stderr, "gsr warning: no audio application with the name \"%s\" was found, expected one of the following:\n", request_audio_input.name.c_str()); for(const std::string &app_name : app_audio_names) { fprintf(stderr, " * %s\n", app_name.c_str()); } fprintf(stderr, " assuming this is intentional (if you are trying to record audio for applications that haven't started yet).\n"); } } } // Manually check if the audio inputs we give exist. This is only needed for pipewire, not pulseaudio. // Pipewire instead DEFAULTS TO THE DEFAULT AUDIO INPUT. THAT'S RETARDED. // OH, YOU MISSPELLED THE AUDIO INPUT? FUCK YOU static std::vector parse_audio_inputs(const AudioDevices &audio_devices, const Arg *audio_input_arg) { std::vector requested_audio_inputs; for(int i = 0; i < audio_input_arg->num_values; ++i) { const char *audio_input = audio_input_arg->values[i]; if(!audio_input || audio_input[0] == '\0') continue; requested_audio_inputs.push_back(parse_audio_input_arg(audio_input)); for(AudioInput &request_audio_input : requested_audio_inputs.back().audio_inputs) { if(request_audio_input.type != AudioInputType::DEVICE) continue; bool match = false; if(request_audio_input.name == "default_output") { if(audio_devices.default_output.empty()) { fprintf(stderr, "gsr error: -a default_output was specified but no default audio output is specified in the audio server\n"); _exit(2); } match = true; } else if(request_audio_input.name == "default_input") { if(audio_devices.default_input.empty()) { fprintf(stderr, "gsr error: -a default_input was specified but no default audio input is specified in the audio server\n"); _exit(2); } match = true; } else { const bool name_is_existing_audio_device = get_audio_device_by_name(audio_devices.audio_inputs, request_audio_input.name.c_str()) != nullptr; if(name_is_existing_audio_device) match = true; } if(!match) { fprintf(stderr, "gsr error: Audio device '%s' is not a valid audio device, expected one of:\n", request_audio_input.name.c_str()); if(!audio_devices.default_output.empty()) fprintf(stderr, " default_output (Default output)\n"); if(!audio_devices.default_input.empty()) fprintf(stderr, " default_input (Default input)\n"); for(const auto &audio_device_input : audio_devices.audio_inputs) { fprintf(stderr, " %s (%s)\n", audio_device_input.name.c_str(), audio_device_input.description.c_str()); } _exit(50); } } } return requested_audio_inputs; } static bool is_hex_num(char c) { return (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') || (c >= '0' && c <= '9'); } static bool contains_non_hex_number(const char *str) { bool hex_start = false; size_t len = strlen(str); if(len >= 2 && memcmp(str, "0x", 2) == 0) { str += 2; len -= 2; hex_start = true; } bool is_hex = false; for(size_t i = 0; i < len; ++i) { char c = str[i]; if(c == '\0') return false; if(!is_hex_num(c)) return true; if((c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f')) is_hex = true; } return is_hex && !hex_start; } template static bool string_to_int(const char *str, size_t len, T *number) { char number_str[32]; snprintf(number_str, sizeof(number_str), "%.*s", (int)len, str); errno = 0; *number = strtol(number_str, NULL, 0); return errno == 0; } static void capture_source_type_from_string(const char *capture_source_str, size_t size, CaptureSource &capture_source) { char capture_source_str_n[64]; snprintf(capture_source_str_n, sizeof(capture_source_str_n), "%.*s", (int)size, capture_source_str); if(size == 7 && memcmp(capture_source_str_n, "focused", 7) == 0) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_FOCUSED_WINDOW; } else if(size == 6 && memcmp(capture_source_str_n, "portal", 6) == 0) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_PORTAL; } else if(size == 6 && memcmp(capture_source_str_n, "region", 6) == 0) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_REGION; } else if(size >= 10 && memcmp(capture_source_str_n, "/dev/video", 10) == 0) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_V4L2; } else if(sscanf(capture_source_str_n, "%dx%d+%d+%d", &capture_source.region_size.x, &capture_source.region_size.y, &capture_source.region_pos.x, &capture_source.region_pos.y) == 4) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_REGION; capture_source.region_set = true; } else if(contains_non_hex_number(capture_source_str_n)) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_MONITOR; } else { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_WINDOW; } } static bool string_to_capture_alignment(const char *str, size_t len, gsr_capture_alignment *alignment) { if(len == 5 && memcmp(str, "start", 5) == 0) { *alignment = GSR_CAPTURE_ALIGN_START; return true; } else if(len == 6 && memcmp(str, "center", 6) == 0) { *alignment = GSR_CAPTURE_ALIGN_CENTER; return true; } else if(len == 3 && memcmp(str, "end", 3) == 0) { *alignment = GSR_CAPTURE_ALIGN_END; return true; } else { return false; } } static bool string_to_v4l2_pixfmt(const char *str, size_t len, gsr_capture_v4l2_pixfmt *pixfmt) { if(len == 4 && memcmp(str, "auto", 4) == 0) { *pixfmt = GSR_CAPTURE_V4L2_PIXFMT_AUTO; return true; } else if(len == 4 && memcmp(str, "yuyv", 4) == 0) { *pixfmt = GSR_CAPTURE_V4L2_PIXFMT_YUYV; return true; } else if(len == 5 && memcmp(str, "mjpeg", 5) == 0) { *pixfmt = GSR_CAPTURE_V4L2_PIXFMT_MJPEG; return true; } else { return false; } } static bool string_to_bool(const char *str, size_t len, bool *value) { if(len == 4 && memcmp(str, "true", 4) == 0) { *value = true; return true; } else if(len == 5 && memcmp(str, "false", 5) == 0) { *value = false; return true; } else { return false; } } static void parse_capture_source_options(const std::string &capture_source_str, CaptureSource &capture_source) { bool is_first_column = true; split_string(capture_source_str, ';', [&](const char *sub, size_t size) { if(size == 0) return true; // First column contains the capture target if(is_first_column) { is_first_column = false; return true; } if(string_starts_with(sub, size, "x=")) { capture_source.pos.x_type = sub[size - 1] == '%' ? VVEC2I_TYPE_SCALAR : VVEC2I_TYPE_PIXELS; sub += 2; size -= 2; if(!string_to_int(sub, size, &capture_source.pos.x)) { fprintf(stderr, "gsr error: invalid capture target value for option x: \"%.*s\", expected a number\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "y=")) { capture_source.pos.y_type = sub[size - 1] == '%' ? VVEC2I_TYPE_SCALAR : VVEC2I_TYPE_PIXELS; sub += 2; size -= 2; if(!string_to_int(sub, size, &capture_source.pos.y)) { fprintf(stderr, "gsr error: invalid capture target value for option y: \"%.*s\", expected a number\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "width=")) { capture_source.size.x_type = sub[size - 1] == '%' ? VVEC2I_TYPE_SCALAR : VVEC2I_TYPE_PIXELS; sub += 6; size -= 6; if(!string_to_int(sub, size, &capture_source.size.x)) { fprintf(stderr, "gsr error: invalid capture target value for option width: \"%.*s\", expected a number\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "height=")) { capture_source.size.y_type = sub[size - 1] == '%' ? VVEC2I_TYPE_SCALAR : VVEC2I_TYPE_PIXELS; sub += 7; size -= 7; if(!string_to_int(sub, size, &capture_source.size.y)) { fprintf(stderr, "gsr error: invalid capture target value for option height: \"%.*s\", expected a number\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "halign=")) { sub += 7; size -= 7; if(!string_to_capture_alignment(sub, size, &capture_source.halign)) { fprintf(stderr, "gsr error: invalid capture target value for option halign: \"%.*s\", expected a \"start\", \"center\" or \"end\"\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "valign=")) { sub += 7; size -= 7; if(!string_to_capture_alignment(sub, size, &capture_source.valign)) { fprintf(stderr, "gsr error: invalid capture target value for option valign: \"%.*s\", expected a \"start\", \"center\" or \"end\"\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "pixfmt=")) { sub += 7; size -= 7; if(!string_to_v4l2_pixfmt(sub, size, &capture_source.v4l2_pixfmt)) { fprintf(stderr, "gsr error: invalid v4l2 pixfmt value for option pixfmt: \"%.*s\", expected a \"auto\", \"yuyv\" or \"mjpeg\"\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "hflip=")) { sub += 6; size -= 6; bool hflip = false; if(!string_to_bool(sub, size, &hflip)) { fprintf(stderr, "gsr error: invalid bool value for option hflip: \"%.*s\", expected a \"true\" or \"false\"\n", (int)size, sub); _exit(1); } if(hflip) capture_source.flip |= GSR_FLIP_HORIZONTAL; } else if(string_starts_with(sub, size, "vflip=")) { sub += 6; size -= 6; bool vflip = false; if(!string_to_bool(sub, size, &vflip)) { fprintf(stderr, "gsr error: invalid bool value for option vflip: \"%.*s\", expected a \"true\" or \"false\"\n", (int)size, sub); _exit(1); } if(vflip) capture_source.flip |= GSR_FLIP_VERTICAL; } else if(string_starts_with(sub, size, "camera_fps=")) { sub += 11; size -= 11; if(!string_to_int(sub, size, &capture_source.camera_fps)) { fprintf(stderr, "gsr error: invalid capture target value for option camera_fps: \"%.*s\", expected a number\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "camera_width=")) { sub += 13; size -= 13; if(!string_to_int(sub, size, &capture_source.camera_resolution.x)) { fprintf(stderr, "gsr error: invalid capture target value for option camera_width: \"%.*s\", expected a number\n", (int)size, sub); _exit(1); } } else if(string_starts_with(sub, size, "camera_height=")) { sub += 14; size -= 14; if(!string_to_int(sub, size, &capture_source.camera_resolution.y)) { fprintf(stderr, "gsr error: invalid capture target value for option camera_height: \"%.*s\", expected a number\n", (int)size, sub); _exit(1); } } else { fprintf(stderr, "gsr error: invalid capture target option \"%.*s\", expected x, y, width, height, halign, valign, pixfmt, hflip, vflip, camera_fps, camera_width or camera_height\n", (int)size, sub); _exit(1); } return true; }); } static std::vector parse_capture_source_arg(const char *capture_source_arg, const args_parser &arg_parser) { std::vector requested_capture_sources; const bool has_multiple_capture_sources = strchr(capture_source_arg, '|') != nullptr; split_string(capture_source_arg, '|', [&](const char *sub, size_t size) { if(size == 0) return true; const char *substr_start = sub; size_t capture_source_size = size; const char *capture_source_end = (const char*)memchr(sub, ';', size); if(capture_source_end) capture_source_size = capture_source_end - sub; CaptureSource capture_source; capture_source.region_pos = arg_parser.region_position; capture_source.region_size = arg_parser.region_size; if(string_starts_with(sub, capture_source_size, "monitor:")) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_MONITOR; sub += 8; capture_source_size -= 8; } else if(string_starts_with(sub, capture_source_size, "window:")) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_WINDOW; sub += 7; capture_source_size -= 7; } else if(string_starts_with(sub, capture_source_size, "v4l2:")) { capture_source.type = GSR_CAPTURE_SOURCE_TYPE_V4L2; sub += 5; capture_source_size -= 5; } else { capture_source_type_from_string(sub, capture_source_size, capture_source); } capture_source.name.assign(sub, capture_source_size); if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_WINDOW) { if(!string_to_int(capture_source.name.c_str(), capture_source.name.size(), &capture_source.window_id)) { fprintf(stderr, "gsr error: invalid window number %s\n", capture_source.name.c_str()); args_parser_print_usage(); _exit(1); } } if(has_multiple_capture_sources) { capture_source.halign = GSR_CAPTURE_ALIGN_START; capture_source.valign = GSR_CAPTURE_ALIGN_START; capture_source.pos = {0, 0, VVEC2I_TYPE_PIXELS, VVEC2I_TYPE_PIXELS}; } parse_capture_source_options(std::string(substr_start, size), capture_source); requested_capture_sources.push_back(capture_source); return true; }); return requested_capture_sources; } static bool audio_inputs_has_app_audio(const std::vector &audio_inputs) { for(const auto &audio_input : audio_inputs) { if(audio_input.type == AudioInputType::APPLICATION) return true; } return false; } static bool merged_audio_inputs_has_app_audio(const std::vector &merged_audio_inputs) { for(const auto &merged_audio_input : merged_audio_inputs) { if(audio_inputs_has_app_audio(merged_audio_input.audio_inputs)) return true; } return false; } // Should use amix if more than 1 audio device and 0 application audio, merged static bool audio_inputs_should_use_amix(const std::vector &audio_inputs) { int num_audio_devices = 0; int num_app_audio = 0; for(const auto &audio_input : audio_inputs) { if(audio_input.type == AudioInputType::DEVICE) ++num_audio_devices; else if(audio_input.type == AudioInputType::APPLICATION) ++num_app_audio; } return num_audio_devices > 1 && num_app_audio == 0; } static bool merged_audio_inputs_should_use_amix(const std::vector &merged_audio_inputs) { for(const auto &merged_audio_input : merged_audio_inputs) { if(audio_inputs_should_use_amix(merged_audio_input.audio_inputs)) return true; } return false; } static void validate_merged_audio_inputs_app_audio(const std::vector &merged_audio_inputs, const std::vector &app_audio_names) { for(const auto &merged_audio_input : merged_audio_inputs) { int num_app_audio = 0; int num_app_inverted_audio = 0; for(const auto &audio_input : merged_audio_input.audio_inputs) { if(audio_input.type == AudioInputType::APPLICATION) { if(audio_input.inverted) ++num_app_inverted_audio; else ++num_app_audio; } } match_app_audio_input_to_available_apps(merged_audio_input.audio_inputs, app_audio_names); if(num_app_audio > 0 && num_app_inverted_audio > 0) { fprintf(stderr, "gsr error: argument -a was provided with both app: and app-inverse:, only one of them can be used for one audio track\n"); _exit(2); } } } static gsr_audio_codec select_audio_codec_with_fallback(gsr_audio_codec audio_codec, const std::string &file_extension, bool uses_amix) { switch(audio_codec) { case GSR_AUDIO_CODEC_AAC: { if(file_extension == "webm") { //audio_codec_to_use = "opus"; audio_codec = GSR_AUDIO_CODEC_OPUS; fprintf(stderr, "gsr warning: .webm files only support opus audio codec, changing audio codec from aac to opus\n"); } break; } case GSR_AUDIO_CODEC_OPUS: { if(file_extension != "mp4" && file_extension != "mkv" && file_extension != "webm" && file_extension != "ts") { //audio_codec_to_use = "aac"; audio_codec = GSR_AUDIO_CODEC_AAC; fprintf(stderr, "gsr warning: opus audio codec is only supported by .mp4, .mkv, .webm and .ts files, falling back to aac instead\n"); } break; } case GSR_AUDIO_CODEC_FLAC: { // TODO: Also check mpegts? if(file_extension == "webm") { //audio_codec_to_use = "opus"; audio_codec = GSR_AUDIO_CODEC_OPUS; fprintf(stderr, "gsr warning: .webm files only support opus audio codec, changing audio codec from flac to opus\n"); } else if(file_extension != "mp4" && file_extension != "mkv") { //audio_codec_to_use = "aac"; audio_codec = GSR_AUDIO_CODEC_AAC; fprintf(stderr, "gsr warning: flac audio codec is only supported by .mp4 and .mkv files, falling back to aac instead\n"); } else if(uses_amix) { // TODO: remove this? is it true anymore? //audio_codec_to_use = "opus"; audio_codec = GSR_AUDIO_CODEC_OPUS; fprintf(stderr, "gsr warning: flac audio codec is not supported when mixing audio sources, falling back to opus instead\n"); } break; } } return audio_codec; } static bool video_codec_only_supports_low_power_mode(const gsr_supported_video_codecs &supported_video_codecs, gsr_video_codec video_codec) { switch(video_codec) { case GSR_VIDEO_CODEC_H264: return supported_video_codecs.h264.low_power; case GSR_VIDEO_CODEC_HEVC: return supported_video_codecs.hevc.low_power; case GSR_VIDEO_CODEC_HEVC_HDR: return supported_video_codecs.hevc_hdr.low_power; case GSR_VIDEO_CODEC_HEVC_10BIT: return supported_video_codecs.hevc_10bit.low_power; case GSR_VIDEO_CODEC_AV1: return supported_video_codecs.av1.low_power; case GSR_VIDEO_CODEC_AV1_HDR: return supported_video_codecs.av1_hdr.low_power; case GSR_VIDEO_CODEC_AV1_10BIT: return supported_video_codecs.av1_10bit.low_power; case GSR_VIDEO_CODEC_VP8: return supported_video_codecs.vp8.low_power; case GSR_VIDEO_CODEC_VP9: return supported_video_codecs.vp9.low_power; case GSR_VIDEO_CODEC_H264_VULKAN: return supported_video_codecs.h264.low_power; case GSR_VIDEO_CODEC_HEVC_VULKAN: return supported_video_codecs.hevc.low_power; case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: return supported_video_codecs.hevc_hdr.low_power; case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: return supported_video_codecs.hevc_10bit.low_power; case GSR_VIDEO_CODEC_AV1_VULKAN: return supported_video_codecs.av1.low_power; case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: return supported_video_codecs.av1_hdr.low_power; case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: return supported_video_codecs.av1_10bit.low_power; } return false; } static const AVCodec* get_av_codec_if_supported(gsr_video_codec video_codec, gsr_egl *egl, bool use_software_video_encoder, const gsr_supported_video_codecs *supported_video_codecs) { switch(video_codec) { case GSR_VIDEO_CODEC_H264: case GSR_VIDEO_CODEC_H264_VULKAN: { if(use_software_video_encoder) return avcodec_find_encoder_by_name("libx264"); else if(supported_video_codecs->h264.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_HEVC: case GSR_VIDEO_CODEC_HEVC_VULKAN: { if(supported_video_codecs->hevc.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_HEVC_HDR: case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: { if(supported_video_codecs->hevc_hdr.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_HEVC_10BIT: case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: { if(supported_video_codecs->hevc_10bit.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_AV1: case GSR_VIDEO_CODEC_AV1_VULKAN: { if(supported_video_codecs->av1.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_AV1_HDR: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: { if(supported_video_codecs->av1_hdr.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_AV1_10BIT: case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: { if(supported_video_codecs->av1_10bit.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_VP8: { if(supported_video_codecs->vp8.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } case GSR_VIDEO_CODEC_VP9: { if(supported_video_codecs->vp9.supported) return get_ffmpeg_video_codec(video_codec, egl->gpu_info.vendor); break; } } return nullptr; } static vec2i codec_get_max_resolution(gsr_video_codec video_codec, bool use_software_video_encoder, const gsr_supported_video_codecs *supported_video_codecs) { switch(video_codec) { case GSR_VIDEO_CODEC_H264: case GSR_VIDEO_CODEC_H264_VULKAN: { if(use_software_video_encoder) return {4096, 2304}; else if(supported_video_codecs->h264.supported) return supported_video_codecs->h264.max_resolution; break; } case GSR_VIDEO_CODEC_HEVC: case GSR_VIDEO_CODEC_HEVC_VULKAN: { if(supported_video_codecs->hevc.supported) return supported_video_codecs->hevc.max_resolution; break; } case GSR_VIDEO_CODEC_HEVC_HDR: case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: { if(supported_video_codecs->hevc_hdr.supported) return supported_video_codecs->hevc_hdr.max_resolution; break; } case GSR_VIDEO_CODEC_HEVC_10BIT: case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: { if(supported_video_codecs->hevc_10bit.supported) return supported_video_codecs->hevc_10bit.max_resolution; break; } case GSR_VIDEO_CODEC_AV1: case GSR_VIDEO_CODEC_AV1_VULKAN: { if(supported_video_codecs->av1.supported) return supported_video_codecs->av1.max_resolution; break; } case GSR_VIDEO_CODEC_AV1_HDR: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: { if(supported_video_codecs->av1_hdr.supported) return supported_video_codecs->av1_hdr.max_resolution; break; } case GSR_VIDEO_CODEC_AV1_10BIT: case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: { if(supported_video_codecs->av1_10bit.supported) return supported_video_codecs->av1_10bit.max_resolution; break; } case GSR_VIDEO_CODEC_VP8: { if(supported_video_codecs->vp8.supported) return supported_video_codecs->vp8.max_resolution; break; } case GSR_VIDEO_CODEC_VP9: { if(supported_video_codecs->vp9.supported) return supported_video_codecs->vp9.max_resolution; break; } } return {0, 0}; } static bool codec_supports_resolution(vec2i codec_max_resolution, vec2i capture_resolution) { if(codec_max_resolution.x == 0 || codec_max_resolution.y == 0) return true; return codec_max_resolution.x >= capture_resolution.x && codec_max_resolution.y >= capture_resolution.y; } static void print_codec_error(gsr_video_codec video_codec) { if(video_codec == (gsr_video_codec)GSR_VIDEO_CODEC_AUTO) video_codec = GSR_VIDEO_CODEC_H264; const char *video_codec_name = video_codec_to_string(video_codec); fprintf(stderr, "gsr error: your gpu does not support '%s' video codec. If you are sure that your gpu does support '%s' video encoding and you are using an AMD/Intel GPU,\n" " then make sure you have installed the GPU specific vaapi packages (intel-media-driver, libva-intel-driver, libva-mesa-driver and linux-firmware).\n" " It's also possible that your distro has disabled hardware accelerated video encoding for '%s' video codec.\n" " This may be the case on corporate distros such as Manjaro, Fedora or OpenSUSE.\n" " You can test this by running 'vainfo | grep VAEntrypointEncSlice' to see if it matches any H264/HEVC/AV1/VP8/VP9 profile.\n" " On such distros, you need to manually install mesa from source to enable H264/HEVC hardware acceleration, or use a more user friendly distro. Alternatively record with AV1 if supported by your GPU.\n" " You can alternatively use the flatpak version of GPU Screen Recorder (https://flathub.org/apps/com.dec05eba.gpu_screen_recorder) which bypasses system issues with patented H264/HEVC codecs.\n" " If your GPU doesn't support hardware accelerated video encoding then you can use '-fallback-cpu-encoding yes' option to encode with your cpu instead.\n", video_codec_name, video_codec_name, video_codec_name); } static void force_cpu_encoding(args_parser *args_parser) { args_parser->video_codec = GSR_VIDEO_CODEC_H264; args_parser->video_encoder = GSR_VIDEO_ENCODER_HW_CPU; if(args_parser->bitrate_mode == GSR_BITRATE_MODE_VBR) { fprintf(stderr, "gsr warning: bitrate mode has been forcefully set to qp because software encoding option doesn't support vbr option\n"); args_parser->bitrate_mode = GSR_BITRATE_MODE_QP; } } static const AVCodec* pick_video_codec(gsr_egl *egl, args_parser *args_parser, bool use_fallback_codec, bool *low_power, gsr_supported_video_codecs *supported_video_codecs) { // TODO: software encoder for hevc, av1, vp8 and vp9 *low_power = false; const AVCodec *video_codec_f = get_av_codec_if_supported(args_parser->video_codec, egl, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, supported_video_codecs); if(!video_codec_f && use_fallback_codec && args_parser->video_encoder != GSR_VIDEO_ENCODER_HW_CPU) { switch(args_parser->video_codec) { case GSR_VIDEO_CODEC_H264: { fprintf(stderr, "gsr error: selected video codec h264 is not supported by your hardware\n"); if(args_parser->fallback_cpu_encoding) { fprintf(stderr, "gsr warning: gpu encoding is not available on your system, trying cpu encoding instead because -fallback-cpu-encoding is enabled. Install the proper vaapi drivers on your system (if supported) if you experience performance issues\n"); force_cpu_encoding(args_parser); } break; } case GSR_VIDEO_CODEC_HEVC: case GSR_VIDEO_CODEC_HEVC_HDR: case GSR_VIDEO_CODEC_HEVC_10BIT: { fprintf(stderr, "gsr warning: selected video codec hevc is not supported by your hardware, trying h264 instead\n"); args_parser->video_codec = GSR_VIDEO_CODEC_H264; return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs); } case GSR_VIDEO_CODEC_AV1: case GSR_VIDEO_CODEC_AV1_HDR: case GSR_VIDEO_CODEC_AV1_10BIT: { fprintf(stderr, "gsr warning: selected video codec av1 is not supported by your hardware, trying h264 instead\n"); args_parser->video_codec = GSR_VIDEO_CODEC_H264; return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs); } case GSR_VIDEO_CODEC_VP8: case GSR_VIDEO_CODEC_VP9: // TODO: Cant fallback to other codec because webm only supports vp8/vp9 break; case GSR_VIDEO_CODEC_H264_VULKAN: { fprintf(stderr, "gsr warning: selected video codec h264_vulkan is not supported by your hardware, trying h264 instead\n"); args_parser->video_codec = GSR_VIDEO_CODEC_H264; // Need to do a query again because this time it's without vulkan if(!get_supported_video_codecs(egl, args_parser->video_codec, false, true, supported_video_codecs)) { fprintf(stderr, "gsr error: failed to query for supported video codecs\n"); print_codec_error(args_parser->video_codec); _exit(11); } return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs); } case GSR_VIDEO_CODEC_HEVC_VULKAN: case GSR_VIDEO_CODEC_HEVC_HDR_VULKAN: case GSR_VIDEO_CODEC_HEVC_10BIT_VULKAN: { fprintf(stderr, "gsr warning: selected video codec hevc_vulkan is not supported by your hardware, trying hevc instead\n"); args_parser->video_codec = GSR_VIDEO_CODEC_HEVC; // Need to do a query again because this time it's without vulkan if(!get_supported_video_codecs(egl, args_parser->video_codec, false, true, supported_video_codecs)) { fprintf(stderr, "gsr error: failed to query for supported video codecs\n"); print_codec_error(args_parser->video_codec); _exit(11); } return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs); } case GSR_VIDEO_CODEC_AV1_VULKAN: case GSR_VIDEO_CODEC_AV1_HDR_VULKAN: case GSR_VIDEO_CODEC_AV1_10BIT_VULKAN: { fprintf(stderr, "gsr warning: selected video codec av1_vulkan is not supported by your hardware, trying av1 instead\n"); args_parser->video_codec = GSR_VIDEO_CODEC_AV1; // Need to do a query again because this time it's without vulkan if(!get_supported_video_codecs(egl, args_parser->video_codec, false, true, supported_video_codecs)) { fprintf(stderr, "gsr error: failed to query for supported video codecs\n"); print_codec_error(args_parser->video_codec); _exit(11); } return pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs); } } video_codec_f = get_av_codec_if_supported(args_parser->video_codec, egl, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, supported_video_codecs); } if(!video_codec_f) { print_codec_error(args_parser->video_codec); _exit(54); } *low_power = video_codec_only_supports_low_power_mode(*supported_video_codecs, args_parser->video_codec); return video_codec_f; } /* Returns -1 if none is available */ static gsr_video_codec select_appropriate_video_codec_automatically(vec2i video_size, const gsr_supported_video_codecs *supported_video_codecs) { if(supported_video_codecs->h264.supported && codec_supports_resolution(supported_video_codecs->h264.max_resolution, video_size)) { fprintf(stderr, "gsr info: using h264 encoder because a codec was not specified\n"); return GSR_VIDEO_CODEC_H264; } else if(supported_video_codecs->hevc.supported && codec_supports_resolution(supported_video_codecs->hevc.max_resolution, video_size)) { fprintf(stderr, "gsr info: using hevc encoder because a codec was not specified and h264 supported max resolution (%dx%d) is less than the capture resolution (%dx%d)\n", supported_video_codecs->h264.max_resolution.x, supported_video_codecs->h264.max_resolution.y, video_size.x, video_size.y); return GSR_VIDEO_CODEC_HEVC; } else if(supported_video_codecs->av1.supported && codec_supports_resolution(supported_video_codecs->av1.max_resolution, video_size)) { fprintf(stderr, "gsr info: using av1 encoder because a codec was not specified and hevc supported max resolution (%dx%d) is less than the capture resolution (%dx%d)\n", supported_video_codecs->hevc.max_resolution.x, supported_video_codecs->hevc.max_resolution.y, video_size.x, video_size.y); return GSR_VIDEO_CODEC_AV1; } else { return (gsr_video_codec)-1; } } static const AVCodec* select_video_codec_with_fallback(vec2i video_size, args_parser *args_parser, const char *file_extension, gsr_egl *egl, bool *low_power) { gsr_supported_video_codecs supported_video_codecs_non_vulkan; get_supported_video_codecs(egl, args_parser->video_codec, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, true, &supported_video_codecs_non_vulkan); gsr_supported_video_codecs supported_video_codecs_vulkan = supported_video_codecs_non_vulkan; set_supported_video_codecs_ffmpeg(&supported_video_codecs_non_vulkan, &supported_video_codecs_vulkan, egl->gpu_info.vendor); gsr_supported_video_codecs *supported_video_codecs = video_codec_is_vulkan(args_parser->video_codec) ? &supported_video_codecs_vulkan : &supported_video_codecs_non_vulkan; const bool video_codec_auto = args_parser->video_codec == (gsr_video_codec)GSR_VIDEO_CODEC_AUTO; if(video_codec_auto) { if(strcmp(file_extension, "webm") == 0) { fprintf(stderr, "gsr info: using vp8 encoder because a codec was not specified and the file extension is .webm\n"); args_parser->video_codec = GSR_VIDEO_CODEC_VP8; } else if(args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU) { fprintf(stderr, "gsr info: using h264 encoder because a codec was not specified\n"); args_parser->video_codec = GSR_VIDEO_CODEC_H264; } else if(args_parser->video_encoder != GSR_VIDEO_ENCODER_HW_CPU) { args_parser->video_codec = select_appropriate_video_codec_automatically(video_size, &supported_video_codecs_non_vulkan); if(args_parser->video_codec == (gsr_video_codec)-1) { if(args_parser->fallback_cpu_encoding) { fprintf(stderr, "gsr warning: gpu encoding is not available on your system or your gpu doesn't support recording at the resolution you are trying to record, trying cpu encoding instead because -fallback-cpu-encoding is enabled. Install the proper vaapi drivers on your system (if supported) if you experience performance issues\n"); force_cpu_encoding(args_parser); } else { fprintf(stderr, "gsr error: no video encoder was specified and neither h264, hevc nor av1 are supported on your system or you are trying to capture at a resolution higher than your system supports for each codec.\n"); fprintf(stderr, " Ensure that you have installed the proper vaapi driver. If your gpu doesn't support video encoding then you can run gpu-screen-recorder with \"-fallback-cpu-encoding yes\" option to use cpu encoding.\n"); _exit(52); } } } } if(LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(60, 10, 100) && strcmp(file_extension, "flv") == 0) { if(args_parser->video_codec != GSR_VIDEO_CODEC_H264) { args_parser->video_codec = GSR_VIDEO_CODEC_H264; fprintf(stderr, "gsr warning: hevc/av1 is not compatible with flv in your outdated version of ffmpeg, falling back to h264 instead.\n"); } } else if(strcmp(file_extension, "m3u8") == 0) { if(video_codec_is_av1(args_parser->video_codec)) { args_parser->video_codec = GSR_VIDEO_CODEC_HEVC; fprintf(stderr, "gsr warning: av1 is not compatible with hls (m3u8), falling back to hevc instead.\n"); } } const AVCodec *codec = pick_video_codec(egl, args_parser, true, low_power, supported_video_codecs); const vec2i codec_max_resolution = codec_get_max_resolution(args_parser->video_codec, args_parser->video_encoder == GSR_VIDEO_ENCODER_HW_CPU, supported_video_codecs); if(!codec_supports_resolution(codec_max_resolution, video_size)) { const char *video_codec_name = video_codec_to_string(args_parser->video_codec); fprintf(stderr, "gsr error: The max resolution for video codec %s is %dx%d while you are trying to capture at resolution %dx%d. Change capture resolution or video codec and try again\n", video_codec_name, codec_max_resolution.x, codec_max_resolution.y, video_size.x, video_size.y); _exit(53); } return codec; } static std::vector create_device_audio_inputs(const std::vector &audio_inputs, AVCodecContext *audio_codec_context, int num_channels, double num_audio_frames_shift, std::vector &src_filter_ctx, bool use_amix) { std::vector audio_track_audio_devices; for(size_t i = 0; i < audio_inputs.size(); ++i) { const auto &audio_input = audio_inputs[i]; AVFilterContext *src_ctx = nullptr; if(use_amix) src_ctx = src_filter_ctx[i]; AudioDeviceData audio_device; audio_device.audio_input = audio_input; audio_device.src_filter_ctx = src_ctx; if(audio_input.name.empty()) { audio_device.sound_device.handle = NULL; audio_device.sound_device.frames = 0; } else { const std::string description = "gsr-" + audio_input.name; if(sound_device_get_by_name(&audio_device.sound_device, description.c_str(), audio_input.name.c_str(), description.c_str(), num_channels, audio_codec_context->frame_size, audio_codec_context_get_audio_format(audio_codec_context)) != 0) { fprintf(stderr, "gsr error: failed to get \"%s\" audio device\n", audio_input.name.c_str()); _exit(1); } } audio_device.frame = create_audio_frame(audio_codec_context); audio_device.frame->pts = -audio_codec_context->frame_size * num_audio_frames_shift; audio_track_audio_devices.push_back(std::move(audio_device)); } return audio_track_audio_devices; } #ifdef GSR_APP_AUDIO static AudioDeviceData create_application_audio_audio_input(const MergedAudioInputs &merged_audio_inputs, AVCodecContext *audio_codec_context, int num_channels, double num_audio_frames_shift, gsr_pipewire_audio *pipewire_audio) { AudioDeviceData audio_device; audio_device.frame = create_audio_frame(audio_codec_context); audio_device.frame->pts = -audio_codec_context->frame_size * num_audio_frames_shift; char random_str[8]; if(!generate_random_characters_standard_alphabet(random_str, sizeof(random_str))) { fprintf(stderr, "gsr error: failed to generate random string\n"); _exit(1); } std::string combined_sink_name = "gsr-combined-"; combined_sink_name.append(random_str, sizeof(random_str)); combined_sink_name += ".monitor"; if(sound_device_get_by_name(&audio_device.sound_device, combined_sink_name.c_str(), "", "gpu-screen-recorder", num_channels, audio_codec_context->frame_size, audio_codec_context_get_audio_format(audio_codec_context)) != 0) { fprintf(stderr, "gsr error: failed to setup audio recording to combined sink\n"); _exit(1); } std::vector audio_devices_sources; for(const auto &audio_input : merged_audio_inputs.audio_inputs) { if(audio_input.type == AudioInputType::DEVICE) audio_devices_sources.push_back(audio_input.name.c_str()); } bool app_audio_inverted = false; std::vector app_names; for(const auto &audio_input : merged_audio_inputs.audio_inputs) { if(audio_input.type == AudioInputType::APPLICATION) { app_names.push_back(audio_input.name.c_str()); app_audio_inverted = audio_input.inverted; } } if(!audio_devices_sources.empty()) { if(!gsr_pipewire_audio_add_link_from_sources_to_stream(pipewire_audio, audio_devices_sources.data(), audio_devices_sources.size(), combined_sink_name.c_str())) { fprintf(stderr, "gsr error: failed to add application audio link\n"); _exit(1); } } if(app_audio_inverted) { if(!gsr_pipewire_audio_add_link_from_apps_to_stream_inverted(pipewire_audio, app_names.data(), app_names.size(), combined_sink_name.c_str())) { fprintf(stderr, "gsr error: failed to add application audio link\n"); _exit(1); } } else { if(!gsr_pipewire_audio_add_link_from_apps_to_stream(pipewire_audio, app_names.data(), app_names.size(), combined_sink_name.c_str())) { fprintf(stderr, "gsr error: failed to add application audio link\n"); _exit(1); } } return audio_device; } #endif static bool get_image_format_from_filename(const char *filename, gsr_image_format *image_format) { if(string_ends_with(filename, ".jpg") || string_ends_with(filename, ".jpeg")) { *image_format = GSR_IMAGE_FORMAT_JPEG; return true; } else if(string_ends_with(filename, ".png")) { *image_format = GSR_IMAGE_FORMAT_PNG; return true; } else { return false; } } // TODO: replace this with start_recording_create_steams static bool av_open_file_write_header(AVFormatContext *av_format_context, const char *filename, const char *ffmpeg_opts) { int ret = avio_open(&av_format_context->pb, filename, AVIO_FLAG_WRITE); if(ret < 0) { fprintf(stderr, "gsr error: Could not open '%s': %s\n", filename, av_error_to_string(ret)); return false; } AVDictionary *options = nullptr; av_dict_set(&options, "strict", "experimental", 0); if(ffmpeg_opts) av_dict_parse_string(&options, ffmpeg_opts, "=", ";", 0); ret = avformat_write_header(av_format_context, &options); if(ret < 0) fprintf(stderr, "Error occurred when writing header to output file: %s\n", av_error_to_string(ret)); const bool success = ret >= 0; if(!success) avio_close(av_format_context->pb); av_dict_free(&options); return success; } static int audio_codec_get_frame_size(gsr_audio_codec audio_codec) { switch(audio_codec) { case GSR_AUDIO_CODEC_AAC: return 1024; case GSR_AUDIO_CODEC_OPUS: return 960; case GSR_AUDIO_CODEC_FLAC: assert(false); return 1024; } assert(false); return 1024; } static size_t calculate_estimated_replay_buffer_packets(int64_t replay_buffer_size_secs, int fps, gsr_audio_codec audio_codec, const std::vector &audio_inputs) { if(replay_buffer_size_secs == -1) return 0; int audio_fps = 0; if(!audio_inputs.empty()) audio_fps = AUDIO_SAMPLE_RATE / audio_codec_get_frame_size(audio_codec); return replay_buffer_size_secs * (fps + audio_fps * audio_inputs.size()); } static void set_display_server_environment_variables() { // Some users dont have properly setup environments (no display manager that does systemctl --user import-environment DISPLAY WAYLAND_DISPLAY) const char *display = getenv("DISPLAY"); if(!display) { display = ":0"; setenv("DISPLAY", display, true); } const char *wayland_display = getenv("WAYLAND_DISPLAY"); if(!wayland_display) { wayland_display = "wayland-0"; setenv("WAYLAND_DISPLAY", wayland_display, true); } } static bool is_capturing_damage_tracked_target(const std::vector &capture_sources) { for(const CaptureSource &capture_source : capture_sources) { if(capture_source.type != GSR_CAPTURE_SOURCE_TYPE_V4L2) return true; } return false; } static bool is_capturing_type(const std::vector &capture_sources, CaptureSourceType target_type) { for(const CaptureSource &capture_source : capture_sources) { if(capture_source.type == target_type) return true; } return false; } static bool has_capture_source_with_region_set(const std::vector &capture_sources) { for(const CaptureSource &capture_source : capture_sources) { if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_REGION && capture_source.region_set) return true; } return false; } static bool is_capturing_monitor_or_region(const std::vector &capture_sources) { for(const CaptureSource &capture_source : capture_sources) { if(capture_source.type == GSR_CAPTURE_SOURCE_TYPE_MONITOR || capture_source.type == GSR_CAPTURE_SOURCE_TYPE_REGION) return true; } return false; } static void validate_args_with_capture_sources(args_parser &arg_parser, const std::vector &capture_sources) { const Arg *output_resolution_arg = args_parser_get_arg(&arg_parser, "-s"); assert(output_resolution_arg); const Arg *region_arg = args_parser_get_arg(&arg_parser, "-region"); assert(region_arg); if(is_capturing_type(capture_sources, GSR_CAPTURE_SOURCE_TYPE_FOCUSED_WINDOW) && output_resolution_arg->num_values == 0) { fprintf(stderr, "gsr error: option -s is required when using '-w focused' option\n"); args_parser_print_usage(); _exit(1); } const bool is_capturing_region = is_capturing_type(capture_sources, GSR_CAPTURE_SOURCE_TYPE_REGION); if(region_arg->num_values == 0) { if(is_capturing_region && !has_capture_source_with_region_set(capture_sources)) { fprintf(stderr, "gsr error: option -region is required when '-w region' is used\n"); args_parser_print_usage(); _exit(1); } } else { if(is_capturing_region) { fprintf(stderr, "gsr warning: option -region is deprecated, use -w with region directly instead, for example: -w %s\n", region_arg->values[0]); } else { fprintf(stderr, "gsr error: option -region can only be used when option '-w region' is used\n"); args_parser_print_usage(); _exit(1); } } if(!arg_parser.restore_portal_session && is_capturing_type(capture_sources, GSR_CAPTURE_SOURCE_TYPE_PORTAL)) fprintf(stderr, "gsr info: option '-w portal' was used without '-restore-portal-session yes'. The previous screencast session will be ignored\n"); } static void install_cuda_no_stable_perf_limit() { const char *home = getenv("HOME"); if(!home) { fprintf(stderr, "gsr warning: install_cuda_no_stable_perf_limit: $HOME not set\n"); return; } char nv_profiles_path[4096]; snprintf(nv_profiles_path, sizeof(nv_profiles_path), "%s/.nv/nvidia-application-profiles-rc.d", home); if(create_directory_recursive(nv_profiles_path) != 0) { fprintf(stderr, "gsr warning: install_cuda_no_stable_perf_limit: failed to create directory: %s\n", nv_profiles_path); return; } snprintf(nv_profiles_path, sizeof(nv_profiles_path), "%s/.nv/nvidia-application-profiles-rc.d/10-gsr-cuda-no-stable-perf-limit", home); FILE *f = fopen(nv_profiles_path, "wb"); if(!f) { fprintf(stderr, "gsr warning: install_cuda_no_stable_perf_limit: failed to create file: %s\n", nv_profiles_path); return; } const char *profile_data = "{\n" " \"profiles\": [\n" " {\n" " \"name\": \"CudaNoStablePerfLimit\",\n" " \"settings\": [\"0x166c5e\", 0]\n" " }\n" " ],\n" " \"rules\": [\n" " { \"pattern\": \"gpu-screen-recorder\", \"profile\": \"CudaNoStablePerfLimit\" }\n" " ]\n" "}\n"; fwrite(profile_data, 1, strlen(profile_data), f); fclose(f); } int main(int argc, char **argv) { setlocale(LC_ALL, "C"); // Sigh... stupid C #ifdef __GLIBC__ mallopt(M_MMAP_THRESHOLD, 65536); #endif signal(SIGINT, stop_handler); signal(SIGTERM, stop_handler); signal(SIGUSR1, save_replay_handler); signal(SIGUSR2, toggle_pause_handler); signal(SIGRTMIN, toggle_replay_recording_handler); signal(SIGRTMIN+1, save_replay_10_seconds_handler); signal(SIGRTMIN+2, save_replay_30_seconds_handler); signal(SIGRTMIN+3, save_replay_1_minute_handler); signal(SIGRTMIN+4, save_replay_5_minutes_handler); signal(SIGRTMIN+5, save_replay_10_minutes_handler); signal(SIGRTMIN+6, save_replay_30_minutes_handler); set_display_server_environment_variables(); install_cuda_no_stable_perf_limit(); // Linux nvidia driver 580.105.08 added the environment variable CUDA_DISABLE_PERF_BOOST to disable the p2 power level issue, // where running cuda (which includes nvenc) causes the gpu to be forcefully set to p2 power level which on many nvidia gpus // decreases gpu performance in games. On my GTX 1080 it decreased game performance by 10% for absolutely no reason. // TODO: This only seems to allow the gpu to go to lower power level states, but not higher than p2. setenv("CUDA_DISABLE_PERF_BOOST", "1", true); // Stop nvidia driver from buffering frames setenv("__GL_MaxFramesAllowed", "1", true); // If this is set to 1 then cuGraphicsGLRegisterImage will fail for egl context with error: invalid OpenGL or DirectX context, // so we overwrite it setenv("__GL_THREADED_OPTIMIZATIONS", "0", true); // Some people set this to nvidia (for nvdec) or vdpau (for nvidia vdpau), which breaks gpu screen recorder since // nvidia doesn't support vaapi and nvidia-vaapi-driver doesn't support encoding yet. // Let vaapi find the right vaapi driver instead of forcing a specific one. unsetenv("LIBVA_DRIVER_NAME"); // Some people set this to force all applications to vsync on nvidia, but this makes eglSwapBuffers never return. unsetenv("__GL_SYNC_TO_VBLANK"); // Same as above, but for amd/intel unsetenv("vblank_mode"); if(geteuid() == 0) { fprintf(stderr, "gsr error: don't run gpu-screen-recorder as the root user\n"); _exit(1); } args_handlers arg_handlers; arg_handlers.version = version_command; arg_handlers.info = info_command; arg_handlers.list_audio_devices = list_audio_devices_command; arg_handlers.list_application_audio = list_application_audio_command; arg_handlers.list_v4l2_devices = list_v4l2_devices; arg_handlers.list_capture_options = list_capture_options_command; arg_handlers.list_monitors = list_monitors_command; args_parser arg_parser; if(!args_parser_parse(&arg_parser, argc, argv, &arg_handlers, NULL)) _exit(1); if(!arg_parser.low_power) { // Forces low latency encoding mode. Use this environment variable until vaapi supports setting this as a parameter. // The downside of this is that it always uses maximum power, which is not ideal for replay mode that runs on system startup. // This option was added in mesa 24.1.4, released in july 17, 2024. // Seems like the performance issue is not in encoding, but rendering the frame. // Some frames end up taking 10 times longer. Seems to be an issue with amd gpu power management when letting the application sleep on the cpu side? setenv("AMD_DEBUG", "lowlatencyenc", true); } std::vector capture_sources = parse_capture_source_arg(arg_parser.capture_source, arg_parser); if(capture_sources.empty()) { fprintf(stderr, "gsr error: option -w can't be empty. You need to capture video from at least one source\n"); args_parser_print_usage(); _exit(1); } validate_args_with_capture_sources(arg_parser, capture_sources); //av_log_set_level(AV_LOG_TRACE); const Arg *audio_input_arg = args_parser_get_arg(&arg_parser, "-a"); assert(audio_input_arg); AudioDevices audio_devices; if(audio_input_arg->num_values > 0) audio_devices = get_pulseaudio_inputs(); std::vector requested_audio_inputs = parse_audio_inputs(audio_devices, audio_input_arg); const bool uses_app_audio = merged_audio_inputs_has_app_audio(requested_audio_inputs); std::vector app_audio_names; #ifdef GSR_APP_AUDIO gsr_pipewire_audio pipewire_audio; memset(&pipewire_audio, 0, sizeof(pipewire_audio)); if(uses_app_audio) { if(!pulseaudio_server_is_pipewire()) { fprintf(stderr, "gsr error: your sound server is not PipeWire. Application audio is only available when running PipeWire audio server\n"); _exit(2); } if(!gsr_pipewire_audio_init(&pipewire_audio)) { fprintf(stderr, "gsr error: failed to setup PipeWire audio for application audio capture\n"); _exit(2); } gsr_pipewire_audio_for_each_app(&pipewire_audio, [](const char *app_name, void *userdata) { std::vector *app_audio_names = (std::vector*)userdata; app_audio_names->push_back(app_name); return true; }, &app_audio_names); } #else if(uses_app_audio) { fprintf(stderr, "gsr error: application audio can't be recorded because GPU Screen Recorder is built without application audio support (-Dapp_audio option)\n"); _exit(2); } #endif validate_merged_audio_inputs_app_audio(requested_audio_inputs, app_audio_names); const bool is_replaying = arg_parser.replay_buffer_size_secs != -1; bool wayland = false; Display *dpy = XOpenDisplay(nullptr); if(dpy) { XSelectInput(dpy, DefaultRootWindow(dpy), PropertyChangeMask); } else { wayland = true; fprintf(stderr, "gsr warning: failed to connect to the X server. Assuming wayland is running without Xwayland\n"); } XSetErrorHandler(x11_error_handler); XSetIOErrorHandler(x11_io_error_handler); if(!wayland) wayland = is_xwayland(dpy); if(!wayland && is_using_prime_run()) { // Disable prime-run and similar options as it doesn't work, the monitor to capture has to be run on the same device. // This is fine on wayland since nvidia uses drm interface there and the monitor query checks the monitors connected // to the drm device. fprintf(stderr, "gsr warning: use of prime-run on X11 is not supported. Disabling prime-run\n"); disable_prime_run(); } gsr_window *window = gsr_window_create(dpy, wayland); if(!window) { fprintf(stderr, "gsr error: failed to create window\n"); _exit(1); } if(is_capturing_type(capture_sources, GSR_CAPTURE_SOURCE_TYPE_PORTAL)) { if(is_using_prime_run()) { fprintf(stderr, "gsr warning: use of prime-run with -w portal option is currently not supported. Disabling prime-run\n"); disable_prime_run(); } if(video_codec_is_hdr(arg_parser.video_codec)) { fprintf(stderr, "gsr warning: portal capture option doesn't support hdr yet (PipeWire doesn't support hdr), the video will be tonemapped from hdr to sdr\n"); arg_parser.video_codec = hdr_video_codec_to_sdr_video_codec(arg_parser.video_codec); } } gsr_egl egl; if(!gsr_egl_load(&egl, window, is_capturing_monitor_or_region(capture_sources), arg_parser.gl_debug)) { fprintf(stderr, "gsr error: failed to load opengl\n"); _exit(1); } gsr_shader_enable_debug_output(arg_parser.gl_debug); #ifndef NDEBUG gsr_shader_enable_debug_output(true); #endif if(!args_parser_validate_with_gl_info(&arg_parser, &egl)) _exit(1); egl.card_path[0] = '\0'; if(monitor_capture_use_drm(window, egl.gpu_info.vendor)) { // TODO: Allow specifying another card, and in other places if(!gsr_get_valid_card_path(&egl, egl.card_path, is_capturing_monitor_or_region(capture_sources))) { fprintf(stderr, "gsr error: no /dev/dri/cardX device found. Make sure that you have at least one monitor connected or record a single window instead on X11 or record with the -w portal option\n"); _exit(2); } } else { gsr_get_valid_card_path(&egl, egl.card_path, false); } memset(&x11_cursor, 0, sizeof(x11_cursor)); x11_cursor_display = NULL; if(gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_X11 && arg_parser.record_cursor) { x11_cursor_display = (Display*)gsr_window_get_display(egl.window); gsr_cursor_init(&x11_cursor, &egl, x11_cursor_display); } // if(wayland && arg_parser.capture_source_type == GSR_CAPTURE_SOURCE_TYPE_MONITOR) { // fprintf(stderr, "gsr warning: it's not possible to sync video to recorded monitor exactly on wayland when recording a monitor." // " If you experience stutter in the video then record with portal capture option instead (-w portal) or use X11 instead\n"); // } gsr_image_format image_format; if(get_image_format_from_filename(arg_parser.filename, &image_format)) { if(audio_input_arg->num_values > 0) { fprintf(stderr, "gsr error: can't record audio (-a) when taking a screenshot\n"); _exit(1); } capture_image_to_file(arg_parser, &egl, window, image_format, capture_sources); _exit(0); } AVFormatContext *av_format_context; // The output format is automatically guessed by the file extension avformat_alloc_output_context2(&av_format_context, nullptr, arg_parser.container_format, arg_parser.filename); if (!av_format_context) { if(arg_parser.container_format) { fprintf(stderr, "gsr error: Container format '%s' (argument -c) is not valid\n", arg_parser.container_format); } else { fprintf(stderr, "gsr error: Failed to deduce container format from file extension. Use the '-c' option to specify container format\n"); args_parser_print_usage(); _exit(1); } _exit(1); } set_format_context_options(av_format_context); const AVOutputFormat *output_format = av_format_context->oformat; std::string file_extension = output_format->extensions ? output_format->extensions : ""; { size_t comma_index = file_extension.find(','); if(comma_index != std::string::npos) file_extension = file_extension.substr(0, comma_index); } const bool force_no_audio_offset = arg_parser.is_livestream || arg_parser.is_output_piped || (file_extension != "mp4" && file_extension != "mkv" && file_extension != "webm"); const double target_fps = 1.0 / (double)arg_parser.fps; const bool uses_amix = merged_audio_inputs_should_use_amix(requested_audio_inputs); arg_parser.audio_codec = select_audio_codec_with_fallback(arg_parser.audio_codec, file_extension, uses_amix); vec2i video_size = {0, 0}; std::vector video_sources = create_video_sources(arg_parser, &egl, false, capture_sources, video_size); // (Some?) livestreaming services require at least one audio track to work. // If not audio is provided then create one silent audio track. if(arg_parser.is_livestream && requested_audio_inputs.empty()) { fprintf(stderr, "gsr info: live streaming but no audio track was added. Adding a silent audio track\n"); MergedAudioInputs mai; mai.audio_inputs.push_back({""}); requested_audio_inputs.push_back(std::move(mai)); } AVStream *video_stream = nullptr; std::vector audio_tracks; if(arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU && arg_parser.video_codec != (gsr_video_codec)GSR_VIDEO_CODEC_AUTO && arg_parser.video_codec != GSR_VIDEO_CODEC_H264) { fprintf(stderr, "gsr error: -encoder cpu was specified but a codec other than h264 was specified. -encoder cpu supports only h264 at the moment\n"); _exit(1); } bool low_power = false; const AVCodec *video_codec_f = select_video_codec_with_fallback(video_size, &arg_parser, file_extension.c_str(), &egl, &low_power); const enum AVPixelFormat video_pix_fmt = get_pixel_format(arg_parser.video_codec, egl.gpu_info.vendor, arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU); AVCodecContext *video_codec_context = create_video_codec_context(video_pix_fmt, video_codec_f, egl, arg_parser, video_size.x, video_size.y); if(!is_replaying) video_stream = create_stream(av_format_context, video_codec_context); AVFrame *video_frame = av_frame_alloc(); if(!video_frame) { fprintf(stderr, "gsr error: Failed to allocate video frame\n"); _exit(1); } video_frame->format = video_codec_context->pix_fmt; video_frame->width = video_size.x; video_frame->height = video_size.y; video_frame->color_range = video_codec_context->color_range; video_frame->color_primaries = video_codec_context->color_primaries; video_frame->color_trc = video_codec_context->color_trc; video_frame->colorspace = video_codec_context->colorspace; video_frame->chroma_location = video_codec_context->chroma_sample_location; const size_t estimated_replay_buffer_packets = calculate_estimated_replay_buffer_packets(arg_parser.replay_buffer_size_secs, arg_parser.fps, arg_parser.audio_codec, requested_audio_inputs); gsr_encoder encoder; if(!gsr_encoder_init(&encoder, arg_parser.replay_storage, estimated_replay_buffer_packets, arg_parser.replay_buffer_size_secs, arg_parser.filename)) { fprintf(stderr, "gsr error: failed to create encoder\n"); _exit(1); } gsr_video_encoder *video_encoder = create_video_encoder(&egl, arg_parser); if(!video_encoder) { fprintf(stderr, "gsr error: failed to create video encoder\n"); _exit(1); } if(!gsr_video_encoder_start(video_encoder, video_codec_context, video_frame)) { fprintf(stderr, "gsr error: failed to start video encoder\n"); _exit(1); } video_size.x = video_codec_context->width; video_size.y = video_codec_context->height; video_sources_update_with_real_video_size(capture_sources, video_sources, video_size); const Arg *plugin_arg = args_parser_get_arg(&arg_parser, "-p"); assert(plugin_arg); gsr_plugins plugins; memset(&plugins, 0, sizeof(plugins)); if(plugin_arg->num_values > 0) load_plugins(&plugins, arg_parser, &egl, video_size); gsr_color_conversion_params color_conversion_params; memset(&color_conversion_params, 0, sizeof(color_conversion_params)); color_conversion_params.color_range = arg_parser.color_range; color_conversion_params.egl = &egl; color_conversion_params.load_external_image_shader = any_video_sources_uses_external_image(video_sources); gsr_video_encoder_get_textures(video_encoder, color_conversion_params.destination_textures, color_conversion_params.destination_textures_size, &color_conversion_params.num_destination_textures, &color_conversion_params.destination_color); gsr_color_conversion color_conversion; if(gsr_color_conversion_init(&color_conversion, &color_conversion_params) != 0) { fprintf(stderr, "gsr error: main: failed to create color conversion\n"); _exit(1); } gsr_color_conversion_clear(&color_conversion); gsr_color_conversion *output_color_conversion = plugins.num_plugins > 0 ? &plugins.color_conversion : &color_conversion; if(arg_parser.video_encoder == GSR_VIDEO_ENCODER_HW_CPU) { open_video_software(video_codec_context, arg_parser); } else { open_video_hardware(video_codec_context, low_power, egl, arg_parser); } if(video_stream) { avcodec_parameters_from_context(video_stream->codecpar, video_codec_context); const size_t video_destination_id = gsr_encoder_add_recording_destination(&encoder, video_codec_context, av_format_context, video_stream, 0); if(arg_parser.write_first_frame_ts && video_destination_id != (size_t)-1) { std::string ts_filepath = std::string(arg_parser.filename) + ".ts"; gsr_encoder_set_recording_destination_first_frame_ts_filepath(&encoder, video_destination_id, ts_filepath.c_str()); } } int audio_max_frame_size = 1024; int audio_stream_index = VIDEO_STREAM_INDEX + 1; for(const MergedAudioInputs &merged_audio_inputs : requested_audio_inputs) { const bool use_amix = audio_inputs_should_use_amix(merged_audio_inputs.audio_inputs); AVCodecContext *audio_codec_context = create_audio_codec_context(arg_parser.fps, arg_parser.audio_codec, use_amix, arg_parser.audio_bitrate); AVStream *audio_stream = nullptr; if(!is_replaying) { audio_stream = create_stream(av_format_context, audio_codec_context); if(gsr_encoder_add_recording_destination(&encoder, audio_codec_context, av_format_context, audio_stream, 0) == (size_t)-1) fprintf(stderr, "gsr error: added too many audio sources\n"); } if(audio_stream && !merged_audio_inputs.track_name.empty()) av_dict_set(&audio_stream->metadata, "title", merged_audio_inputs.track_name.c_str(), 0); open_audio(audio_codec_context, arg_parser.ffmpeg_audio_opts); if(audio_stream) avcodec_parameters_from_context(audio_stream->codecpar, audio_codec_context); #if LIBAVCODEC_VERSION_MAJOR < 60 const int num_channels = audio_codec_context->channels; #else const int num_channels = audio_codec_context->ch_layout.nb_channels; #endif //audio_frame->sample_rate = audio_codec_context->sample_rate; std::vector src_filter_ctx; AVFilterGraph *graph = nullptr; AVFilterContext *sink = nullptr; if(use_amix) { int err = init_filter_graph(audio_codec_context, &graph, &sink, src_filter_ctx, merged_audio_inputs.audio_inputs.size()); if(err < 0) { fprintf(stderr, "gsr error: failed to create audio filter\n"); _exit(1); } } // TODO: Cleanup above const double audio_fps = (double)audio_codec_context->sample_rate / (double)audio_codec_context->frame_size; const double timeout_sec = 1000.0 / audio_fps / 1000.0; const double audio_startup_time_seconds = force_no_audio_offset ? 0 : audio_codec_get_desired_delay(arg_parser.audio_codec, arg_parser.fps);// * ((double)audio_codec_context->frame_size / 1024.0); const double num_audio_frames_shift = audio_startup_time_seconds / timeout_sec; std::vector audio_track_audio_devices; if(audio_inputs_has_app_audio(merged_audio_inputs.audio_inputs)) { assert(!use_amix); #ifdef GSR_APP_AUDIO audio_track_audio_devices.push_back(create_application_audio_audio_input(merged_audio_inputs, audio_codec_context, num_channels, num_audio_frames_shift, &pipewire_audio)); #endif } else { audio_track_audio_devices = create_device_audio_inputs(merged_audio_inputs.audio_inputs, audio_codec_context, num_channels, num_audio_frames_shift, src_filter_ctx, use_amix); } AudioTrack audio_track; audio_track.name = merged_audio_inputs.track_name; audio_track.codec_context = audio_codec_context; audio_track.audio_devices = std::move(audio_track_audio_devices); audio_track.graph = graph; audio_track.sink = sink; audio_track.stream_index = audio_stream_index; audio_track.pts = -audio_codec_context->frame_size * num_audio_frames_shift; audio_tracks.push_back(std::move(audio_track)); ++audio_stream_index; audio_max_frame_size = std::max(audio_max_frame_size, audio_codec_context->frame_size); } //av_dump_format(av_format_context, 0, filename, 1); if(!is_replaying) { if(!av_open_file_write_header(av_format_context, arg_parser.filename, arg_parser.ffmpeg_opts)) _exit(1); } double fps_start_time = clock_get_monotonic_seconds(); //double frame_timer_start = fps_start_time; int fps_counter = 0; int damage_fps_counter = 0; bool paused = false; std::atomic paused_time_offset(0.0); double paused_time_start = 0.0; bool replay_recording = false; RecordingStartResult replay_recording_start_result; std::vector replay_recording_items; std::string replay_recording_filepath; bool force_iframe_frame = false; // Only needed for video since audio frames are always iframes std::mutex audio_filter_mutex; const double record_start_time = clock_get_monotonic_seconds(); const size_t audio_buffer_size = audio_max_frame_size * 4 * 2; // max 4 bytes/sample, 2 channels uint8_t *empty_audio = (uint8_t*)malloc(audio_buffer_size); if(!empty_audio) { fprintf(stderr, "gsr error: failed to create empty audio\n"); _exit(1); } memset(empty_audio, 0, audio_buffer_size); for(AudioTrack &audio_track : audio_tracks) { for(AudioDeviceData &audio_device : audio_track.audio_devices) { audio_device.thread = std::thread([&]() mutable { const AVSampleFormat sound_device_sample_format = audio_format_to_sample_format(audio_codec_context_get_audio_format(audio_track.codec_context)); // TODO: Always do conversion for now. This fixes issue with stuttering audio on pulseaudio with opus + multiple audio sources merged const bool needs_audio_conversion = true;//audio_track.codec_context->sample_fmt != sound_device_sample_format; SwrContext *swr = nullptr; if(needs_audio_conversion) { swr = swr_alloc(); if(!swr) { fprintf(stderr, "Failed to create SwrContext\n"); _exit(1); } #if LIBAVUTIL_VERSION_MAJOR <= 56 av_opt_set_channel_layout(swr, "in_channel_layout", AV_CH_LAYOUT_STEREO, 0); av_opt_set_channel_layout(swr, "out_channel_layout", AV_CH_LAYOUT_STEREO, 0); #elif LIBAVUTIL_VERSION_MAJOR >= 59 av_opt_set_chlayout(swr, "in_chlayout", &audio_track.codec_context->ch_layout, 0); av_opt_set_chlayout(swr, "out_chlayout", &audio_track.codec_context->ch_layout, 0); #else av_opt_set_chlayout(swr, "in_channel_layout", &audio_track.codec_context->ch_layout, 0); av_opt_set_chlayout(swr, "out_channel_layout", &audio_track.codec_context->ch_layout, 0); #endif av_opt_set_int(swr, "in_sample_rate", audio_track.codec_context->sample_rate, 0); av_opt_set_int(swr, "out_sample_rate", audio_track.codec_context->sample_rate, 0); av_opt_set_sample_fmt(swr, "in_sample_fmt", sound_device_sample_format, 0); av_opt_set_sample_fmt(swr, "out_sample_fmt", audio_track.codec_context->sample_fmt, 0); swr_init(swr); } const double audio_fps = (double)audio_track.codec_context->sample_rate / (double)audio_track.codec_context->frame_size; const int64_t timeout_ms = std::round(1000.0 / audio_fps); const double timeout_sec = 1000.0 / audio_fps / 1000.0; bool first_frame = true; int64_t num_received_frames = 0; while(running) { void *sound_buffer; int sound_buffer_size = -1; const double time_before_read_seconds = clock_get_monotonic_seconds(); if(audio_device.sound_device.handle) { // TODO: use this instead of calculating time to read. But this can fluctuate and we dont want to go back in time, // also it's 0.0 for some users??? double latency_seconds = 0.0; sound_buffer_size = sound_device_read_next_chunk(&audio_device.sound_device, &sound_buffer, timeout_sec * 2.0, &latency_seconds); } const bool got_audio_data = sound_buffer_size >= 0; //fprintf(stderr, "got audio data: %s\n", got_audio_data ? "yes" : "no"); //fprintf(stderr, "time to read: %f, %s, %f\n", time_to_read_seconds, got_audio_data ? "yes" : "no", timeout_sec); const double this_audio_frame_time = clock_get_monotonic_seconds() - paused_time_offset; if(paused) { if(!audio_device.sound_device.handle) av_usleep(timeout_ms * 1000); continue; } int ret = av_frame_make_writable(audio_device.frame); if (ret < 0) { fprintf(stderr, "Failed to make audio frame writable\n"); break; } // TODO: Is this |received_audio_time| really correct? const int64_t num_expected_frames = std::floor((this_audio_frame_time - record_start_time) / timeout_sec); int64_t num_missing_frames = std::max((int64_t)0LL, num_expected_frames - num_received_frames); if(got_audio_data) num_missing_frames = std::max((int64_t)0LL, num_missing_frames - 1); if(!audio_device.sound_device.handle) num_missing_frames = std::max((int64_t)1, num_missing_frames); // Fucking hell is there a better way to do this? I JUST WANT TO KEEP VIDEO AND AUDIO SYNCED HOLY FUCK I WANT TO KILL MYSELF NOW. // THIS PIECE OF SHIT WANTS EMPTY FRAMES OTHERWISE VIDEO PLAYS TOO FAST TO KEEP UP WITH AUDIO OR THE AUDIO PLAYS TOO EARLY. // BUT WE CANT USE DELAYS TO GIVE DUMMY DATA BECAUSE PULSEAUDIO MIGHT GIVE AUDIO A BIG DELAYED!!! // This garbage is needed because we want to produce constant frame rate videos instead of variable frame rate // videos because bad software such as video editing software and VLC do not support variable frame rate software, // despite nvidia shadowplay and xbox game bar producing variable frame rate videos. // So we have to make sure we produce frames at the same relative rate as the video. if((num_missing_frames >= 1 && got_audio_data) || num_missing_frames >= 5 || !audio_device.sound_device.handle) { // TODO: //audio_track.frame->data[0] = empty_audio; if(first_frame || num_missing_frames >= 5) { if(needs_audio_conversion) swr_convert(swr, &audio_device.frame->data[0], audio_track.codec_context->frame_size, (const uint8_t**)&empty_audio, audio_track.codec_context->frame_size); else audio_device.frame->data[0] = empty_audio; } first_frame = false; // TODO: Check if duplicate frame can be saved just by writing it with a different pts instead of sending it again std::lock_guard lock(audio_filter_mutex); for(int i = 0; i < num_missing_frames; ++i) { if(audio_track.graph) { // TODO: av_buffersrc_add_frame if(av_buffersrc_write_frame(audio_device.src_filter_ctx, audio_device.frame) < 0) { fprintf(stderr, "gsr error: failed to add audio frame to filter\n"); } } else { ret = avcodec_send_frame(audio_track.codec_context, audio_device.frame); if(ret >= 0) { // TODO: Move to separate thread because this could write to network (for example when livestreaming) gsr_encoder_receive_packets(&encoder, audio_track.codec_context, audio_device.frame->pts, audio_track.stream_index); } else { fprintf(stderr, "Failed to encode audio!\n"); } audio_track.pts += audio_track.codec_context->frame_size; } audio_device.frame->pts += audio_track.codec_context->frame_size; num_received_frames++; } } if(!audio_device.sound_device.handle) { av_usleep(timeout_ms * 1000); } else if(got_audio_data) { // TODO: Instead of converting audio, get float audio from alsa. Or does alsa do conversion internally to get this format? if(needs_audio_conversion) swr_convert(swr, &audio_device.frame->data[0], audio_track.codec_context->frame_size, (const uint8_t**)&sound_buffer, audio_track.codec_context->frame_size); else audio_device.frame->data[0] = (uint8_t*)sound_buffer; first_frame = false; std::lock_guard lock(audio_filter_mutex); if(audio_track.graph) { // TODO: av_buffersrc_add_frame if(av_buffersrc_write_frame(audio_device.src_filter_ctx, audio_device.frame) < 0) { fprintf(stderr, "gsr error: failed to add audio frame to filter\n"); } } else { ret = avcodec_send_frame(audio_track.codec_context, audio_device.frame); if(ret >= 0) { // TODO: Move to separate thread because this could write to network (for example when livestreaming) gsr_encoder_receive_packets(&encoder, audio_track.codec_context, audio_device.frame->pts, audio_track.stream_index); } else { fprintf(stderr, "Failed to encode audio!\n"); } audio_track.pts += audio_track.codec_context->frame_size; } audio_device.frame->pts += audio_track.codec_context->frame_size; num_received_frames++; } else { // TODO: Maybe sleep for time_to_sleep_until_next_frame/4? for better latency const double time_after_read_seconds = clock_get_monotonic_seconds(); const double time_to_read_seconds = time_after_read_seconds - time_before_read_seconds; const double time_to_sleep_until_next_frame = timeout_sec - time_to_read_seconds; if(time_to_sleep_until_next_frame > 0.0) av_usleep(time_to_sleep_until_next_frame * 1000ULL * 1000ULL); } } if(swr) swr_free(&swr); }); } } std::thread amix_thread; if(uses_amix) { amix_thread = std::thread([&]() { AVFrame *aframe = av_frame_alloc(); while(running) { { std::lock_guard lock(audio_filter_mutex); for(AudioTrack &audio_track : audio_tracks) { if(!audio_track.sink) continue; int err = 0; while ((err = av_buffersink_get_frame(audio_track.sink, aframe)) >= 0) { aframe->pts = audio_track.pts; err = avcodec_send_frame(audio_track.codec_context, aframe); if(err >= 0){ // TODO: Move to separate thread because this could write to network (for example when livestreaming) gsr_encoder_receive_packets(&encoder, audio_track.codec_context, aframe->pts, audio_track.stream_index); } else { fprintf(stderr, "Failed to encode audio!\n"); } av_frame_unref(aframe); audio_track.pts += audio_track.codec_context->frame_size; } } } av_usleep(5 * 1000); // 5 milliseconds } av_frame_free(&aframe); }); } // Set update_fps to 24 to test if duplicate/delayed frames cause video/audio desync or too fast/slow video. //const double update_fps = fps + 190; bool should_stop_error = false; int64_t video_pts_counter = 0; int64_t video_prev_pts = 0; bool hdr_metadata_set = false; const bool hdr = video_codec_is_hdr(arg_parser.video_codec); bool use_damage_tracking = false; gsr_damage damage; memset(&damage, 0, sizeof(damage)); if(arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONTENT && is_capturing_damage_tracked_target(capture_sources)) { if(gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_X11) { gsr_damage_init(&damage, &egl, &x11_cursor, arg_parser.record_cursor); use_damage_tracking = true; for(const CaptureSource &capture_source : capture_sources) { switch(capture_source.type) { case GSR_CAPTURE_SOURCE_TYPE_WINDOW: gsr_damage_start_tracking_window(&damage, capture_source.window_id); break; case GSR_CAPTURE_SOURCE_TYPE_MONITOR: case GSR_CAPTURE_SOURCE_TYPE_REGION: // TODO: When capturing a region only track damage in that region gsr_damage_start_tracking_monitor(&damage, capture_source.name.c_str()); break; default: break; } } } else if(is_capturing_monitor_or_region(capture_sources)) { fprintf(stderr, "gsr warning: \"-fm content\" has no effect on Wayland when recording a monitor. Either record a monitor on X11 or capture with desktop portal instead (-w portal)\n"); } } while(running) { while(gsr_window_process_event(window)) { if(x11_cursor_display && arg_parser.record_cursor) gsr_cursor_on_event(&x11_cursor, gsr_window_get_event_data(window)); gsr_damage_on_event(&damage, gsr_window_get_event_data(window)); for(VideoSource &video_source : video_sources) { gsr_capture_on_event(video_source.capture, &egl); } } if(x11_cursor_display && arg_parser.record_cursor) gsr_cursor_tick(&x11_cursor, DefaultRootWindow(x11_cursor_display)); gsr_damage_tick(&damage); should_stop_error = false; bool damaged = false; if(use_damage_tracking) damaged = gsr_damage_is_damaged(&damage); for(VideoSource &video_source : video_sources) { gsr_capture_tick(video_source.capture); if(gsr_capture_should_stop(video_source.capture, &should_stop_error)) { running = 0; break; } if(video_source.capture_source->type == GSR_CAPTURE_SOURCE_TYPE_FOCUSED_WINDOW) { assert(video_source.capture->get_window_id); const Window damage_target_window = video_source.capture->get_window_id(video_source.capture); if((int64_t)damage_target_window != video_source.capture_source->window_id) { gsr_damage_stop_tracking_window(&damage, video_source.capture_source->window_id); if(damage_target_window != 0) gsr_damage_start_tracking_window(&damage, damage_target_window); } video_source.capture_source->window_id = damage_target_window; } if(video_source.capture->is_damaged) damaged |= video_source.capture->is_damaged(video_source.capture); else if(!use_damage_tracking) damaged = true; } // TODO: Readd wayland sync warning when removing this if(arg_parser.framerate_mode != GSR_FRAMERATE_MODE_CONTENT) damaged = true; if(damaged) ++damage_fps_counter; ++fps_counter; const double time_now = clock_get_monotonic_seconds(); //const double frame_timer_elapsed = time_now - frame_timer_start; const double elapsed = time_now - fps_start_time; if (elapsed >= 1.0) { if(arg_parser.verbose) { fprintf(stderr, "update fps: %d, damage fps: %d\n", fps_counter, damage_fps_counter); } fps_start_time = time_now; fps_counter = 0; damage_fps_counter = 0; } const double this_video_frame_time = clock_get_monotonic_seconds() - paused_time_offset; const int64_t expected_frames = std::floor((this_video_frame_time - record_start_time) / target_fps); const int64_t num_missed_frames = expected_frames - video_pts_counter; if(damaged && num_missed_frames >= 1 && !paused) { // TODO: Dont do this if no damage? egl.glClear(0); gsr_damage_clear(&damage); gsr_capture_kms_cleanup_kms_fds(); if(kms_client_initialized) { if(gsr_kms_client_get_kms(&kms_client, &kms_response) != 0) fprintf(stderr, "gsr error: failed to get kms, error: %d (%s)\n", kms_response.result, kms_response.err_msg); } bool capture_has_synchronous_task = false; for(VideoSource &video_source : video_sources) { if(video_source.capture->clear_damage) video_source.capture->clear_damage(video_source.capture); if(video_source.capture->capture_has_synchronous_task) { capture_has_synchronous_task = video_source.capture->capture_has_synchronous_task(video_source.capture); if(capture_has_synchronous_task) { paused_time_start = clock_get_monotonic_seconds(); paused = true; } } } for(VideoSource &video_source : video_sources) { if(video_source.capture->pre_capture) video_source.capture->pre_capture(video_source.capture, &video_source.metadata, output_color_conversion); } if(output_color_conversion->schedule_clear) { output_color_conversion->schedule_clear = false; gsr_color_conversion_clear(output_color_conversion); } for(VideoSource &video_source : video_sources) { gsr_capture_capture(video_source.capture, &video_source.metadata, output_color_conversion); } gsr_capture_kms_cleanup_kms_fds(); if(plugins.num_plugins > 0) { gsr_plugins_draw(&plugins); gsr_color_conversion_draw(&color_conversion, plugins.texture, {0, 0}, video_size, {0, 0}, video_size, video_size, GSR_ROT_0, GSR_FLIP_NONE, GSR_SOURCE_COLOR_RGB, false); } if(capture_has_synchronous_task) { paused_time_offset = paused_time_offset + (clock_get_monotonic_seconds() - paused_time_start); paused = false; } gsr_egl_swap_buffers(&egl); gsr_video_encoder_copy_textures_to_frame(video_encoder, video_frame, output_color_conversion); for(VideoSource &video_source : video_sources) { if(hdr && !hdr_metadata_set && !is_replaying && add_hdr_metadata_to_video_stream(video_source.capture, video_stream)) hdr_metadata_set = true; } // TODO: Check if duplicate frame can be saved just by writing it with a different pts instead of sending it again const int num_frames_to_encode = arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONSTANT ? num_missed_frames : 1; for(int i = 0; i < num_frames_to_encode; ++i) { if(arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONSTANT) { video_frame->pts = video_pts_counter + i; } else { video_frame->pts = (this_video_frame_time - record_start_time) * (double)AV_TIME_BASE; const bool same_pts = video_frame->pts == video_prev_pts; video_prev_pts = video_frame->pts; if(same_pts) continue; } if(force_iframe_frame) { video_frame->pict_type = AV_PICTURE_TYPE_I; } int ret = avcodec_send_frame(video_codec_context, video_frame); if(ret == 0) { // TODO: Move to separate thread because this could write to network (for example when livestreaming) gsr_encoder_receive_packets(&encoder, video_codec_context, video_frame->pts, VIDEO_STREAM_INDEX); } else { fprintf(stderr, "gsr error: avcodec_send_frame failed, error: %s\n", av_error_to_string(ret)); } if(force_iframe_frame) { force_iframe_frame = false; video_frame->pict_type = AV_PICTURE_TYPE_NONE; } } video_pts_counter += num_missed_frames; } if(toggle_pause == 1 && !is_replaying) { const bool new_paused_state = !paused; if(new_paused_state) { paused_time_start = clock_get_monotonic_seconds(); fprintf(stderr, "Paused\n"); } else { paused_time_offset = paused_time_offset + (clock_get_monotonic_seconds() - paused_time_start); fprintf(stderr, "Unpaused\n"); } toggle_pause = 0; paused = !paused; } if(toggle_replay_recording && !arg_parser.replay_recording_directory) { toggle_replay_recording = 0; printf("gsr error: Unable to start recording since the -ro option was not specified\n"); fflush(stdout); } if(toggle_replay_recording && arg_parser.replay_recording_directory) { toggle_replay_recording = 0; const bool new_replay_recording_state = !replay_recording; if(new_replay_recording_state) { std::lock_guard lock(audio_filter_mutex); replay_recording_items.clear(); replay_recording_filepath = create_new_recording_filepath_from_timestamp(arg_parser.replay_recording_directory, "Video", file_extension, arg_parser.date_folders); replay_recording_start_result = start_recording_create_streams(replay_recording_filepath.c_str(), arg_parser, video_codec_context, audio_tracks, hdr, video_sources); if(replay_recording_start_result.av_format_context) { const size_t video_recording_destination_id = gsr_encoder_add_recording_destination(&encoder, video_codec_context, replay_recording_start_result.av_format_context, replay_recording_start_result.video_stream, video_frame->pts); if(arg_parser.write_first_frame_ts && video_recording_destination_id != (size_t)-1) { std::string ts_filepath = replay_recording_filepath + ".ts"; gsr_encoder_set_recording_destination_first_frame_ts_filepath(&encoder, video_recording_destination_id, ts_filepath.c_str()); } if(video_recording_destination_id != (size_t)-1) replay_recording_items.push_back(video_recording_destination_id); for(const auto &audio_input : replay_recording_start_result.audio_inputs) { const size_t audio_recording_destination_id = gsr_encoder_add_recording_destination(&encoder, audio_input.audio_track->codec_context, replay_recording_start_result.av_format_context, audio_input.stream, audio_input.audio_track->pts); if(audio_recording_destination_id != (size_t)-1) replay_recording_items.push_back(audio_recording_destination_id); } replay_recording = true; force_iframe_frame = true; fprintf(stderr, "Started recording\n"); } else { printf("gsr error: Failed to start recording\n"); fflush(stdout); } } else if(replay_recording_start_result.av_format_context) { for(size_t id : replay_recording_items) { gsr_encoder_remove_recording_destination(&encoder, id); } replay_recording_items.clear(); if(stop_recording_close_streams(replay_recording_start_result.av_format_context)) { fprintf(stderr, "Stopped recording\n"); puts(replay_recording_filepath.c_str()); fflush(stdout); if(arg_parser.recording_saved_script) run_recording_saved_script_async(arg_parser.recording_saved_script, replay_recording_filepath.c_str(), "regular"); } else { printf("gsr error: Failed to save recording\n"); fflush(stdout); } replay_recording_start_result = RecordingStartResult{}; replay_recording = false; replay_recording_filepath.clear(); } } if(save_replay_thread.valid() && save_replay_thread.wait_for(std::chrono::seconds(0)) == std::future_status::ready) { save_replay_thread.get(); if(save_replay_output_filepath.empty()) { printf("gsr error: Failed to save replay\n"); fflush(stdout); } else { puts(save_replay_output_filepath.c_str()); fflush(stdout); if(arg_parser.recording_saved_script) run_recording_saved_script_async(arg_parser.recording_saved_script, save_replay_output_filepath.c_str(), "replay"); } } if(save_replay_seconds != 0 && !save_replay_thread.valid() && is_replaying) { int current_save_replay_seconds = save_replay_seconds; if(current_save_replay_seconds > 0) current_save_replay_seconds += arg_parser.keyint; save_replay_seconds = 0; save_replay_output_filepath.clear(); save_replay_async(video_codec_context, VIDEO_STREAM_INDEX, audio_tracks, &encoder, arg_parser, file_extension, arg_parser.date_folders, hdr, video_sources, current_save_replay_seconds); if(arg_parser.restart_replay_on_save && current_save_replay_seconds == save_replay_seconds_full) { pthread_mutex_lock(&encoder.replay_mutex); gsr_replay_buffer_clear(encoder.replay_buffer); pthread_mutex_unlock(&encoder.replay_mutex); } } const double time_at_frame_end = clock_get_monotonic_seconds() - paused_time_offset; const double time_elapsed_total = time_at_frame_end - record_start_time; const int64_t frames_elapsed = std::floor(time_elapsed_total / target_fps); const double time_at_next_frame = (frames_elapsed + 1) * target_fps; double time_to_next_frame = time_at_next_frame - time_elapsed_total; if(time_to_next_frame > target_fps) time_to_next_frame = target_fps; const int64_t end_num_missed_frames = frames_elapsed - video_pts_counter; if(time_to_next_frame > 0.0 && end_num_missed_frames <= 0) av_usleep(time_to_next_frame * 1000.0 * 1000.0); else { if(paused) av_usleep(20.0 * 1000.0); // 20 milliseconds else if(arg_parser.framerate_mode == GSR_FRAMERATE_MODE_CONTENT) av_usleep(2.8 * 1000.0); // 2.8 milliseconds } } running = 0; if(save_replay_thread.valid()) { save_replay_thread.get(); if(save_replay_output_filepath.empty()) { // TODO: Output failed to save } else { puts(save_replay_output_filepath.c_str()); fflush(stdout); if(arg_parser.recording_saved_script) run_recording_saved_script_async(arg_parser.recording_saved_script, save_replay_output_filepath.c_str(), "replay"); } } gsr_plugins_deinit(&plugins); if(replay_recording_start_result.av_format_context) { for(size_t id : replay_recording_items) { gsr_encoder_remove_recording_destination(&encoder, id); } replay_recording_items.clear(); if(stop_recording_close_streams(replay_recording_start_result.av_format_context)) { fprintf(stderr, "Stopped recording\n"); puts(replay_recording_filepath.c_str()); fflush(stdout); if(arg_parser.recording_saved_script) run_recording_saved_script_async(arg_parser.recording_saved_script, replay_recording_filepath.c_str(), "regular"); } else { printf("gsr error: Failed to save recording\n"); fflush(stdout); } } for(AudioTrack &audio_track : audio_tracks) { for(auto &audio_device : audio_track.audio_devices) { audio_device.thread.join(); sound_device_close(&audio_device.sound_device); } } if(amix_thread.joinable()) amix_thread.join(); // TODO: Replace this with start_recording_create_steams if(!is_replaying && av_write_trailer(av_format_context) != 0) { //fprintf(stderr, "Failed to write trailer\n"); } if(!is_replaying) { avio_close(av_format_context->pb); avformat_free_context(av_format_context); } gsr_cursor_deinit(&x11_cursor); gsr_damage_deinit(&damage); gsr_color_conversion_deinit(&color_conversion); gsr_video_encoder_destroy(video_encoder, video_codec_context); gsr_encoder_deinit(&encoder); for(VideoSource &video_source : video_sources) { gsr_capture_destroy(video_source.capture); } #ifdef GSR_APP_AUDIO gsr_pipewire_audio_deinit(&pipewire_audio); #endif if(kms_client_initialized) { gsr_capture_kms_cleanup_kms_fds(); gsr_kms_client_deinit(&kms_client); } if(!is_replaying && arg_parser.recording_saved_script) run_recording_saved_script_async(arg_parser.recording_saved_script, arg_parser.filename, "regular"); if(dpy) { // TODO: This causes a crash, why? maybe some other library dlclose xlib and that also happened to unload this??? //XCloseDisplay(dpy); } //gsr_egl_unload(&egl); //gsr_window_destroy(&window); //av_frame_free(&video_frame); free(empty_audio); args_parser_deinit(&arg_parser); // We do an _exit here because cuda uses at_exit to do _something_ that causes the program to freeze, // but only on some nvidia driver versions on some gpus (RTX?), and _exit exits the program without calling // the at_exit registered functions. // Cuda (cuvid library in this case) seems to be waiting for a thread that never finishes execution. // Maybe this happens because we dont clean up all ffmpeg resources? // TODO: Investigate this. _exit(should_stop_error ? 3 : 0); } fsdsfdsfdsfdsf-5.13.8/src/pipewire_audio.c000066400000000000000000001145231520215207700205530ustar00rootroot00000000000000#include "../include/pipewire_audio.h" #include #include #include typedef struct { const gsr_pipewire_audio_port *output_port; const gsr_pipewire_audio_port *input_port; } gsr_pipewire_audio_desired_link; static void on_core_info_cb(void *user_data, const struct pw_core_info *info) { gsr_pipewire_audio *self = user_data; //fprintf(stderr, "server name: %s\n", info->name); } static void on_core_error_cb(void *user_data, uint32_t id, int seq, int res, const char *message) { gsr_pipewire_audio *self = user_data; //fprintf(stderr, "gsr error: pipewire: error id:%u seq:%d res:%d: %s\n", id, seq, res, message); pw_thread_loop_signal(self->thread_loop, false); } static void on_core_done_cb(void *user_data, uint32_t id, int seq) { gsr_pipewire_audio *self = user_data; if(id == PW_ID_CORE && self->server_version_sync == seq) pw_thread_loop_signal(self->thread_loop, false); } static const struct pw_core_events core_events = { PW_VERSION_CORE_EVENTS, .info = on_core_info_cb, .done = on_core_done_cb, .error = on_core_error_cb, }; static gsr_pipewire_audio_node* gsr_pipewire_audio_get_node_by_name_case_insensitive(gsr_pipewire_audio *self, const char *node_name, gsr_pipewire_audio_node_type node_type) { for(size_t i = 0; i < self->num_stream_nodes; ++i) { const gsr_pipewire_audio_node *node = &self->stream_nodes[i]; if(node->type == node_type && strcasecmp(node->name, node_name) == 0) return &self->stream_nodes[i]; } return NULL; } static gsr_pipewire_audio_port* gsr_pipewire_audio_get_node_port_by_name(gsr_pipewire_audio *self, uint32_t node_id, const char *port_name) { for(size_t i = 0; i < self->num_ports; ++i) { if(self->ports[i].node_id == node_id && strcmp(self->ports[i].name, port_name) == 0) return &self->ports[i]; } return NULL; } static bool requested_link_matches_name_case_insensitive(const gsr_pipewire_audio_requested_link *requested_link, const char *name) { for(int i = 0; i < requested_link->num_outputs; ++i) { if(requested_link->outputs[i].type == GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD && strcasecmp(requested_link->outputs[i].name, name) == 0) return true; } return false; } static bool requested_link_matches_name_case_insensitive_any_type(const gsr_pipewire_audio *self, const gsr_pipewire_audio_requested_link *requested_link, const char *name) { for(int i = 0; i < requested_link->num_outputs; ++i) { switch(requested_link->outputs[i].type) { case GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD: { if(strcasecmp(requested_link->outputs[i].name, name) == 0) return true; break; } case GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT: { if(strcasecmp(self->default_output_device_name, name) == 0) return true; break; } case GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT: { if(strcasecmp(self->default_input_device_name, name) == 0) return true; break; } } } return false; } static bool requested_link_has_type(const gsr_pipewire_audio_requested_link *requested_link, gsr_pipewire_audio_requested_type type) { for(int i = 0; i < requested_link->num_outputs; ++i) { if(requested_link->outputs[i].type == type) return true; } return false; } static void gsr_pipewire_get_node_input_port_by_type(gsr_pipewire_audio *self, const gsr_pipewire_audio_node *input_node, gsr_pipewire_audio_link_input_type input_type, const gsr_pipewire_audio_port **input_fl_port, const gsr_pipewire_audio_port **input_fr_port) { *input_fl_port = NULL; *input_fr_port = NULL; switch(input_type) { case GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM: { *input_fl_port = gsr_pipewire_audio_get_node_port_by_name(self, input_node->id, "input_FL"); *input_fr_port = gsr_pipewire_audio_get_node_port_by_name(self, input_node->id, "input_FR"); break; } case GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK: { *input_fl_port = gsr_pipewire_audio_get_node_port_by_name(self, input_node->id, "playback_FL"); *input_fr_port = gsr_pipewire_audio_get_node_port_by_name(self, input_node->id, "playback_FR"); break; } } } static bool string_starts_with(const char *str, const char *substr) { const int len = strlen(str); const int substr_len = strlen(substr); return len >= substr_len && memcmp(str, substr, substr_len) == 0; } static bool string_ends_with(const char *str, const char *substr) { const int len = strlen(str); const int substr_len = strlen(substr); return len >= substr_len && memcmp(str + len - substr_len, substr, substr_len) == 0; } /* Returns number of desired links */ static size_t gsr_pipewire_get_node_output_ports(gsr_pipewire_audio *self, const gsr_pipewire_audio_node *output_node, gsr_pipewire_audio_desired_link *desired_links, size_t desired_links_max_size, const gsr_pipewire_audio_port *input_fl_port, const gsr_pipewire_audio_port *input_fr_port) { size_t num_desired_links = 0; for(size_t i = 0; i < self->num_ports && num_desired_links < desired_links_max_size; ++i) { if(self->ports[i].node_id != output_node->id) continue; if(string_starts_with(self->ports[i].name, "playback_")) continue; if(string_ends_with(self->ports[i].name, "_MONO") || string_ends_with(self->ports[i].name, "_FC") || string_ends_with(self->ports[i].name, "_LFE")) { if(num_desired_links + 2 >= desired_links_max_size) break; desired_links[num_desired_links + 0] = (gsr_pipewire_audio_desired_link){ .output_port = &self->ports[i], .input_port = input_fl_port }; desired_links[num_desired_links + 1] = (gsr_pipewire_audio_desired_link){ .output_port = &self->ports[i], .input_port = input_fr_port }; num_desired_links += 2; } else if(string_ends_with(self->ports[i].name, "_FL") || string_ends_with(self->ports[i].name, "_RL") || string_ends_with(self->ports[i].name, "_SL")) { if(num_desired_links + 1 >= desired_links_max_size) break; desired_links[num_desired_links] = (gsr_pipewire_audio_desired_link){ .output_port = &self->ports[i], .input_port = input_fl_port }; num_desired_links += 1; } else if(string_ends_with(self->ports[i].name, "_FR") || string_ends_with(self->ports[i].name, "_RR") || string_ends_with(self->ports[i].name, "_SR")) { if(num_desired_links + 1 >= desired_links_max_size) break; desired_links[num_desired_links] = (gsr_pipewire_audio_desired_link){ .output_port = &self->ports[i], .input_port = input_fr_port }; num_desired_links += 1; } } return num_desired_links; } static void gsr_pipewire_audio_establish_link(gsr_pipewire_audio *self, const gsr_pipewire_audio_port *output_port, const gsr_pipewire_audio_port *input_port) { // TODO: Detect if link already exists before so we dont create these proxies when not needed. // We could do that by saving which nodes have been linked with which nodes after linking them. //fprintf(stderr, "linking!\n"); // TODO: error check and cleanup struct pw_properties *props = pw_properties_new(NULL, NULL); pw_properties_setf(props, PW_KEY_LINK_OUTPUT_PORT, "%u", output_port->id); pw_properties_setf(props, PW_KEY_LINK_INPUT_PORT, "%u", input_port->id); // TODO: Clean this up when removing node struct pw_proxy *proxy = pw_core_create_object(self->core, "link-factory", PW_TYPE_INTERFACE_Link, PW_VERSION_LINK, &props->dict, 0); //self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync); pw_properties_free(props); } static void gsr_pipewire_audio_create_link(gsr_pipewire_audio *self, const gsr_pipewire_audio_requested_link *requested_link) { const gsr_pipewire_audio_node_type requested_link_node_type = requested_link->input_type == GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM ? GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_INPUT : GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE; const gsr_pipewire_audio_node *stream_input_node = gsr_pipewire_audio_get_node_by_name_case_insensitive(self, requested_link->input_name, requested_link_node_type); if(!stream_input_node) return; const gsr_pipewire_audio_port *input_fl_port = NULL; const gsr_pipewire_audio_port *input_fr_port = NULL; gsr_pipewire_get_node_input_port_by_type(self, stream_input_node, requested_link->input_type, &input_fl_port, &input_fr_port); if(!input_fl_port || !input_fr_port) return; gsr_pipewire_audio_desired_link desired_links[64]; for(size_t i = 0; i < self->num_stream_nodes; ++i) { const gsr_pipewire_audio_node *output_node = &self->stream_nodes[i]; if(output_node->type != requested_link->output_type) continue; const bool requested_link_matches_app = requested_link_matches_name_case_insensitive_any_type(self, requested_link, output_node->name); if(requested_link->inverted) { if(requested_link_matches_app) continue; } else { if(!requested_link_matches_app) continue; } const size_t num_desired_links = gsr_pipewire_get_node_output_ports(self, output_node, desired_links, 64, input_fl_port, input_fr_port); for(size_t j = 0; j < num_desired_links; ++j) { gsr_pipewire_audio_establish_link(self, desired_links[j].output_port, desired_links[j].input_port); } } } static void gsr_pipewire_audio_create_links(gsr_pipewire_audio *self) { for(size_t i = 0; i < self->num_requested_links; ++i) { gsr_pipewire_audio_create_link(self, &self->requested_links[i]); } } static void gsr_pipewire_audio_create_link_for_default_devices(gsr_pipewire_audio *self, const gsr_pipewire_audio_requested_link *requested_link, gsr_pipewire_audio_requested_type default_device_type) { if(default_device_type == GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD) return; const char *device_name = default_device_type == GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT ? self->default_output_device_name : self->default_input_device_name; if(device_name[0] == '\0') return; if(!requested_link_has_type(requested_link, default_device_type)) return; const gsr_pipewire_audio_node_type requested_link_node_type = requested_link->input_type == GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM ? GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_INPUT : GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE; const gsr_pipewire_audio_node *stream_input_node = gsr_pipewire_audio_get_node_by_name_case_insensitive(self, requested_link->input_name, requested_link_node_type); if(!stream_input_node) return; const gsr_pipewire_audio_port *input_fl_port = NULL; const gsr_pipewire_audio_port *input_fr_port = NULL; gsr_pipewire_get_node_input_port_by_type(self, stream_input_node, requested_link->input_type, &input_fl_port, &input_fr_port); if(!input_fl_port || !input_fr_port) return; const gsr_pipewire_audio_node *stream_output_node = gsr_pipewire_audio_get_node_by_name_case_insensitive(self, device_name, GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE); if(!stream_output_node) return; gsr_pipewire_audio_desired_link desired_links[64]; const size_t num_desired_links = gsr_pipewire_get_node_output_ports(self, stream_output_node, desired_links, 64, input_fl_port, input_fr_port); for(size_t i = 0; i < num_desired_links; ++i) { gsr_pipewire_audio_establish_link(self, desired_links[i].output_port, desired_links[i].input_port); } } static void gsr_pipewire_audio_create_links_for_default_devices(gsr_pipewire_audio *self, gsr_pipewire_audio_requested_type default_device_type) { for(size_t i = 0; i < self->num_requested_links; ++i) { gsr_pipewire_audio_create_link_for_default_devices(self, &self->requested_links[i], default_device_type); } } static void gsr_pipewire_audio_destroy_links_by_output_to_input(gsr_pipewire_audio *self, uint32_t output_node_id, uint32_t input_node_id) { for(size_t i = 0; i < self->num_links; ++i) { if(self->links[i].output_node_id == output_node_id && self->links[i].input_node_id == input_node_id) pw_registry_destroy(self->registry, self->links[i].id); } } static void gsr_pipewire_destroy_default_device_link(gsr_pipewire_audio *self, const gsr_pipewire_audio_requested_link *requested_link, gsr_pipewire_audio_requested_type default_device_type) { if(default_device_type == GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD) return; const char *device_name = default_device_type == GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT ? self->default_output_device_name : self->default_input_device_name; if(device_name[0] == '\0') return; if(!requested_link_has_type(requested_link, default_device_type)) return; /* default_output and default_input can be the same device. In that case both are the same link and we dont want to remove the link */ const gsr_pipewire_audio_requested_type opposite_device_type = default_device_type == GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT ? GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT : GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT; const char *opposite_device_name = opposite_device_type == GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT ? self->default_output_device_name : self->default_input_device_name; if(requested_link_has_type(requested_link, opposite_device_type) && strcmp(device_name, opposite_device_name) == 0) return; const gsr_pipewire_audio_node_type requested_link_node_type = requested_link->input_type == GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM ? GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_INPUT : GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE; const gsr_pipewire_audio_node *stream_input_node = gsr_pipewire_audio_get_node_by_name_case_insensitive(self, requested_link->input_name, requested_link_node_type); if(!stream_input_node) return; const gsr_pipewire_audio_node *stream_output_node = gsr_pipewire_audio_get_node_by_name_case_insensitive(self, device_name, GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE); if(!stream_output_node) return; if(requested_link_matches_name_case_insensitive(requested_link, stream_output_node->name)) return; gsr_pipewire_audio_destroy_links_by_output_to_input(self, stream_output_node->id, stream_input_node->id); //fprintf(stderr, "destroying a link from %u to %u\n", stream_output_node->id, stream_input_node->id); } static void gsr_pipewire_destroy_default_device_links(gsr_pipewire_audio *self, gsr_pipewire_audio_requested_type default_device_type) { for(size_t i = 0; i < self->num_requested_links; ++i) { gsr_pipewire_destroy_default_device_link(self, &self->requested_links[i], default_device_type); } } static bool json_get_value(const char *json_str, const char *key, char *value, size_t value_size) { char key_full[32]; const int key_full_size = snprintf(key_full, sizeof(key_full), "\"%s\":", key); const char *start = strstr(json_str, key_full); if(!start) return false; start += key_full_size; const char *value_start = strchr(start, '"'); if(!value_start) return false; value_start += 1; const char *value_end = strchr(value_start, '"'); if(!value_end) return false; snprintf(value, value_size, "%.*s", (int)(value_end - value_start), value_start); return true; } static int on_metadata_property_cb(void *data, uint32_t id, const char *key, const char *type, const char *value) { (void)type; gsr_pipewire_audio *self = data; if(id == PW_ID_CORE && key && value) { char value_decoded[128]; if(strcmp(key, "default.audio.sink") == 0) { if(json_get_value(value, "name", value_decoded, sizeof(value_decoded)) && strcmp(value_decoded, self->default_output_device_name) != 0) { gsr_pipewire_destroy_default_device_links(self, GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT); snprintf(self->default_output_device_name, sizeof(self->default_output_device_name), "%s", value_decoded); gsr_pipewire_audio_create_links_for_default_devices(self, GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT); } } else if(strcmp(key, "default.audio.source") == 0) { if(json_get_value(value, "name", value_decoded, sizeof(value_decoded)) && strcmp(value_decoded, self->default_input_device_name) != 0) { gsr_pipewire_destroy_default_device_links(self, GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT); snprintf(self->default_input_device_name, sizeof(self->default_input_device_name), "%s", value_decoded); gsr_pipewire_audio_create_links_for_default_devices(self, GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT); } } } return 0; } static const struct pw_metadata_events metadata_events = { PW_VERSION_METADATA_EVENTS, .property = on_metadata_property_cb, }; static void on_metadata_proxy_removed_cb(void *data) { gsr_pipewire_audio *self = data; if(self->metadata_proxy) { pw_proxy_destroy(self->metadata_proxy); self->metadata_proxy = NULL; } } static void on_metadata_proxy_destroy_cb(void *data) { gsr_pipewire_audio *self = data; spa_hook_remove(&self->metadata_listener); spa_hook_remove(&self->metadata_proxy_listener); spa_zero(self->metadata_listener); spa_zero(self->metadata_proxy_listener); self->metadata_proxy = NULL; } static const struct pw_proxy_events metadata_proxy_events = { PW_VERSION_PROXY_EVENTS, .removed = on_metadata_proxy_removed_cb, .destroy = on_metadata_proxy_destroy_cb, }; static bool gsr_pipewire_audio_listen_on_metadata(gsr_pipewire_audio *self, uint32_t id) { if(self->metadata_proxy) { pw_proxy_destroy(self->metadata_proxy); self->metadata_proxy = NULL; } self->metadata_proxy = pw_registry_bind(self->registry, id, PW_TYPE_INTERFACE_Metadata, PW_VERSION_METADATA, 0); if(!self->metadata_proxy) { fprintf(stderr, "gsr error: gsr_pipewire_audio_listen_on_metadata: failed to bind to registry\n"); return false; } pw_proxy_add_object_listener(self->metadata_proxy, &self->metadata_listener, &metadata_events, self); pw_proxy_add_listener(self->metadata_proxy, &self->metadata_proxy_listener, &metadata_proxy_events, self); self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync); return true; } static bool array_ensure_capacity(void **array, size_t size, size_t *capacity_items, size_t element_size) { if(size + 1 >= *capacity_items) { size_t new_capacity_items = *capacity_items * 2; if(new_capacity_items == 0) new_capacity_items = 32; void *new_data = realloc(*array, new_capacity_items * element_size); if(!new_data) { fprintf(stderr, "gsr error: pipewire_audio: failed to reallocate memory\n"); return false; } *array = new_data; *capacity_items = new_capacity_items; } return true; } static void registry_event_global(void *data, uint32_t id, uint32_t permissions, const char *type, uint32_t version, const struct spa_dict *props) { //fprintf(stderr, "add: id: %d, type: %s\n", (int)id, type); gsr_pipewire_audio *self = (gsr_pipewire_audio*)data; if(!props || !type || !self->running) return; //pw_properties_new_dict(props); if(strcmp(type, PW_TYPE_INTERFACE_Node) == 0) { const char *node_name = spa_dict_lookup(props, PW_KEY_NODE_NAME); const char *media_class = spa_dict_lookup(props, PW_KEY_MEDIA_CLASS); //fprintf(stderr, " node id: %u, node name: %s, media class: %s\n", id, node_name, media_class); const bool is_stream_output = media_class && strcmp(media_class, "Stream/Output/Audio") == 0; const bool is_stream_input = media_class && strcmp(media_class, "Stream/Input/Audio") == 0; const bool is_sink = media_class && string_starts_with(media_class, "Audio/Sink"); // Matches Audio/Sink/Virtual as well const bool is_source = media_class && string_starts_with(media_class, "Audio/Source"); // Matches Audio/Source/Virtual as well if(node_name && (is_stream_output || is_stream_input || is_sink || is_source)) { //const char *application_binary = spa_dict_lookup(props, PW_KEY_APP_PROCESS_BINARY); //const char *application_name = spa_dict_lookup(props, PW_KEY_APP_NAME); //fprintf(stderr, " node name: %s, app binary: %s, app name: %s\n", node_name, application_binary, application_name); if(!array_ensure_capacity((void**)&self->stream_nodes, self->num_stream_nodes, &self->stream_nodes_capacity_items, sizeof(gsr_pipewire_audio_node))) return; char *node_name_copy = strdup(node_name); if(node_name_copy) { self->stream_nodes[self->num_stream_nodes].id = id; self->stream_nodes[self->num_stream_nodes].name = node_name_copy; if(is_stream_output) self->stream_nodes[self->num_stream_nodes].type = GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT; else if(is_stream_input) self->stream_nodes[self->num_stream_nodes].type = GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_INPUT; else if(is_sink || is_source) self->stream_nodes[self->num_stream_nodes].type = GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE; ++self->num_stream_nodes; gsr_pipewire_audio_create_links(self); } } } else if(strcmp(type, PW_TYPE_INTERFACE_Port) == 0) { const char *port_name = spa_dict_lookup(props, PW_KEY_PORT_NAME); const char *port_direction = spa_dict_lookup(props, PW_KEY_PORT_DIRECTION); gsr_pipewire_audio_port_direction direction = -1; if(port_direction && strcmp(port_direction, "in") == 0) direction = GSR_PIPEWIRE_AUDIO_PORT_DIRECTION_INPUT; else if(port_direction && strcmp(port_direction, "out") == 0) direction = GSR_PIPEWIRE_AUDIO_PORT_DIRECTION_OUTPUT; const char *node_id = spa_dict_lookup(props, PW_KEY_NODE_ID); const int node_id_num = node_id ? atoi(node_id) : 0; if(port_name && direction >= 0 && node_id_num > 0) { if(!array_ensure_capacity((void**)&self->ports, self->num_ports, &self->ports_capacity_items, sizeof(gsr_pipewire_audio_port))) return; //fprintf(stderr, " port name: %s, node id: %d, direction: %s\n", port_name, node_id_num, port_direction); char *port_name_copy = strdup(port_name); if(port_name_copy) { //fprintf(stderr, " port id: %u, node id: %u, name: %s\n", id, node_id_num, port_name_copy); self->ports[self->num_ports].id = id; self->ports[self->num_ports].node_id = node_id_num; self->ports[self->num_ports].direction = direction; self->ports[self->num_ports].name = port_name_copy; ++self->num_ports; gsr_pipewire_audio_create_links(self); } } } else if(strcmp(type, PW_TYPE_INTERFACE_Link) == 0) { const char *output_node = spa_dict_lookup(props, PW_KEY_LINK_OUTPUT_NODE); const char *input_node = spa_dict_lookup(props, PW_KEY_LINK_INPUT_NODE); const uint32_t output_node_id_num = output_node ? atoi(output_node) : 0; const uint32_t input_node_id_num = input_node ? atoi(input_node) : 0; if(output_node_id_num > 0 && input_node_id_num > 0) { if(!array_ensure_capacity((void**)&self->links, self->num_links, &self->links_capacity_items, sizeof(gsr_pipewire_audio_link))) return; //fprintf(stderr, " new link (%u): %u -> %u\n", id, output_node_id_num, input_node_id_num); self->links[self->num_links].id = id; self->links[self->num_links].output_node_id = output_node_id_num; self->links[self->num_links].input_node_id = input_node_id_num; ++self->num_links; } } else if(strcmp(type, PW_TYPE_INTERFACE_Metadata) == 0) { const char *name = spa_dict_lookup(props, PW_KEY_METADATA_NAME); if(name && strcmp(name, "default") == 0) gsr_pipewire_audio_listen_on_metadata(self, id); } } static bool gsr_pipewire_audio_remove_node_by_id(gsr_pipewire_audio *self, uint32_t node_id) { for(size_t i = 0; i < self->num_stream_nodes; ++i) { if(self->stream_nodes[i].id != node_id) continue; free(self->stream_nodes[i].name); self->stream_nodes[i] = self->stream_nodes[self->num_stream_nodes - 1]; --self->num_stream_nodes; return true; } return false; } static bool gsr_pipewire_audio_remove_port_by_id(gsr_pipewire_audio *self, uint32_t port_id) { for(size_t i = 0; i < self->num_ports; ++i) { if(self->ports[i].id != port_id) continue; free(self->ports[i].name); self->ports[i] = self->ports[self->num_ports - 1]; --self->num_ports; return true; } return false; } static bool gsr_pipewire_audio_remove_link_by_id(gsr_pipewire_audio *self, uint32_t link_id) { for(size_t i = 0; i < self->num_links; ++i) { if(self->links[i].id != link_id) continue; self->links[i] = self->links[self->num_links - 1]; --self->num_links; return true; } return false; } static void registry_event_global_remove(void *data, uint32_t id) { //fprintf(stderr, "remove: %d\n", (int)id); gsr_pipewire_audio *self = (gsr_pipewire_audio*)data; if(gsr_pipewire_audio_remove_node_by_id(self, id)) { //fprintf(stderr, "removed node\n"); return; } if(gsr_pipewire_audio_remove_port_by_id(self, id)) { //fprintf(stderr, "removed port\n"); return; } if(gsr_pipewire_audio_remove_link_by_id(self, id)) { //fprintf(stderr, "removed link\n"); return; } } static const struct pw_registry_events registry_events = { PW_VERSION_REGISTRY_EVENTS, .global = registry_event_global, .global_remove = registry_event_global_remove, }; bool gsr_pipewire_audio_init(gsr_pipewire_audio *self) { memset(self, 0, sizeof(*self)); self->running = true; pw_init(NULL, NULL); self->thread_loop = pw_thread_loop_new("gsr screen capture", NULL); if(!self->thread_loop) { fprintf(stderr, "gsr error: gsr_pipewire_audio_init: failed to create pipewire thread\n"); gsr_pipewire_audio_deinit(self); return false; } self->context = pw_context_new(pw_thread_loop_get_loop(self->thread_loop), NULL, 0); if(!self->context) { fprintf(stderr, "gsr error: gsr_pipewire_audio_init: failed to create pipewire context\n"); gsr_pipewire_audio_deinit(self); return false; } pw_context_load_module(self->context, "libpipewire-module-link-factory", NULL, NULL); if(pw_thread_loop_start(self->thread_loop) < 0) { fprintf(stderr, "gsr error: gsr_pipewire_audio_init: failed to start thread\n"); gsr_pipewire_audio_deinit(self); return false; } pw_thread_loop_lock(self->thread_loop); self->core = pw_context_connect(self->context, pw_properties_new(PW_KEY_REMOTE_NAME, NULL, NULL), 0); if(!self->core) { pw_thread_loop_unlock(self->thread_loop); gsr_pipewire_audio_deinit(self); return false; } // TODO: Error check pw_core_add_listener(self->core, &self->core_listener, &core_events, self); self->registry = pw_core_get_registry(self->core, PW_VERSION_REGISTRY, 0); pw_registry_add_listener(self->registry, &self->registry_listener, ®istry_events, self); self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync); pw_thread_loop_wait(self->thread_loop); pw_thread_loop_unlock(self->thread_loop); return true; } static gsr_pipewire_audio_link* gsr_pipewire_audio_get_first_link_to_node(gsr_pipewire_audio *self, uint32_t node_id) { for(size_t i = 0; i < self->num_links; ++i) { if(self->links[i].input_node_id == node_id) return &self->links[i]; } return NULL; } static void gsr_pipewire_audio_destroy_requested_links(gsr_pipewire_audio *self) { pw_thread_loop_lock(self->thread_loop); self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync); pw_thread_loop_wait(self->thread_loop); for(size_t requested_link_index = 0; requested_link_index < self->num_requested_links; ++requested_link_index) { const gsr_pipewire_audio_node_type requested_link_node_type = self->requested_links[requested_link_index].input_type == GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM ? GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_INPUT : GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE; const gsr_pipewire_audio_node *stream_input_node = gsr_pipewire_audio_get_node_by_name_case_insensitive(self, self->requested_links[requested_link_index].input_name, requested_link_node_type); if(!stream_input_node) continue; for(;;) { gsr_pipewire_audio_link *link = gsr_pipewire_audio_get_first_link_to_node(self, stream_input_node->id); if(!link) break; pw_registry_destroy(self->registry, link->id); self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, self->server_version_sync); pw_thread_loop_wait(self->thread_loop); usleep(10 * 1000); } } pw_thread_loop_unlock(self->thread_loop); } void gsr_pipewire_audio_deinit(gsr_pipewire_audio *self) { self->running = false; if(self->thread_loop) { /* We need to manually destroy links first, otherwise the linked audio sources will be paused when closing the program */ gsr_pipewire_audio_destroy_requested_links(self); //pw_thread_loop_wait(self->thread_loop); pw_thread_loop_stop(self->thread_loop); } if(self->metadata_proxy) { spa_hook_remove(&self->metadata_listener); spa_hook_remove(&self->metadata_proxy_listener); pw_proxy_destroy(self->metadata_proxy); spa_zero(self->metadata_listener); spa_zero(self->metadata_proxy_listener); self->metadata_proxy = NULL; } spa_hook_remove(&self->registry_listener); spa_hook_remove(&self->core_listener); if(self->core) { pw_core_disconnect(self->core); self->core = NULL; } if(self->context) { pw_context_destroy(self->context); self->context = NULL; } if(self->thread_loop) { pw_thread_loop_destroy(self->thread_loop); self->thread_loop = NULL; } if(self->stream_nodes) { for(size_t i = 0; i < self->num_stream_nodes; ++i) { free(self->stream_nodes[i].name); } self->num_stream_nodes = 0; self->stream_nodes_capacity_items = 0; free(self->stream_nodes); self->stream_nodes = NULL; } if(self->ports) { for(size_t i = 0; i < self->num_ports; ++i) { free(self->ports[i].name); } self->num_ports = 0; self->ports_capacity_items = 0; free(self->ports); self->ports = NULL; } if(self->links) { self->num_links = 0; self->links_capacity_items = 0; free(self->links); self->links = NULL; } if(self->requested_links) { for(size_t i = 0; i < self->num_requested_links; ++i) { for(int j = 0; j < self->requested_links[i].num_outputs; ++j) { free(self->requested_links[i].outputs[j].name); } free(self->requested_links[i].outputs); free(self->requested_links[i].input_name); } self->num_requested_links = 0; self->requested_links_capacity_items = 0; free(self->requested_links); self->requested_links = NULL; } #if PW_CHECK_VERSION(0, 3, 49) pw_deinit(); #endif } static bool string_remove_suffix(char *str, const char *suffix) { int str_len = strlen(str); int suffix_len = strlen(suffix); if(str_len >= suffix_len && memcmp(str + str_len - suffix_len, suffix, suffix_len) == 0) { str[str_len - suffix_len] = '\0'; return true; } else { return false; } } static bool gsr_pipewire_audio_add_links_to_output(gsr_pipewire_audio *self, const char **output_names, int num_output_names, const char *input_name, gsr_pipewire_audio_node_type output_type, gsr_pipewire_audio_link_input_type input_type, bool inverted) { if(!array_ensure_capacity((void**)&self->requested_links, self->num_requested_links, &self->requested_links_capacity_items, sizeof(gsr_pipewire_audio_requested_link))) return false; gsr_pipewire_audio_requested_output *outputs = calloc(num_output_names, sizeof(gsr_pipewire_audio_requested_output)); if(!outputs) return false; char *input_name_copy = strdup(input_name); if(!input_name_copy) goto error; if(input_type == GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK) string_remove_suffix(input_name_copy, ".monitor"); for(int i = 0; i < num_output_names; ++i) { outputs[i].name = strdup(output_names[i]); if(!outputs[i].name) goto error; outputs[i].type = GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD; if(output_type == GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE) { string_remove_suffix(outputs[i].name, ".monitor"); if(strcmp(outputs[i].name, "default_output") == 0) outputs[i].type = GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT; else if(strcmp(outputs[i].name, "default_input") == 0) outputs[i].type = GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT; else outputs[i].type = GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_STANDARD; } } pw_thread_loop_lock(self->thread_loop); self->requested_links[self->num_requested_links].outputs = outputs; self->requested_links[self->num_requested_links].num_outputs = num_output_names; self->requested_links[self->num_requested_links].input_name = input_name_copy; self->requested_links[self->num_requested_links].output_type = output_type; self->requested_links[self->num_requested_links].input_type = input_type; self->requested_links[self->num_requested_links].inverted = inverted; ++self->num_requested_links; gsr_pipewire_audio_create_link(self, &self->requested_links[self->num_requested_links - 1]); // TODO: Remove these? gsr_pipewire_audio_create_link_for_default_devices(self, &self->requested_links[self->num_requested_links - 1], GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_OUTPUT); gsr_pipewire_audio_create_link_for_default_devices(self, &self->requested_links[self->num_requested_links - 1], GSR_PIPEWIRE_AUDIO_REQUESTED_TYPE_DEFAULT_INPUT); pw_thread_loop_unlock(self->thread_loop); return true; error: free(input_name_copy); for(int i = 0; i < num_output_names; ++i) { free(outputs[i].name); } free(outputs); return false; } bool gsr_pipewire_audio_add_link_from_apps_to_stream(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *stream_name_input) { return gsr_pipewire_audio_add_links_to_output(self, app_names, num_app_names, stream_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM, false); } bool gsr_pipewire_audio_add_link_from_apps_to_stream_inverted(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *stream_name_input) { return gsr_pipewire_audio_add_links_to_output(self, app_names, num_app_names, stream_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM, true); } bool gsr_pipewire_audio_add_link_from_apps_to_sink(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *sink_name_input) { return gsr_pipewire_audio_add_links_to_output(self, app_names, num_app_names, sink_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK, false); } bool gsr_pipewire_audio_add_link_from_apps_to_sink_inverted(gsr_pipewire_audio *self, const char **app_names, int num_app_names, const char *sink_name_input) { return gsr_pipewire_audio_add_links_to_output(self, app_names, num_app_names, sink_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK, true); } bool gsr_pipewire_audio_add_link_from_sources_to_stream(gsr_pipewire_audio *self, const char **source_names, int num_source_names, const char *stream_name_input) { return gsr_pipewire_audio_add_links_to_output(self, source_names, num_source_names, stream_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_STREAM, false); } bool gsr_pipewire_audio_add_link_from_sources_to_sink(gsr_pipewire_audio *self, const char **source_names, int num_source_names, const char *sink_name_input) { return gsr_pipewire_audio_add_links_to_output(self, source_names, num_source_names, sink_name_input, GSR_PIPEWIRE_AUDIO_NODE_TYPE_SINK_OR_SOURCE, GSR_PIPEWIRE_AUDIO_LINK_INPUT_TYPE_SINK, false); } void gsr_pipewire_audio_for_each_app(gsr_pipewire_audio *self, gsr_pipewire_audio_app_query_callback callback, void *userdata) { pw_thread_loop_lock(self->thread_loop); for(int i = 0; i < (int)self->num_stream_nodes; ++i) { const gsr_pipewire_audio_node *node = &self->stream_nodes[i]; if(node->type != GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT) continue; bool duplicate_app = false; for(int j = i - 1; j >= 0; --j) { const gsr_pipewire_audio_node *prev_node = &self->stream_nodes[j]; if(prev_node->type != GSR_PIPEWIRE_AUDIO_NODE_TYPE_STREAM_OUTPUT) continue; if(strcasecmp(node->name, prev_node->name) == 0) { duplicate_app = true; break; } } if(duplicate_app) continue; if(!callback(node->name, userdata)) break; } pw_thread_loop_unlock(self->thread_loop); } fsdsfdsfdsfdsf-5.13.8/src/pipewire_video.c000066400000000000000000001132061520215207700205550ustar00rootroot00000000000000#include "../include/pipewire_video.h" #include "../include/egl.h" #include "../include/utils.h" #include #include #include #include #include #include /* This code is partially based on xr-video-player pipewire implementation which is based on obs-studio's pipewire implementation */ /* TODO: Make gsr_pipewire_video_init asynchronous */ /* TODO: Support hdr when pipewire supports it */ /* TODO: Test all of the image formats */ #ifndef SPA_POD_PROP_FLAG_DONT_FIXATE #define SPA_POD_PROP_FLAG_DONT_FIXATE (1 << 4) #endif #if !PW_CHECK_VERSION(0, 3, 62) enum spa_meta_videotransform_value { SPA_META_TRANSFORMATION_None = 0, /**< no transform */ SPA_META_TRANSFORMATION_90, /**< 90 degree counter-clockwise */ SPA_META_TRANSFORMATION_180, /**< 180 degree counter-clockwise */ SPA_META_TRANSFORMATION_270, /**< 270 degree counter-clockwise */ SPA_META_TRANSFORMATION_Flipped, /**< 180 degree flipped around the vertical axis. Equivalent * to a reflexion through the vertical line splitting the * buffer in two equal sized parts */ SPA_META_TRANSFORMATION_Flipped90, /**< flip then rotate around 90 degree counter-clockwise */ SPA_META_TRANSFORMATION_Flipped180, /**< flip then rotate around 180 degree counter-clockwise */ SPA_META_TRANSFORMATION_Flipped270, /**< flip then rotate around 270 degree counter-clockwise */ }; /** a transformation of the buffer */ struct spa_meta_videotransform { uint32_t transform; /**< orientation transformation that was applied to the buffer, * one of enum spa_meta_videotransform_value */ }; #define SPA_META_VideoTransform 8 #endif #define CURSOR_META_SIZE(width, height) \ (sizeof(struct spa_meta_cursor) + sizeof(struct spa_meta_bitmap) + \ width * height * 4) static bool parse_pw_version(gsr_pipewire_video_data_version *dst, const char *version) { const int n_matches = sscanf(version, "%d.%d.%d", &dst->major, &dst->minor, &dst->micro); return n_matches == 3; } static bool check_pw_version(const gsr_pipewire_video_data_version *pw_version, int major, int minor, int micro) { if (pw_version->major != major) return pw_version->major > major; if (pw_version->minor != minor) return pw_version->minor > minor; return pw_version->micro >= micro; } static void update_pw_versions(gsr_pipewire_video *self, const char *version) { fprintf(stderr, "gsr info: pipewire: server version: %s\n", version); fprintf(stderr, "gsr info: pipewire: library version: %s\n", pw_get_library_version()); fprintf(stderr, "gsr info: pipewire: header version: %s\n", pw_get_headers_version()); if(!parse_pw_version(&self->server_version, version)) fprintf(stderr, "gsr error: pipewire: failed to parse server version\n"); } static void on_core_info_cb(void *user_data, const struct pw_core_info *info) { gsr_pipewire_video *self = user_data; update_pw_versions(self, info->version); } static void on_core_error_cb(void *user_data, uint32_t id, int seq, int res, const char *message) { gsr_pipewire_video *self = user_data; fprintf(stderr, "gsr error: pipewire: error id:%u seq:%d res:%d: %s\n", id, seq, res, message); pw_thread_loop_signal(self->thread_loop, false); } static void on_core_done_cb(void *user_data, uint32_t id, int seq) { gsr_pipewire_video *self = user_data; if (id == PW_ID_CORE && self->server_version_sync == seq) pw_thread_loop_signal(self->thread_loop, false); } static bool is_cursor_format_supported(const enum spa_video_format format) { switch(format) { case SPA_VIDEO_FORMAT_RGBx: return true; case SPA_VIDEO_FORMAT_BGRx: return true; case SPA_VIDEO_FORMAT_RGBA: return true; case SPA_VIDEO_FORMAT_BGRA: return true; case SPA_VIDEO_FORMAT_RGB: return true; case SPA_VIDEO_FORMAT_BGR: return true; case SPA_VIDEO_FORMAT_ARGB: return true; case SPA_VIDEO_FORMAT_ABGR: return true; #if PW_CHECK_VERSION(0, 3, 41) case SPA_VIDEO_FORMAT_xRGB_210LE: return true; case SPA_VIDEO_FORMAT_xBGR_210LE: return true; case SPA_VIDEO_FORMAT_ARGB_210LE: return true; case SPA_VIDEO_FORMAT_ABGR_210LE: return true; #endif default: break; } return false; } static const struct pw_core_events core_events = { PW_VERSION_CORE_EVENTS, .info = on_core_info_cb, .done = on_core_done_cb, .error = on_core_error_cb, }; static void on_process_cb(void *user_data) { gsr_pipewire_video *self = user_data; /* Find the most recent buffer */ struct pw_buffer *pw_buf = NULL; for(;;) { struct pw_buffer *aux = pw_stream_dequeue_buffer(self->stream); if(!aux) break; if(pw_buf) pw_stream_queue_buffer(self->stream, pw_buf); pw_buf = aux; } if(!pw_buf) { fprintf(stderr, "gsr info: pipewire: out of buffers!\n"); return; } struct spa_buffer *buffer = pw_buf->buffer; const bool has_buffer = buffer->n_datas > 0 && buffer->datas[0].chunk->size != 0; pthread_mutex_lock(&self->mutex); bool buffer_updated = false; if(has_buffer && buffer->datas[0].type == SPA_DATA_DmaBuf) { for(size_t i = 0; i < self->dmabuf_num_planes; ++i) { if(self->dmabuf_data[i].fd > 0) { close(self->dmabuf_data[i].fd); self->dmabuf_data[i].fd = -1; } } self->dmabuf_num_planes = buffer->n_datas; if(self->dmabuf_num_planes > GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES) self->dmabuf_num_planes = GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES; for(size_t i = 0; i < self->dmabuf_num_planes; ++i) { self->dmabuf_data[i].fd = dup(buffer->datas[i].fd); self->dmabuf_data[i].offset = buffer->datas[i].chunk->offset; self->dmabuf_data[i].stride = buffer->datas[i].chunk->stride; } buffer_updated = true; } // TODO: Move down to read_metadata struct spa_meta_region *region = spa_buffer_find_meta_data(buffer, SPA_META_VideoCrop, sizeof(*region)); if(region && spa_meta_region_is_valid(region)) { // fprintf(stderr, "gsr info: pipewire: crop Region available (%dx%d+%d+%d)\n", // region->region.position.x, region->region.position.y, // region->region.size.width, region->region.size.height); self->crop.x = region->region.position.x; self->crop.y = region->region.position.y; self->crop.width = region->region.size.width; self->crop.height = region->region.size.height; self->crop.valid = true; } else { self->crop.valid = false; } struct spa_meta_videotransform *video_transform = spa_buffer_find_meta_data(buffer, SPA_META_VideoTransform, sizeof(*video_transform)); enum spa_meta_videotransform_value transform = SPA_META_TRANSFORMATION_None; if(video_transform) transform = video_transform->transform; self->rotation = GSR_MONITOR_ROT_0; switch(transform) { case SPA_META_TRANSFORMATION_90: self->rotation = GSR_MONITOR_ROT_90; break; case SPA_META_TRANSFORMATION_180: self->rotation = GSR_MONITOR_ROT_180; break; case SPA_META_TRANSFORMATION_270: self->rotation = GSR_MONITOR_ROT_270; break; default: // TODO: Support other rotations. Wayland compositors dont use them yet so it's ok to not support it now break; } const struct spa_meta *video_damage = spa_buffer_find_meta(buffer, SPA_META_VideoDamage); if(video_damage) { struct spa_meta_region *meta_region = NULL; spa_meta_for_each(meta_region, video_damage) { if(meta_region->region.size.width == 0 || meta_region->region.size.height == 0) continue; self->damaged = true; break; } } else if(buffer_updated) { self->damaged = true; } const struct spa_meta_cursor *cursor = spa_buffer_find_meta_data(buffer, SPA_META_Cursor, sizeof(*cursor)); self->cursor.valid = cursor && spa_meta_cursor_is_valid(cursor); if (self->cursor.visible && self->cursor.valid) { struct spa_meta_bitmap *bitmap = NULL; if (cursor->bitmap_offset) bitmap = SPA_MEMBER(cursor, cursor->bitmap_offset, struct spa_meta_bitmap); // TODO: Maybe check if the cursor is actually visible by checking if there are visible pixels if (bitmap && bitmap->size.width > 0 && bitmap->size.height > 0 && is_cursor_format_supported(bitmap->format)) { const uint8_t *bitmap_data = SPA_MEMBER(bitmap, bitmap->offset, uint8_t); fprintf(stderr, "gsr info: pipewire: cursor bitmap update, size: %dx%d, format: %s\n", (int)bitmap->size.width, (int)bitmap->size.height, spa_debug_type_find_name(spa_type_video_format, bitmap->format)); const size_t bitmap_size = bitmap->size.width * bitmap->size.height * 4; uint8_t *new_bitmap_data = realloc(self->cursor.data, bitmap_size); if(new_bitmap_data) { self->cursor.data = new_bitmap_data; /* TODO: Convert bgr and other image formats to rgb here */ memcpy(self->cursor.data, bitmap_data, bitmap_size); } self->cursor.hotspot_x = cursor->hotspot.x; self->cursor.hotspot_y = cursor->hotspot.y; self->cursor.width = bitmap->size.width; self->cursor.height = bitmap->size.height; self->damaged = true; } if(cursor->position.x != self->cursor.x || cursor->position.y != self->cursor.y) self->damaged = true; self->cursor.x = cursor->position.x; self->cursor.y = cursor->position.y; //fprintf(stderr, "gsr info: pipewire: cursor: %d %d %d %d\n", cursor->hotspot.x, cursor->hotspot.y, cursor->position.x, cursor->position.y); } pthread_mutex_unlock(&self->mutex); pw_stream_queue_buffer(self->stream, pw_buf); } static void on_param_changed_cb(void *user_data, uint32_t id, const struct spa_pod *param) { gsr_pipewire_video *self = user_data; if (!param || id != SPA_PARAM_Format) return; int result = spa_format_parse(param, &self->format.media_type, &self->format.media_subtype); if (result < 0) return; if (self->format.media_type != SPA_MEDIA_TYPE_video || self->format.media_subtype != SPA_MEDIA_SUBTYPE_raw) return; pthread_mutex_lock(&self->mutex); spa_format_video_raw_parse(param, &self->format.info.raw); pthread_mutex_unlock(&self->mutex); uint32_t buffer_types = 0; const bool has_modifier = spa_pod_find_prop(param, NULL, SPA_FORMAT_VIDEO_modifier) != NULL; if(has_modifier || check_pw_version(&self->server_version, 0, 3, 24)) buffer_types |= 1 << SPA_DATA_DmaBuf; fprintf(stderr, "gsr info: pipewire: negotiated format:\n"); fprintf(stderr, "gsr info: pipewire: Format: %d (%s)\n", self->format.info.raw.format, spa_debug_type_find_name(spa_type_video_format, self->format.info.raw.format)); self->has_modifier = has_modifier; if(self->has_modifier) { fprintf(stderr, "gsr info: pipewire: Modifier: 0x%" PRIx64 "\n", self->format.info.raw.modifier); } fprintf(stderr, "gsr info: pipewire: Size: %dx%d\n", self->format.info.raw.size.width, self->format.info.raw.size.height); fprintf(stderr, "gsr info: pipewire: Framerate: %d/%d\n", self->format.info.raw.framerate.num, self->format.info.raw.framerate.denom); uint8_t params_buffer[2048]; struct spa_pod_builder pod_builder = SPA_POD_BUILDER_INIT(params_buffer, sizeof(params_buffer)); const struct spa_pod *params[5]; int param_index = 0; params[param_index++] = spa_pod_builder_add_object( &pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoCrop), SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_region))); params[param_index++] = spa_pod_builder_add_object( &pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoDamage), SPA_PARAM_META_size, SPA_POD_CHOICE_RANGE_Int( sizeof(struct spa_meta_region) * 16, sizeof(struct spa_meta_region) * 1, sizeof(struct spa_meta_region) * 16)); params[param_index++] = spa_pod_builder_add_object( &pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Cursor), SPA_PARAM_META_size, SPA_POD_CHOICE_RANGE_Int(CURSOR_META_SIZE(64, 64), CURSOR_META_SIZE(1, 1), CURSOR_META_SIZE(1024, 1024))); params[param_index++] = spa_pod_builder_add_object( &pod_builder, SPA_TYPE_OBJECT_ParamBuffers, SPA_PARAM_Buffers, SPA_PARAM_BUFFERS_dataType, SPA_POD_Int(buffer_types)); #if PW_CHECK_VERSION(0, 3, 62) if (check_pw_version(&self->server_version, 0, 3, 62)) { /* Video transformation */ params[param_index++] = spa_pod_builder_add_object(&pod_builder, SPA_TYPE_OBJECT_ParamMeta, SPA_PARAM_Meta, SPA_PARAM_META_type, SPA_POD_Id(SPA_META_VideoTransform), SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_videotransform))); } #endif pw_stream_update_params(self->stream, params, param_index); self->negotiated = true; } static void on_state_changed_cb(void *user_data, enum pw_stream_state prev_state, enum pw_stream_state new_state, const char *error) { gsr_pipewire_video *self = user_data; fprintf(stderr, "gsr info: pipewire: stream %p previous state: \"%s\", new state: \"%s\" (error: %s)\n", (void*)self->stream, pw_stream_state_as_string(prev_state), pw_stream_state_as_string(new_state), error ? error : "none"); pthread_mutex_lock(&self->mutex); if(new_state == PW_STREAM_STATE_PAUSED) { self->paused_start_secs = clock_get_monotonic_seconds(); self->paused = true; } else { self->paused = false; } self->streaming = (new_state == PW_STREAM_STATE_STREAMING); pthread_mutex_unlock(&self->mutex); } static const struct pw_stream_events stream_events = { PW_VERSION_STREAM_EVENTS, .state_changed = on_state_changed_cb, .param_changed = on_param_changed_cb, .process = on_process_cb, }; static inline struct spa_pod *build_format(struct spa_pod_builder *b, const gsr_pipewire_video_video_info *ovi, uint32_t format, const uint64_t *modifiers, size_t modifier_count) { struct spa_pod_frame format_frame; spa_pod_builder_push_object(b, &format_frame, SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat); spa_pod_builder_add(b, SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_video), 0); spa_pod_builder_add(b, SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw), 0); spa_pod_builder_add(b, SPA_FORMAT_VIDEO_format, SPA_POD_Id(format), 0); if (modifier_count > 0) { struct spa_pod_frame modifier_frame; spa_pod_builder_prop(b, SPA_FORMAT_VIDEO_modifier, SPA_POD_PROP_FLAG_MANDATORY | SPA_POD_PROP_FLAG_DONT_FIXATE); spa_pod_builder_push_choice(b, &modifier_frame, SPA_CHOICE_Enum, 0); /* The first element of choice pods is the preferred value. Here * we arbitrarily pick the first modifier as the preferred one. */ // TODO: spa_pod_builder_long(b, modifiers[0]); for(uint32_t i = 0; i < modifier_count; i++) spa_pod_builder_long(b, modifiers[i]); spa_pod_builder_pop(b, &modifier_frame); } spa_pod_builder_add(b, SPA_FORMAT_VIDEO_size, SPA_POD_CHOICE_RANGE_Rectangle( &SPA_RECTANGLE(32, 32), &SPA_RECTANGLE(1, 1), &SPA_RECTANGLE(16384, 16384)), SPA_FORMAT_VIDEO_framerate, SPA_POD_CHOICE_RANGE_Fraction( &SPA_FRACTION(ovi->fps_num, ovi->fps_den), &SPA_FRACTION(0, 1), &SPA_FRACTION(500, 1)), 0); return spa_pod_builder_pop(b, &format_frame); } /* https://gstreamer.freedesktop.org/documentation/additional/design/mediatype-video-raw.html?gi-language=c#formats */ /* For some reason gstreamer formats are in opposite order to drm formats */ static int64_t spa_video_format_to_drm_format(const enum spa_video_format format) { switch(format) { case SPA_VIDEO_FORMAT_RGBx: return DRM_FORMAT_XBGR8888; case SPA_VIDEO_FORMAT_BGRx: return DRM_FORMAT_XRGB8888; case SPA_VIDEO_FORMAT_RGBA: return DRM_FORMAT_ABGR8888; case SPA_VIDEO_FORMAT_BGRA: return DRM_FORMAT_ARGB8888; case SPA_VIDEO_FORMAT_RGB: return DRM_FORMAT_XBGR8888; case SPA_VIDEO_FORMAT_BGR: return DRM_FORMAT_XRGB8888; //case SPA_VIDEO_FORMAT_ARGB: return DRM_FORMAT_BGRA8888; //case SPA_VIDEO_FORMAT_ABGR: return DRM_FORMAT_RGBA8888; #if PW_CHECK_VERSION(0, 3, 41) case SPA_VIDEO_FORMAT_xRGB_210LE: return DRM_FORMAT_XRGB2101010; case SPA_VIDEO_FORMAT_xBGR_210LE: return DRM_FORMAT_XBGR2101010; case SPA_VIDEO_FORMAT_ARGB_210LE: return DRM_FORMAT_ARGB2101010; case SPA_VIDEO_FORMAT_ABGR_210LE: return DRM_FORMAT_ABGR2101010; #endif default: break; } return DRM_FORMAT_INVALID; } #if PW_CHECK_VERSION(0, 3, 41) #define GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS #else #define GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS 6 #endif static const enum spa_video_format video_formats[GSR_PIPEWIRE_VIDEO_MAX_VIDEO_FORMATS] = { SPA_VIDEO_FORMAT_BGRx, SPA_VIDEO_FORMAT_BGR, SPA_VIDEO_FORMAT_RGBx, SPA_VIDEO_FORMAT_RGB, SPA_VIDEO_FORMAT_RGBA, SPA_VIDEO_FORMAT_BGRA, //SPA_VIDEO_FORMAT_ARGB, //SPA_VIDEO_FORMAT_ABGR, #if PW_CHECK_VERSION(0, 3, 41) SPA_VIDEO_FORMAT_xRGB_210LE, SPA_VIDEO_FORMAT_xBGR_210LE, SPA_VIDEO_FORMAT_ARGB_210LE, SPA_VIDEO_FORMAT_ABGR_210LE, #endif }; static bool gsr_pipewire_video_build_format_params(gsr_pipewire_video *self, struct spa_pod_builder *pod_builder, struct spa_pod **params, uint32_t *num_params) { *num_params = 0; if(!check_pw_version(&self->server_version, 0, 3, 33)) return false; for(size_t i = 0; i < GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS; i++) { if(self->supported_video_formats[i].modifiers_size == 0) continue; params[*num_params] = build_format(pod_builder, &self->video_info, self->supported_video_formats[i].format, self->modifiers + self->supported_video_formats[i].modifiers_index, self->supported_video_formats[i].modifiers_size); ++(*num_params); } return true; } static void renegotiate_format(void *data, uint64_t expirations) { (void)expirations; gsr_pipewire_video *self = (gsr_pipewire_video*)data; pw_thread_loop_lock(self->thread_loop); struct spa_pod *params[GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS]; uint32_t num_video_formats = 0; uint8_t params_buffer[4096]; struct spa_pod_builder pod_builder = SPA_POD_BUILDER_INIT(params_buffer, sizeof(params_buffer)); if (!gsr_pipewire_video_build_format_params(self, &pod_builder, params, &num_video_formats)) { fprintf(stderr, "gsr error: renegotiate_format: failed to build formats\n"); pw_thread_loop_unlock(self->thread_loop); return; } pw_stream_update_params(self->stream, (const struct spa_pod**)params, num_video_formats); pw_thread_loop_unlock(self->thread_loop); } static bool spa_video_format_get_modifiers(gsr_pipewire_video *self, const enum spa_video_format format, uint64_t *modifiers, int32_t max_modifiers, int32_t *num_modifiers) { *num_modifiers = 0; if(max_modifiers == 0) { fprintf(stderr, "gsr error: spa_video_format_get_modifiers: no space for modifiers left\n"); //modifiers[0] = DRM_FORMAT_MOD_LINEAR; //modifiers[1] = DRM_FORMAT_MOD_INVALID; //*num_modifiers = 2; return false; } if(!self->egl->eglQueryDmaBufModifiersEXT) { fprintf(stderr, "gsr error: spa_video_format_get_modifiers: failed to initialize modifiers because eglQueryDmaBufModifiersEXT is not available\n"); //modifiers[0] = DRM_FORMAT_MOD_LINEAR; //modifiers[1] = DRM_FORMAT_MOD_INVALID; //*num_modifiers = 2; modifiers[0] = DRM_FORMAT_MOD_INVALID; *num_modifiers = 1; return false; } const int64_t drm_format = spa_video_format_to_drm_format(format); if(drm_format == DRM_FORMAT_INVALID) { fprintf(stderr, "gsr error: spa_video_format_get_modifiers: unsupported format: %d\n", (int)format); return false; } if(!self->egl->eglQueryDmaBufModifiersEXT(self->egl->egl_display, drm_format, max_modifiers, modifiers, NULL, num_modifiers)) { fprintf(stderr, "gsr error: spa_video_format_get_modifiers: eglQueryDmaBufModifiersEXT failed with drm format %d, %" PRIi64 "\n", (int)format, drm_format); //modifiers[0] = DRM_FORMAT_MOD_LINEAR; //modifiers[1] = DRM_FORMAT_MOD_INVALID; //*num_modifiers = 2; modifiers[0] = DRM_FORMAT_MOD_INVALID; *num_modifiers = 1; return false; } // if(*num_modifiers + 2 <= max_modifiers) { // modifiers[*num_modifiers + 0] = DRM_FORMAT_MOD_LINEAR; // modifiers[*num_modifiers + 1] = DRM_FORMAT_MOD_INVALID; // *num_modifiers += 2; // } return true; } static void gsr_pipewire_video_init_modifiers(gsr_pipewire_video *self) { for(size_t i = 0; i < GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS; i++) { self->supported_video_formats[i].format = video_formats[i]; int32_t num_modifiers_video_format = 0; spa_video_format_get_modifiers(self, self->supported_video_formats[i].format, self->modifiers + self->num_modifiers, GSR_PIPEWIRE_VIDEO_MAX_MODIFIERS - self->num_modifiers, &num_modifiers_video_format); self->supported_video_formats[i].modifiers_index = self->num_modifiers; self->supported_video_formats[i].modifiers_size = num_modifiers_video_format; self->num_modifiers += num_modifiers_video_format; } } /* Returns the number of modifiers */ static size_t gsr_pipewire_video_format_remove_modifier(gsr_pipewire_video *self, gsr_video_format *video_format, uint64_t modifier) { for(size_t i = 0; i < video_format->modifiers_size; ++i) { if(self->modifiers[video_format->modifiers_index + i] == modifier) { for(size_t j = i + 1; j < video_format->modifiers_size; ++j) { self->modifiers[video_format->modifiers_index + j - 1] = self->modifiers[video_format->modifiers_index + j]; } --video_format->modifiers_size; break; } } return video_format->modifiers_size; } static void gsr_pipewire_video_remove_modifier(gsr_pipewire_video *self, uint64_t modifier) { self->num_modifiers = 0; for(size_t i = 0; i < GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS; i++) { gsr_video_format *video_format = &self->supported_video_formats[i]; const size_t num_modifiers_video_format = gsr_pipewire_video_format_remove_modifier(self, video_format, modifier); video_format->modifiers_index = self->num_modifiers; self->num_modifiers += num_modifiers_video_format; } } static bool gsr_pipewire_video_setup_stream(gsr_pipewire_video *self) { struct spa_pod *params[GSR_PIPEWIRE_VIDEO_NUM_VIDEO_FORMATS]; uint32_t num_video_formats = 0; uint8_t params_buffer[4096]; struct spa_pod_builder pod_builder = SPA_POD_BUILDER_INIT(params_buffer, sizeof(params_buffer)); self->thread_loop = pw_thread_loop_new("gsr screen capture", NULL); if(!self->thread_loop) { fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: failed to create pipewire thread\n"); goto error; } self->context = pw_context_new(pw_thread_loop_get_loop(self->thread_loop), NULL, 0); if(!self->context) { fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: failed to create pipewire context\n"); goto error; } if(pw_thread_loop_start(self->thread_loop) < 0) { fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: failed to start thread\n"); goto error; } pw_thread_loop_lock(self->thread_loop); // TODO: Why pass 5 to fcntl? self->core = pw_context_connect_fd(self->context, fcntl(self->fd, F_DUPFD_CLOEXEC, 5), NULL, 0); if(!self->core) { pw_thread_loop_unlock(self->thread_loop); fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: failed to connect to fd %d\n", self->fd); goto error; } // TODO: Error check pw_core_add_listener(self->core, &self->core_listener, &core_events, self); self->server_version_sync = pw_core_sync(self->core, PW_ID_CORE, 0); pw_thread_loop_wait(self->thread_loop); gsr_pipewire_video_init_modifiers(self); // TODO: Cleanup? self->reneg = pw_loop_add_event(pw_thread_loop_get_loop(self->thread_loop), renegotiate_format, self); if(!self->reneg) { pw_thread_loop_unlock(self->thread_loop); fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: pw_loop_add_event failed\n"); goto error; } self->stream = pw_stream_new(self->core, "com.dec05eba.gpu_screen_recorder", pw_properties_new(PW_KEY_MEDIA_TYPE, "Video", PW_KEY_MEDIA_CATEGORY, "Capture", PW_KEY_MEDIA_ROLE, "Screen", NULL)); if(!self->stream) { pw_thread_loop_unlock(self->thread_loop); fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: failed to create stream\n"); goto error; } pw_stream_add_listener(self->stream, &self->stream_listener, &stream_events, self); if(!gsr_pipewire_video_build_format_params(self, &pod_builder, params, &num_video_formats)) { pw_thread_loop_unlock(self->thread_loop); fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: failed to build format params\n"); goto error; } if(pw_stream_connect( self->stream, PW_DIRECTION_INPUT, self->node, PW_STREAM_FLAG_AUTOCONNECT | PW_STREAM_FLAG_MAP_BUFFERS, (const struct spa_pod**)params, num_video_formats) < 0) { pw_thread_loop_unlock(self->thread_loop); fprintf(stderr, "gsr error: gsr_pipewire_video_setup_stream: failed to connect stream\n"); goto error; } pw_thread_loop_unlock(self->thread_loop); return true; error: if(self->thread_loop) { //pw_thread_loop_wait(self->thread_loop); pw_thread_loop_stop(self->thread_loop); } if(self->stream) { pw_stream_disconnect(self->stream); pw_stream_destroy(self->stream); self->stream = NULL; } if(self->core) { pw_core_disconnect(self->core); self->core = NULL; } if(self->context) { pw_context_destroy(self->context); self->context = NULL; } if(self->thread_loop) { pw_thread_loop_destroy(self->thread_loop); self->thread_loop = NULL; } return false; } static int pw_init_counter = 0; bool gsr_pipewire_video_init(gsr_pipewire_video *self, int pipewire_fd, uint32_t pipewire_node, int fps, bool capture_cursor, gsr_egl *egl) { if(pw_init_counter == 0) pw_init(NULL, NULL); ++pw_init_counter; memset(self, 0, sizeof(*self)); self->egl = egl; self->fd = pipewire_fd; self->node = pipewire_node; if(pthread_mutex_init(&self->mutex, NULL) != 0) { fprintf(stderr, "gsr error: gsr_pipewire_video_init: failed to initialize mutex\n"); gsr_pipewire_video_deinit(self); return false; } self->mutex_initialized = true; self->video_info.fps_num = fps; self->video_info.fps_den = 1; self->cursor.visible = capture_cursor; if(!gsr_pipewire_video_setup_stream(self)) { gsr_pipewire_video_deinit(self); return false; } return true; } void gsr_pipewire_video_deinit(gsr_pipewire_video *self) { if(self->thread_loop) { //pw_thread_loop_wait(self->thread_loop); pw_thread_loop_stop(self->thread_loop); } if(self->stream) { pw_stream_disconnect(self->stream); pw_stream_destroy(self->stream); self->stream = NULL; } if(self->core) { pw_core_disconnect(self->core); self->core = NULL; } if(self->context) { pw_context_destroy(self->context); self->context = NULL; } if(self->thread_loop) { pw_thread_loop_destroy(self->thread_loop); self->thread_loop = NULL; } if(self->fd > 0) { close(self->fd); self->fd = -1; } for(size_t i = 0; i < self->dmabuf_num_planes; ++i) { if(self->dmabuf_data[i].fd > 0) { close(self->dmabuf_data[i].fd); self->dmabuf_data[i].fd = -1; } } self->dmabuf_num_planes = 0; self->negotiated = false; if(self->mutex_initialized) { pthread_mutex_destroy(&self->mutex); self->mutex_initialized = false; } if(self->cursor.data) { free(self->cursor.data); self->cursor.data = NULL; } --pw_init_counter; if(pw_init_counter == 0) { #if PW_CHECK_VERSION(0, 3, 49) pw_deinit(); #endif } } static EGLImage gsr_pipewire_video_create_egl_image(gsr_pipewire_video *self, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, bool use_modifiers) { intptr_t img_attr[44]; setup_dma_buf_attrs(img_attr, spa_video_format_to_drm_format(self->format.info.raw.format), self->format.info.raw.size.width, self->format.info.raw.size.height, fds, offsets, pitches, modifiers, self->dmabuf_num_planes, use_modifiers); while(self->egl->eglGetError() != EGL_SUCCESS){} EGLImage image = self->egl->eglCreateImage(self->egl->egl_display, 0, EGL_LINUX_DMA_BUF_EXT, NULL, img_attr); if(!image || self->egl->eglGetError() != EGL_SUCCESS) { if(image) self->egl->eglDestroyImage(self->egl->egl_display, image); return NULL; } return image; } static EGLImage gsr_pipewire_video_create_egl_image_with_fallback(gsr_pipewire_video *self) { int fds[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES]; uint32_t offsets[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES]; uint32_t pitches[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES]; uint64_t modifiers[GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES]; for(size_t i = 0; i < self->dmabuf_num_planes; ++i) { fds[i] = self->dmabuf_data[i].fd; offsets[i] = self->dmabuf_data[i].offset; pitches[i] = self->dmabuf_data[i].stride; modifiers[i] = self->format.info.raw.modifier; } EGLImage image = NULL; if(self->no_modifiers_fallback || !self->has_modifier) { image = gsr_pipewire_video_create_egl_image(self, fds, offsets, pitches, modifiers, false); } else { image = gsr_pipewire_video_create_egl_image(self, fds, offsets, pitches, modifiers, true); if(!image) { if(self->format.info.raw.modifier == DRM_FORMAT_MOD_INVALID) { fprintf(stderr, "gsr error: gsr_pipewire_video_create_egl_image_with_fallback: failed to create egl image with modifiers, trying without modifiers\n"); self->no_modifiers_fallback = true; image = gsr_pipewire_video_create_egl_image(self, fds, offsets, pitches, modifiers, false); } else { fprintf(stderr, "gsr error: gsr_pipewire_video_create_egl_image_with_fallback: failed to create egl image with modifier 0x%" PRIx64 ", renegotiating with a different modifier\n", self->format.info.raw.modifier); self->negotiated = false; pw_thread_loop_lock(self->thread_loop); gsr_pipewire_video_remove_modifier(self, self->format.info.raw.modifier); pw_loop_signal_event(pw_thread_loop_get_loop(self->thread_loop), self->reneg); pw_thread_loop_unlock(self->thread_loop); } } } return image; } static bool gsr_pipewire_video_bind_image_to_texture(gsr_pipewire_video *self, EGLImage image, unsigned int texture_id, bool external_texture) { const int texture_target = external_texture ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D; while(self->egl->glGetError() != 0){} self->egl->glBindTexture(texture_target, texture_id); self->egl->glEGLImageTargetTexture2DOES(texture_target, image); const bool success = self->egl->glGetError() == 0; self->egl->glBindTexture(texture_target, 0); return success; } static void gsr_pipewire_video_bind_image_to_texture_with_fallback(gsr_pipewire_video *self, gsr_texture_map texture_map, EGLImage image) { if(self->external_texture_fallback) { gsr_pipewire_video_bind_image_to_texture(self, image, texture_map.external_texture_id, true); } else { if(!gsr_pipewire_video_bind_image_to_texture(self, image, texture_map.texture_id, false)) { fprintf(stderr, "gsr error: gsr_pipewire_video_map_texture: failed to bind image to texture, trying with external texture\n"); self->external_texture_fallback = true; gsr_pipewire_video_bind_image_to_texture(self, image, texture_map.external_texture_id, true); } } } static void gsr_pipewire_video_update_cursor_texture(gsr_pipewire_video *self, gsr_texture_map texture_map) { if(!self->cursor.data) return; self->egl->glBindTexture(GL_TEXTURE_2D, texture_map.cursor_texture_id); // TODO: glTextureSubImage2D if same size self->egl->glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, self->cursor.width, self->cursor.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, self->cursor.data); self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); self->egl->glBindTexture(GL_TEXTURE_2D, 0); free(self->cursor.data); self->cursor.data = NULL; } bool gsr_pipewire_video_map_texture(gsr_pipewire_video *self, gsr_texture_map texture_map, gsr_map_texture_output *output) { for(int i = 0; i < GSR_PIPEWIRE_VIDEO_DMABUF_MAX_PLANES; ++i) { memset(&output->dmabuf_data[i], 0, sizeof(gsr_pipewire_video_dmabuf_data)); } output->num_dmabuf_data = 0; output->using_external_image = self->external_texture_fallback; output->fourcc = 0; output->modifiers = 0; output->rotation = GSR_MONITOR_ROT_0; pthread_mutex_lock(&self->mutex); if(!self->negotiated || !self->streaming || self->dmabuf_data[0].fd <= 0) { pthread_mutex_unlock(&self->mutex); return false; } EGLImage image = gsr_pipewire_video_create_egl_image_with_fallback(self); if(!image) { pthread_mutex_unlock(&self->mutex); return false; } gsr_pipewire_video_bind_image_to_texture_with_fallback(self, texture_map, image); output->using_external_image = self->external_texture_fallback; self->egl->eglDestroyImage(self->egl->egl_display, image); gsr_pipewire_video_update_cursor_texture(self, texture_map); output->texture_width = self->format.info.raw.size.width; output->texture_height = self->format.info.raw.size.height; output->region.x = 0; output->region.y = 0; output->region.width = self->format.info.raw.size.width; output->region.height = self->format.info.raw.size.height; if(self->crop.valid) { output->region.x = self->crop.x; output->region.y = self->crop.y; output->region.width = self->crop.width; output->region.height = self->crop.height; } // TODO: Test transform + cropping if(self->rotation == GSR_MONITOR_ROT_90 || self->rotation == GSR_MONITOR_ROT_270) { const int temp = output->region.width; output->region.width = output->region.height; output->region.height = temp; } /* TODO: Test if cursor hotspot is correct */ output->cursor_region.x = self->cursor.x - self->cursor.hotspot_x; output->cursor_region.y = self->cursor.y - self->cursor.hotspot_y; output->cursor_region.width = self->cursor.width; output->cursor_region.height = self->cursor.height; for(size_t i = 0; i < self->dmabuf_num_planes; ++i) { output->dmabuf_data[i] = self->dmabuf_data[i]; self->dmabuf_data[i].fd = -1; } output->num_dmabuf_data = self->dmabuf_num_planes; output->fourcc = spa_video_format_to_drm_format(self->format.info.raw.format); output->modifiers = self->format.info.raw.modifier; output->rotation = self->rotation; self->dmabuf_num_planes = 0; pthread_mutex_unlock(&self->mutex); return true; } bool gsr_pipewire_video_is_damaged(gsr_pipewire_video *self) { if(!self->mutex_initialized) return false; bool damaged = false; pthread_mutex_lock(&self->mutex); damaged = self->damaged; pthread_mutex_unlock(&self->mutex); return damaged; } void gsr_pipewire_video_clear_damage(gsr_pipewire_video *self) { if(!self->mutex_initialized) return; pthread_mutex_lock(&self->mutex); self->damaged = false; pthread_mutex_unlock(&self->mutex); } bool gsr_pipewire_video_should_restart(gsr_pipewire_video *self) { if(!self->mutex_initialized) return false; bool should_restart = false; pthread_mutex_lock(&self->mutex); should_restart = self->paused && clock_get_monotonic_seconds() - self->paused_start_secs >= 3.0; pthread_mutex_unlock(&self->mutex); return should_restart; } fsdsfdsfdsfdsf-5.13.8/src/plugins.c000066400000000000000000000117061520215207700172260ustar00rootroot00000000000000#include "../include/plugins.h" #include "../include/utils.h" #include #include #include #include static int color_depth_to_gl_internal_format(gsr_plugin_color_depth color_depth) { switch(color_depth) { case GSR_PLUGIN_COLOR_DEPTH_8_BITS: return GL_RGBA8; case GSR_PLUGIN_COLOR_DEPTH_10_BITS: return GL_RGBA16; } assert(false); return GL_RGBA8; } bool gsr_plugins_init(gsr_plugins *self, gsr_plugin_init_params init_params, gsr_egl *egl) { memset(self, 0, sizeof(*self)); self->init_params = init_params; self->egl = egl; const unsigned int texture = gl_create_texture(egl, init_params.width, init_params.height, color_depth_to_gl_internal_format(init_params.color_depth), GL_RGBA, GL_LINEAR); if(texture == 0) { fprintf(stderr, "gsr error: gsr_plugins_init failed to create texture\n"); return false; } self->texture = texture; gsr_color_conversion_params color_conversion_params = { .egl = egl, .destination_color = GSR_DESTINATION_COLOR_RGB, .destination_textures[0] = self->texture, .destination_textures_size[0] = (vec2i){ init_params.width, init_params.height }, .num_destination_textures = 1, .color_range = GSR_COLOR_RANGE_FULL, .load_external_image_shader = false, //.force_graphics_shader = false, }; color_conversion_params.destination_textures[0] = self->texture; if(gsr_color_conversion_init(&self->color_conversion, &color_conversion_params) != 0) { fprintf(stderr, "gsr error: gsr_plugins_init failed to create color conversion\n"); gsr_plugins_deinit(self); return false; } gsr_color_conversion_clear(&self->color_conversion); return true; } void gsr_plugins_deinit(gsr_plugins *self) { for(int i = self->num_plugins - 1; i >= 0; --i) { gsr_plugin *plugin = &self->plugins[i]; plugin->gsr_plugin_deinit(plugin->data.userdata); fprintf(stderr, "gsr info: unloaded plugin: %s\n", plugin->data.name); } self->num_plugins = 0; if(self->texture > 0) { self->egl->glDeleteTextures(1, &self->texture); self->texture = 0; } gsr_color_conversion_deinit(&self->color_conversion); } bool gsr_plugins_load_plugin(gsr_plugins *self, const char *plugin_filepath) { if(self->num_plugins >= GSR_MAX_PLUGINS) { fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed, more plugins can't load more than %d plugins. Report this as an issue\n", GSR_MAX_PLUGINS); return false; } gsr_plugin plugin; memset(&plugin, 0, sizeof(plugin)); plugin.lib = dlopen(plugin_filepath, RTLD_LAZY); if(!plugin.lib) { fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load \"%s\", error: %s\n", plugin_filepath, dlerror()); return false; } plugin.gsr_plugin_init = dlsym(plugin.lib, "gsr_plugin_init"); if(!plugin.gsr_plugin_init) { fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to find \"gsr_plugin_init\" in plugin \"%s\"\n", plugin_filepath); goto fail; } plugin.gsr_plugin_deinit = dlsym(plugin.lib, "gsr_plugin_deinit"); if(!plugin.gsr_plugin_deinit) { fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to find \"gsr_plugin_deinit\" in plugin \"%s\"\n", plugin_filepath); goto fail; } if(!plugin.gsr_plugin_init(&self->init_params, &plugin.data)) { fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load plugin \"%s\", gsr_plugin_init in the plugin failed\n", plugin_filepath); goto fail; } if(!plugin.data.name) { fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load plugin \"%s\", the plugin didn't set the name (gsr_plugin_init_return.name)\n", plugin_filepath); goto fail; } if(plugin.data.version == 0) { fprintf(stderr, "gsr error: gsr_plugins_load_plugin failed to load plugin \"%s\", the plugin didn't set the version (gsr_plugin_init_return.version)\n", plugin_filepath); goto fail; } fprintf(stderr, "gsr info: loaded plugin: %s, name: %s, version: %u\n", plugin_filepath, plugin.data.name, plugin.data.version); self->plugins[self->num_plugins] = plugin; ++self->num_plugins; return true; fail: dlclose(plugin.lib); return false; } void gsr_plugins_draw(gsr_plugins *self) { const gsr_plugin_draw_params params = { .width = self->init_params.width, .height = self->init_params.height, }; self->egl->glBindFramebuffer(GL_FRAMEBUFFER, self->color_conversion.framebuffers[0]); self->egl->glViewport(0, 0, self->init_params.width, self->init_params.height); for(int i = 0; i < self->num_plugins; ++i) { const gsr_plugin *plugin = &self->plugins[i]; if(plugin->data.draw) plugin->data.draw(¶ms, plugin->data.userdata); } self->egl->glBindFramebuffer(GL_FRAMEBUFFER, 0); } fsdsfdsfdsfdsf-5.13.8/src/replay_buffer/000077500000000000000000000000001520215207700202215ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/src/replay_buffer/replay_buffer.c000066400000000000000000000042401520215207700232120ustar00rootroot00000000000000#include "../../include/replay_buffer/replay_buffer.h" #include "../../include/replay_buffer/replay_buffer_ram.h" #include "../../include/replay_buffer/replay_buffer_disk.h" #include #include #include gsr_replay_buffer* gsr_replay_buffer_create(gsr_replay_storage replay_storage, const char *replay_directory, double replay_buffer_time, size_t replay_buffer_num_packets) { gsr_replay_buffer *replay_buffer = NULL; switch(replay_storage) { case GSR_REPLAY_STORAGE_RAM: replay_buffer = gsr_replay_buffer_ram_create(replay_buffer_num_packets); break; case GSR_REPLAY_STORAGE_DISK: replay_buffer = gsr_replay_buffer_disk_create(replay_directory, replay_buffer_time); break; } return replay_buffer; } void gsr_replay_buffer_destroy(gsr_replay_buffer *self) { self->destroy(self); free(self); } bool gsr_replay_buffer_append(gsr_replay_buffer *self, const AVPacket *av_packet, double timestamp) { return self->append(self, av_packet, timestamp); } void gsr_replay_buffer_clear(gsr_replay_buffer *self) { self->clear(self); } AVPacket* gsr_replay_buffer_iterator_get_packet(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator) { return self->iterator_get_packet(self, iterator); } uint8_t* gsr_replay_buffer_iterator_get_packet_data(gsr_replay_buffer *self, gsr_replay_buffer_iterator iterator) { return self->iterator_get_packet_data(self, iterator); } gsr_replay_buffer* gsr_replay_buffer_clone(gsr_replay_buffer *self) { return self->clone(self); } gsr_replay_buffer_iterator gsr_replay_buffer_find_packet_index_by_time_passed(gsr_replay_buffer *self, int seconds) { return self->find_packet_index_by_time_passed(self, seconds); } gsr_replay_buffer_iterator gsr_replay_buffer_find_keyframe(gsr_replay_buffer *self, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) { return self->find_keyframe(self, start_iterator, stream_index, invert_stream_index); } bool gsr_replay_buffer_iterator_next(gsr_replay_buffer *self, gsr_replay_buffer_iterator *iterator) { return self->iterator_next(self, iterator); } fsdsfdsfdsfdsf-5.13.8/src/replay_buffer/replay_buffer_disk.c000066400000000000000000000401731520215207700242310ustar00rootroot00000000000000#include "../../include/replay_buffer/replay_buffer_disk.h" #include "../../include/utils.h" #include #include #include #include #include #include #include #include #define REPLAY_BUFFER_FILE_SIZE_BYTES 1024 * 1024 * 256 /* 256MB */ #define FILE_PREFIX "Replay" static void gsr_replay_buffer_disk_set_impl_funcs(gsr_replay_buffer_disk *self); static void gsr_av_packet_disk_init(gsr_av_packet_disk *self, const AVPacket *av_packet, size_t data_index, double timestamp) { self->packet = *av_packet; self->packet.data = NULL; self->data_index = data_index; self->timestamp = timestamp; } static gsr_replay_buffer_file* gsr_replay_buffer_file_create(char *replay_directory, size_t replay_storage_counter, double timestamp, int *replay_storage_fd) { gsr_replay_buffer_file *self = calloc(1, sizeof(gsr_replay_buffer_file)); if(!self) { fprintf(stderr, "gsr error: gsr_av_packet_file_init: failed to create buffer file\n"); return NULL; } if(create_directory_recursive(replay_directory) != 0) { fprintf(stderr, "gsr error: gsr_av_packet_file_init: failed to create replay directory: %s\n", replay_directory); free(self); return NULL; } char filename[PATH_MAX]; snprintf(filename, sizeof(filename), "%s/%s_%d.gsr", replay_directory, FILE_PREFIX, (int)replay_storage_counter); *replay_storage_fd = creat(filename, 0700); if(*replay_storage_fd <= 0) { fprintf(stderr, "gsr error: gsr_av_packet_file_init: failed to create replay file: %s\n", filename); free(self); return NULL; } self->id = replay_storage_counter; self->start_timestamp = timestamp; self->end_timestamp = timestamp; self->ref_counter = 1; self->fd = -1; self->packets = NULL; self->capacity_num_packets = 0; self->num_packets = 0; return self; } static gsr_replay_buffer_file* gsr_replay_buffer_file_ref(gsr_replay_buffer_file *self) { if(self->ref_counter >= 1) ++self->ref_counter; return self; } static void gsr_replay_buffer_file_free(gsr_replay_buffer_file *self, const char *replay_directory) { self->ref_counter = 0; if(self->fd > 0) { close(self->fd); self->fd = -1; } char filename[PATH_MAX]; snprintf(filename, sizeof(filename), "%s/%s_%d.gsr", replay_directory, FILE_PREFIX, (int)self->id); remove(filename); if(self->packets) { free(self->packets); self->packets = NULL; } self->num_packets = 0; self->capacity_num_packets = 0; free(self); } static void gsr_replay_buffer_file_unref(gsr_replay_buffer_file *self, const char *replay_directory) { if(self->ref_counter > 0) --self->ref_counter; if(self->ref_counter <= 0) gsr_replay_buffer_file_free(self, replay_directory); } static void gsr_replay_buffer_disk_clear(gsr_replay_buffer *replay_buffer) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; for(size_t i = 0; i < self->num_files; ++i) { gsr_replay_buffer_file_unref(self->files[i], self->replay_directory); } self->num_files = 0; if(self->storage_fd > 0) { close(self->storage_fd); self->storage_fd = 0; } self->storage_num_bytes_written = 0; } static void gsr_replay_buffer_disk_destroy(gsr_replay_buffer *replay_buffer) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; gsr_replay_buffer_disk_clear(replay_buffer); if(self->owns_directory) { remove(self->replay_directory); self->owns_directory = false; } } static bool file_write_all(int fd, const uint8_t *data, size_t size, size_t *bytes_written_total) { *bytes_written_total = 0; while(*bytes_written_total < size) { const ssize_t bytes_written = write(fd, data + *bytes_written_total, size - *bytes_written_total); if(bytes_written == -1) { if(errno == EAGAIN) continue; else return false; } *bytes_written_total += bytes_written; } return true; } static bool gsr_replay_buffer_disk_create_next_file(gsr_replay_buffer_disk *self, double timestamp) { if(self->num_files + 1 >= GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES) { fprintf(stderr, "gsr error: gsr_replay_buffer_disk_create_next_file: too many replay buffer files created! (> %d), either reduce the replay buffer time or report this as a bug\n", (int)GSR_REPLAY_BUFFER_CAPACITY_NUM_FILES); return false; } gsr_replay_buffer_file *replay_buffer_file = gsr_replay_buffer_file_create(self->replay_directory, self->storage_counter, timestamp, &self->storage_fd); if(!replay_buffer_file) return false; self->files[self->num_files] = replay_buffer_file; ++self->num_files; ++self->storage_counter; return true; } static bool gsr_replay_buffer_disk_append_to_current_file(gsr_replay_buffer_disk *self, const AVPacket *av_packet, double timestamp) { gsr_replay_buffer_file *replay_buffer_file = self->files[self->num_files - 1]; replay_buffer_file->end_timestamp = timestamp; if(replay_buffer_file->num_packets + 1 >= replay_buffer_file->capacity_num_packets) { size_t new_capacity_num_packets = replay_buffer_file->capacity_num_packets * 2; if(new_capacity_num_packets == 0) new_capacity_num_packets = 256; void *new_packets = realloc(replay_buffer_file->packets, new_capacity_num_packets * sizeof(gsr_av_packet_disk)); if(!new_packets) { fprintf(stderr, "gsr error: gsr_replay_buffer_disk_append_to_current_file: failed to reallocate replay buffer file packets\n"); return false; } replay_buffer_file->capacity_num_packets = new_capacity_num_packets; replay_buffer_file->packets = new_packets; } gsr_av_packet_disk *packet = &replay_buffer_file->packets[replay_buffer_file->num_packets]; gsr_av_packet_disk_init(packet, av_packet, self->storage_num_bytes_written, timestamp); ++replay_buffer_file->num_packets; size_t bytes_written = 0; const bool file_written = file_write_all(self->storage_fd, av_packet->data, av_packet->size, &bytes_written); self->storage_num_bytes_written += bytes_written; if(self->storage_num_bytes_written >= REPLAY_BUFFER_FILE_SIZE_BYTES) { self->storage_num_bytes_written = 0; close(self->storage_fd); self->storage_fd = 0; } return file_written; } static void gsr_replay_buffer_disk_remove_first_file(gsr_replay_buffer_disk *self) { gsr_replay_buffer_file_unref(self->files[0], self->replay_directory); for(size_t i = 1; i < self->num_files; ++i) { self->files[i - 1] = self->files[i]; } --self->num_files; } static bool gsr_replay_buffer_disk_append(gsr_replay_buffer *replay_buffer, const AVPacket *av_packet, double timestamp) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; bool success = false; if(self->storage_fd <= 0) { if(!gsr_replay_buffer_disk_create_next_file(self, timestamp)) goto done; } const bool data_written = gsr_replay_buffer_disk_append_to_current_file(self, av_packet, timestamp); if(self->num_files > 1) { const double buffer_time_accumulated = timestamp - self->files[1]->start_timestamp; if(buffer_time_accumulated >= self->replay_buffer_time) gsr_replay_buffer_disk_remove_first_file(self); } success = data_written; done: return success; } static AVPacket* gsr_replay_buffer_disk_iterator_get_packet(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; assert(iterator.file_index < self->num_files); assert(iterator.packet_index < self->files[iterator.file_index]->num_packets); return &self->files[iterator.file_index]->packets[iterator.packet_index].packet; } static uint8_t* gsr_replay_buffer_disk_iterator_get_packet_data(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; assert(iterator.file_index < self->num_files); gsr_replay_buffer_file *file = self->files[iterator.file_index]; assert(iterator.packet_index < file->num_packets); if(file->fd <= 0) { char filename[PATH_MAX]; snprintf(filename, sizeof(filename), "%s/%s_%d.gsr", self->replay_directory, FILE_PREFIX, (int)file->id); file->fd = open(filename, O_RDONLY); if(file->fd <= 0) { fprintf(stderr, "gsr error: gsr_replay_buffer_disk_iterator_get_packet_data: failed to open file\n"); return NULL; } } const gsr_av_packet_disk *packet = &self->files[iterator.file_index]->packets[iterator.packet_index]; if(lseek(file->fd, packet->data_index, SEEK_SET) == -1) { fprintf(stderr, "gsr error: gsr_replay_buffer_disk_iterator_get_packet_data: failed to seek\n"); return NULL; } uint8_t *packet_data = malloc(packet->packet.size); if(read(file->fd, packet_data, packet->packet.size) != packet->packet.size) { fprintf(stderr, "gsr error: gsr_replay_buffer_disk_iterator_get_packet_data: failed to read data from file\n"); free(packet_data); return NULL; } return packet_data; } static gsr_replay_buffer* gsr_replay_buffer_disk_clone(gsr_replay_buffer *replay_buffer) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; gsr_replay_buffer_disk *destination = calloc(1, sizeof(gsr_replay_buffer_disk)); if(!destination) return NULL; gsr_replay_buffer_disk_set_impl_funcs(destination); destination->replay_buffer_time = self->replay_buffer_time; destination->storage_counter = self->storage_counter; destination->storage_num_bytes_written = self->storage_num_bytes_written; destination->storage_fd = 0; // We only want to read from the clone. If there is a need to write to it in the future then TODO change this for(size_t i = 0; i < self->num_files; ++i) { destination->files[i] = gsr_replay_buffer_file_ref(self->files[i]); } destination->num_files = self->num_files; snprintf(destination->replay_directory, sizeof(destination->replay_directory), "%s", self->replay_directory); destination->owns_directory = false; return (gsr_replay_buffer*)destination; } /* Binary search */ static size_t gsr_replay_buffer_file_find_packet_index_by_time_passed(const gsr_replay_buffer_file *self, int seconds) { const double now = clock_get_monotonic_seconds(); if(self->num_packets == 0) { return 0; } size_t lower_bound = 0; size_t upper_bound = self->num_packets; size_t index = 0; for(;;) { index = lower_bound + (upper_bound - lower_bound) / 2; const gsr_av_packet_disk *packet = &self->packets[index]; const double time_passed_since_packet = now - packet->timestamp; if(time_passed_since_packet >= seconds) { if(lower_bound == index) break; lower_bound = index; } else { if(upper_bound == index) break; upper_bound = index; } } return index; } /* Binary search */ static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_file_index_by_time_passed(gsr_replay_buffer *replay_buffer, int seconds) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; const double now = clock_get_monotonic_seconds(); if(self->num_files == 0) { return (gsr_replay_buffer_iterator){0, 0}; } size_t lower_bound = 0; size_t upper_bound = self->num_files; size_t file_index = 0; for(;;) { file_index = lower_bound + (upper_bound - lower_bound) / 2; const gsr_replay_buffer_file *file = self->files[file_index]; const double time_passed_since_file_start = now - file->start_timestamp; const double time_passed_since_file_end = now - file->end_timestamp; if(time_passed_since_file_start >= seconds && time_passed_since_file_end <= seconds) { break; } else if(time_passed_since_file_start >= seconds) { if(lower_bound == file_index) break; lower_bound = file_index; } else { if(upper_bound == file_index) break; upper_bound = file_index; } } const gsr_replay_buffer_file *file = self->files[file_index]; const size_t packet_index = gsr_replay_buffer_file_find_packet_index_by_time_passed(file, seconds); return (gsr_replay_buffer_iterator){packet_index, file_index}; } static gsr_replay_buffer_iterator gsr_replay_buffer_disk_find_keyframe(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; gsr_replay_buffer_iterator keyframe_iterator = {(size_t)-1, 0}; size_t packet_index = start_iterator.packet_index; for(size_t file_index = start_iterator.file_index; file_index < self->num_files; ++file_index) { const gsr_replay_buffer_file *file = self->files[file_index]; for(; packet_index < file->num_packets; ++packet_index) { const gsr_av_packet_disk *packet = &file->packets[packet_index]; if((packet->packet.flags & AV_PKT_FLAG_KEY) && (invert_stream_index ? packet->packet.stream_index != stream_index : packet->packet.stream_index == stream_index)) { keyframe_iterator.packet_index = packet_index; keyframe_iterator.file_index = file_index; goto done; } } packet_index = 0; } done: return keyframe_iterator; } static bool gsr_replay_buffer_disk_iterator_next(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator *iterator) { gsr_replay_buffer_disk *self = (gsr_replay_buffer_disk*)replay_buffer; if(iterator->file_index >= self->num_files) return false; if(iterator->packet_index + 1 >= self->files[iterator->file_index]->num_packets) { if(iterator->file_index + 1 >= self->num_files) return false; if(self->files[iterator->file_index + 1]->num_packets == 0) return false; ++iterator->file_index; iterator->packet_index = 0; return true; } else { ++iterator->packet_index; return true; } } static void get_current_time(char *time_str, size_t time_str_size) { time_t now = time(NULL); struct tm *t = localtime(&now); strftime(time_str, time_str_size - 1, "%Y-%m-%d_%H-%M-%S", t); } static void gsr_replay_buffer_disk_set_impl_funcs(gsr_replay_buffer_disk *self) { self->replay_buffer.destroy = gsr_replay_buffer_disk_destroy; self->replay_buffer.append = gsr_replay_buffer_disk_append; self->replay_buffer.clear = gsr_replay_buffer_disk_clear; self->replay_buffer.iterator_get_packet = gsr_replay_buffer_disk_iterator_get_packet; self->replay_buffer.iterator_get_packet_data = gsr_replay_buffer_disk_iterator_get_packet_data; self->replay_buffer.clone = gsr_replay_buffer_disk_clone; self->replay_buffer.find_packet_index_by_time_passed = gsr_replay_buffer_disk_find_file_index_by_time_passed; self->replay_buffer.find_keyframe = gsr_replay_buffer_disk_find_keyframe; self->replay_buffer.iterator_next = gsr_replay_buffer_disk_iterator_next; } gsr_replay_buffer* gsr_replay_buffer_disk_create(const char *replay_directory, double replay_buffer_time) { assert(replay_buffer_time > 0); gsr_replay_buffer_disk *replay_buffer = calloc(1, sizeof(gsr_replay_buffer_disk)); if(!replay_buffer) return NULL; char time_str[128]; get_current_time(time_str, sizeof(time_str)); replay_buffer->num_files = 0; replay_buffer->storage_counter = 0; replay_buffer->replay_buffer_time = replay_buffer_time; snprintf(replay_buffer->replay_directory, sizeof(replay_buffer->replay_directory), "%s/gsr-replay-%s.gsr", replay_directory, time_str); replay_buffer->owns_directory = true; gsr_replay_buffer_disk_set_impl_funcs(replay_buffer); return (gsr_replay_buffer*)replay_buffer; } fsdsfdsfdsfdsf-5.13.8/src/replay_buffer/replay_buffer_ram.c000066400000000000000000000211741520215207700240560ustar00rootroot00000000000000#include "../../include/replay_buffer/replay_buffer_ram.h" #include "../../include/utils.h" #include #include #include #include static void gsr_replay_buffer_ram_set_impl_funcs(gsr_replay_buffer_ram *self); static gsr_av_packet_ram* gsr_av_packet_ram_create(const AVPacket *av_packet, double timestamp) { gsr_av_packet_ram *self = malloc(sizeof(gsr_av_packet_ram)); if(!self) return NULL; self->ref_counter = 1; self->packet = *av_packet; self->timestamp = timestamp; // Why are we doing this you ask? there is a ffmpeg bug that causes cpu usage to increase over time when you have // packets that are not being free'd until later. So we copy the packet data, free the packet and then reconstruct // the packet later on when we need it, to keep packets alive only for a short period. self->packet.data = av_memdup(av_packet->data, av_packet->size); if(!self->packet.data) { free(self); return NULL; } return self; } static gsr_av_packet_ram* gsr_av_packet_ram_ref(gsr_av_packet_ram *self) { if(self->ref_counter >= 1) ++self->ref_counter; return self; } static void gsr_av_packet_ram_free(gsr_av_packet_ram *self) { self->ref_counter = 0; if(self->packet.data) { av_free(self->packet.data); self->packet.data = NULL; } free(self); } static void gsr_av_packet_ram_unref(gsr_av_packet_ram *self) { if(self->ref_counter >= 1) --self->ref_counter; if(self->ref_counter <= 0) gsr_av_packet_ram_free(self); } static void gsr_replay_buffer_ram_destroy(gsr_replay_buffer *replay_buffer) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; for(size_t i = 0; i < self->num_packets; ++i) { if(self->packets[i]) { gsr_av_packet_ram_unref(self->packets[i]); self->packets[i] = NULL; } } self->num_packets = 0; if(self->packets) { free(self->packets); self->packets = NULL; } self->capacity_num_packets = 0; self->index = 0; } static bool gsr_replay_buffer_ram_append(gsr_replay_buffer *replay_buffer, const AVPacket *av_packet, double timestamp) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; gsr_av_packet_ram *packet = gsr_av_packet_ram_create(av_packet, timestamp); if(!packet) return false; if(self->packets[self->index]) { gsr_av_packet_ram_unref(self->packets[self->index]); self->packets[self->index] = NULL; } self->packets[self->index] = packet; self->index = (self->index + 1) % self->capacity_num_packets; ++self->num_packets; if(self->num_packets > self->capacity_num_packets) self->num_packets = self->capacity_num_packets; return true; } static void gsr_replay_buffer_ram_clear(gsr_replay_buffer *replay_buffer) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; for(size_t i = 0; i < self->num_packets; ++i) { if(self->packets[i]) { gsr_av_packet_ram_unref(self->packets[i]); self->packets[i] = NULL; } } self->num_packets = 0; self->index = 0; } static gsr_av_packet_ram* gsr_replay_buffer_ram_get_packet_at_index(gsr_replay_buffer *replay_buffer, size_t index) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; assert(index < self->num_packets); size_t start_index = 0; if(self->num_packets < self->capacity_num_packets) start_index = self->num_packets - self->index; else start_index = self->index; const size_t offset = (start_index + index) % self->capacity_num_packets; return self->packets[offset]; } static AVPacket* gsr_replay_buffer_ram_iterator_get_packet(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) { return &gsr_replay_buffer_ram_get_packet_at_index(replay_buffer, iterator.packet_index)->packet; } static uint8_t* gsr_replay_buffer_ram_iterator_get_packet_data(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator iterator) { (void)replay_buffer; (void)iterator; return NULL; } static gsr_replay_buffer* gsr_replay_buffer_ram_clone(gsr_replay_buffer *replay_buffer) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; gsr_replay_buffer_ram *destination = calloc(1, sizeof(gsr_replay_buffer_ram)); if(!destination) return NULL; gsr_replay_buffer_ram_set_impl_funcs(destination); destination->capacity_num_packets = self->capacity_num_packets; destination->index = self->index; destination->packets = calloc(destination->capacity_num_packets, sizeof(gsr_av_packet_ram*)); if(!destination->packets) { free(destination); return NULL; } destination->num_packets = self->num_packets; for(size_t i = 0; i < destination->num_packets; ++i) { destination->packets[i] = gsr_av_packet_ram_ref(self->packets[i]); } return (gsr_replay_buffer*)destination; } /* Binary search */ static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_packet_index_by_time_passed(gsr_replay_buffer *replay_buffer, int seconds) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; const double now = clock_get_monotonic_seconds(); if(self->num_packets == 0) { return (gsr_replay_buffer_iterator){0, 0}; } size_t lower_bound = 0; size_t upper_bound = self->num_packets; size_t index = 0; for(;;) { index = lower_bound + (upper_bound - lower_bound) / 2; const gsr_av_packet_ram *packet = gsr_replay_buffer_ram_get_packet_at_index(replay_buffer, index); const double time_passed_since_packet = now - packet->timestamp; if(time_passed_since_packet >= seconds) { if(lower_bound == index) break; lower_bound = index; } else { if(upper_bound == index) break; upper_bound = index; } } return (gsr_replay_buffer_iterator){index, 0}; } static gsr_replay_buffer_iterator gsr_replay_buffer_ram_find_keyframe(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator start_iterator, int stream_index, bool invert_stream_index) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; size_t keyframe_index = (size_t)-1; for(size_t i = start_iterator.packet_index; i < self->num_packets; ++i) { const gsr_av_packet_ram *packet = gsr_replay_buffer_ram_get_packet_at_index(replay_buffer, i); if((packet->packet.flags & AV_PKT_FLAG_KEY) && (invert_stream_index ? packet->packet.stream_index != stream_index : packet->packet.stream_index == stream_index)) { keyframe_index = i; break; } } return (gsr_replay_buffer_iterator){keyframe_index, 0}; } static bool gsr_replay_buffer_ram_iterator_next(gsr_replay_buffer *replay_buffer, gsr_replay_buffer_iterator *iterator) { gsr_replay_buffer_ram *self = (gsr_replay_buffer_ram*)replay_buffer; if(iterator->packet_index + 1 < self->num_packets) { ++iterator->packet_index; return true; } else { return false; } } static void gsr_replay_buffer_ram_set_impl_funcs(gsr_replay_buffer_ram *self) { self->replay_buffer.destroy = gsr_replay_buffer_ram_destroy; self->replay_buffer.append = gsr_replay_buffer_ram_append; self->replay_buffer.clear = gsr_replay_buffer_ram_clear; self->replay_buffer.iterator_get_packet = gsr_replay_buffer_ram_iterator_get_packet; self->replay_buffer.iterator_get_packet_data = gsr_replay_buffer_ram_iterator_get_packet_data; self->replay_buffer.clone = gsr_replay_buffer_ram_clone; self->replay_buffer.find_packet_index_by_time_passed = gsr_replay_buffer_ram_find_packet_index_by_time_passed; self->replay_buffer.find_keyframe = gsr_replay_buffer_ram_find_keyframe; self->replay_buffer.iterator_next = gsr_replay_buffer_ram_iterator_next; } gsr_replay_buffer* gsr_replay_buffer_ram_create(size_t replay_buffer_num_packets) { assert(replay_buffer_num_packets > 0); gsr_replay_buffer_ram *replay_buffer = calloc(1, sizeof(gsr_replay_buffer_ram)); if(!replay_buffer) return NULL; replay_buffer->capacity_num_packets = replay_buffer_num_packets; replay_buffer->num_packets = 0; replay_buffer->index = 0; replay_buffer->packets = calloc(replay_buffer->capacity_num_packets, sizeof(gsr_av_packet_ram*)); if(!replay_buffer->packets) { gsr_replay_buffer_ram_destroy(&replay_buffer->replay_buffer); free(replay_buffer); return NULL; } gsr_replay_buffer_ram_set_impl_funcs(replay_buffer); return (gsr_replay_buffer*)replay_buffer; } fsdsfdsfdsfdsf-5.13.8/src/shader.c000066400000000000000000000103511520215207700170060ustar00rootroot00000000000000#include "../include/shader.h" #include "../include/egl.h" #include #include static bool print_compile_errors = false; static int min_int(int a, int b) { return a < b ? a : b; } static unsigned int load_shader(gsr_egl *egl, unsigned int type, const char *source) { unsigned int shader_id = egl->glCreateShader(type); if(shader_id == 0) { fprintf(stderr, "gsr error: load_shader: failed to create shader, error: %d\n", egl->glGetError()); return 0; } egl->glShaderSource(shader_id, 1, &source, NULL); egl->glCompileShader(shader_id); int compiled = 0; egl->glGetShaderiv(shader_id, GL_COMPILE_STATUS, &compiled); if(!compiled) { int info_length = 0; egl->glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &info_length); if(info_length > 1 && print_compile_errors) { char info_log[4096]; egl->glGetShaderInfoLog(shader_id, min_int(4096, info_length), NULL, info_log); fprintf(stderr, "gsr error: load_shader: failed to compile shader, error:\n%s\nshader source:\n%s\n", info_log, source); } egl->glDeleteShader(shader_id); return 0; } return shader_id; } static unsigned int load_program(gsr_egl *egl, const char *vertex_shader, const char *fragment_shader) { unsigned int vertex_shader_id = 0; unsigned int fragment_shader_id = 0; unsigned int program_id = 0; int linked = 0; bool success = false; if(vertex_shader) { vertex_shader_id = load_shader(egl, GL_VERTEX_SHADER, vertex_shader); if(vertex_shader_id == 0) goto done; } if(fragment_shader) { fragment_shader_id = load_shader(egl, GL_FRAGMENT_SHADER, fragment_shader); if(fragment_shader_id == 0) goto done; } program_id = egl->glCreateProgram(); if(program_id == 0) { fprintf(stderr, "gsr error: load_program: failed to create shader program, error: %d\n", egl->glGetError()); goto done; } if(vertex_shader_id) egl->glAttachShader(program_id, vertex_shader_id); if(fragment_shader_id) egl->glAttachShader(program_id, fragment_shader_id); egl->glLinkProgram(program_id); egl->glGetProgramiv(program_id, GL_LINK_STATUS, &linked); if(!linked) { int info_length = 0; egl->glGetProgramiv(program_id, GL_INFO_LOG_LENGTH, &info_length); if(info_length > 1) { char info_log[4096]; egl->glGetProgramInfoLog(program_id, min_int(4096, info_length), NULL, info_log); fprintf(stderr, "gsr error: load program: linking shader program failed, error:\n%s\n", info_log); } goto done; } success = true; done: if(!success) { if(program_id) egl->glDeleteProgram(program_id); program_id = 0; } if(fragment_shader_id) egl->glDeleteShader(fragment_shader_id); if(vertex_shader_id) egl->glDeleteShader(vertex_shader_id); return program_id; } int gsr_shader_init(gsr_shader *self, gsr_egl *egl, const char *vertex_shader, const char *fragment_shader) { assert(egl); self->egl = egl; self->program_id = 0; if(!vertex_shader && !fragment_shader) { fprintf(stderr, "gsr error: gsr_shader_init: vertex and fragment shader can't be NULL at the same time\n"); return -1; } self->program_id = load_program(self->egl, vertex_shader, fragment_shader); if(self->program_id == 0) return -1; return 0; } void gsr_shader_deinit(gsr_shader *self) { if(!self->egl) return; if(self->program_id) { self->egl->glDeleteProgram(self->program_id); self->program_id = 0; } self->egl = NULL; } int gsr_shader_bind_attribute_location(gsr_shader *self, const char *attribute, int location) { while(self->egl->glGetError()) {} self->egl->glBindAttribLocation(self->program_id, location, attribute); return self->egl->glGetError(); } void gsr_shader_use(gsr_shader *self) { self->egl->glUseProgram(self->program_id); } void gsr_shader_use_none(gsr_shader *self) { self->egl->glUseProgram(0); } void gsr_shader_enable_debug_output(bool enable) { print_compile_errors = enable; } fsdsfdsfdsfdsf-5.13.8/src/sound.cpp000066400000000000000000000554441520215207700172440ustar00rootroot00000000000000#include "../include/sound.hpp" extern "C" { #include "../include/utils.h" } #include #include #include #include #include #include #include #include #include #include #define RECONNECT_TRY_TIMEOUT_SECONDS 0.5 #define DEVICE_NAME_MAX_SIZE 128 #define CHECK_DEAD_GOTO(p, rerror, label) \ do { \ if (!(p)->context || !PA_CONTEXT_IS_GOOD(pa_context_get_state((p)->context)) || \ !(p)->stream || !PA_STREAM_IS_GOOD(pa_stream_get_state((p)->stream))) { \ if (((p)->context && pa_context_get_state((p)->context) == PA_CONTEXT_FAILED) || \ ((p)->stream && pa_stream_get_state((p)->stream) == PA_STREAM_FAILED)) { \ if (rerror) \ *(rerror) = pa_context_errno((p)->context); \ } else \ if (rerror) \ *(rerror) = PA_ERR_BADSTATE; \ goto label; \ } \ } while(false); enum class DeviceType { STANDARD, DEFAULT_OUTPUT, DEFAULT_INPUT }; struct pa_handle { pa_context *context; pa_stream *stream; pa_mainloop *mainloop; const void *read_data; size_t read_index, read_length; uint8_t *output_data; size_t output_index, output_length; int operation_success; double latency_seconds; pa_buffer_attr attr; pa_sample_spec ss; std::mutex reconnect_mutex; DeviceType device_type; char stream_name[256]; char node_name[256]; bool reconnect; double reconnect_last_tried_seconds; char device_name[DEVICE_NAME_MAX_SIZE]; char default_output_device_name[DEVICE_NAME_MAX_SIZE]; char default_input_device_name[DEVICE_NAME_MAX_SIZE]; pa_proplist *proplist; bool connected; }; static void pa_sound_device_free(pa_handle *p) { assert(p); if(p->proplist) { pa_proplist_free(p->proplist); p->proplist = NULL; } if (p->stream) { pa_stream_unref(p->stream); p->stream = NULL; } if (p->context) { pa_context_disconnect(p->context); pa_context_unref(p->context); p->context = NULL; } if (p->mainloop) { pa_mainloop_free(p->mainloop); p->mainloop = NULL; } if (p->output_data) { free(p->output_data); p->output_data = NULL; } pa_xfree(p); } static void subscribe_update_default_devices(pa_context*, const pa_server_info *server_info, void *userdata) { pa_handle *handle = (pa_handle*)userdata; std::lock_guard lock(handle->reconnect_mutex); if(server_info->default_sink_name) { // TODO: Size check snprintf(handle->default_output_device_name, sizeof(handle->default_output_device_name), "%s.monitor", server_info->default_sink_name); if(handle->device_type == DeviceType::DEFAULT_OUTPUT && strcmp(handle->device_name, handle->default_output_device_name) != 0) { handle->reconnect = true; handle->reconnect_last_tried_seconds = clock_get_monotonic_seconds(); // TODO: Size check snprintf(handle->device_name, sizeof(handle->device_name), "%s", handle->default_output_device_name); } } if(server_info->default_source_name) { // TODO: Size check snprintf(handle->default_input_device_name, sizeof(handle->default_input_device_name), "%s", server_info->default_source_name); if(handle->device_type == DeviceType::DEFAULT_INPUT && strcmp(handle->device_name, handle->default_input_device_name) != 0) { handle->reconnect = true; handle->reconnect_last_tried_seconds = clock_get_monotonic_seconds(); // TODO: Size check snprintf(handle->device_name, sizeof(handle->device_name), "%s", handle->default_input_device_name); } } } static void subscribe_cb(pa_context *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { (void)idx; pa_handle *handle = (pa_handle*)userdata; if((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SERVER) { pa_operation *pa = pa_context_get_server_info(c, subscribe_update_default_devices, handle); if(pa) pa_operation_unref(pa); } } static void store_default_devices(pa_context*, const pa_server_info *server_info, void *userdata) { pa_handle *handle = (pa_handle*)userdata; if(server_info->default_sink_name) snprintf(handle->default_output_device_name, sizeof(handle->default_output_device_name), "%s.monitor", server_info->default_sink_name); if(server_info->default_source_name) snprintf(handle->default_input_device_name, sizeof(handle->default_input_device_name), "%s", server_info->default_source_name); } static bool startup_get_default_devices(pa_handle *p, const char *device_name) { pa_operation *pa = pa_context_get_server_info(p->context, store_default_devices, p); while(pa) { pa_operation_state state = pa_operation_get_state(pa); if(state == PA_OPERATION_DONE) { pa_operation_unref(pa); break; } else if(state == PA_OPERATION_CANCELLED) { pa_operation_unref(pa); return false; } pa_mainloop_iterate(p->mainloop, 1, NULL); } if(p->default_output_device_name[0] == '\0') { fprintf(stderr, "gsr error: failed to find default audio output device\n"); return false; } if(strcmp(device_name, "default_output") == 0) { snprintf(p->device_name, sizeof(p->device_name), "%s", p->default_output_device_name); p->device_type = DeviceType::DEFAULT_OUTPUT; } else if(strcmp(device_name, "default_input") == 0) { snprintf(p->device_name, sizeof(p->device_name), "%s", p->default_input_device_name); p->device_type = DeviceType::DEFAULT_INPUT; } else { snprintf(p->device_name, sizeof(p->device_name), "%s", device_name); p->device_type = DeviceType::STANDARD; } return true; } static pa_handle* pa_sound_device_new(const char *server, const char *name, const char *device_name, const char *stream_name, const pa_sample_spec *ss, const pa_buffer_attr *attr, int *rerror) { pa_handle *p; int error = PA_ERR_INTERNAL; pa_operation *pa = NULL; p = pa_xnew0(pa_handle, 1); p->attr = *attr; p->ss = *ss; snprintf(p->node_name, sizeof(p->node_name), "%s", name); snprintf(p->stream_name, sizeof(p->stream_name), "%s", stream_name); p->reconnect = true; p->reconnect_last_tried_seconds = clock_get_monotonic_seconds() - (RECONNECT_TRY_TIMEOUT_SECONDS * 1000.0 * 2.0); p->default_output_device_name[0] = '\0'; p->default_input_device_name[0] = '\0'; p->device_type = DeviceType::STANDARD; const int buffer_size = attr->fragsize; void *buffer = malloc(buffer_size); if(!buffer) { fprintf(stderr, "gsr error: failed to allocate buffer for audio\n"); *rerror = -1; return NULL; } p->output_data = (uint8_t*)buffer; p->output_length = buffer_size; p->output_index = 0; p->proplist = pa_proplist_new(); pa_proplist_sets(p->proplist, PA_PROP_MEDIA_ROLE, "production"); if(strcmp(device_name, "") == 0) { pa_proplist_sets(p->proplist, "node.autoconnect", "false"); pa_proplist_sets(p->proplist, "node.dont-reconnect", "true"); } if (!(p->mainloop = pa_mainloop_new())) goto fail; if (!(p->context = pa_context_new_with_proplist(pa_mainloop_get_api(p->mainloop), p->node_name, p->proplist))) goto fail; if (pa_context_connect(p->context, server, PA_CONTEXT_NOFLAGS, NULL) < 0) { error = pa_context_errno(p->context); goto fail; } for (;;) { pa_context_state_t state = pa_context_get_state(p->context); if (state == PA_CONTEXT_READY) break; if (!PA_CONTEXT_IS_GOOD(state)) { error = pa_context_errno(p->context); goto fail; } pa_mainloop_iterate(p->mainloop, 1, NULL); } if(!startup_get_default_devices(p, device_name)) goto fail; pa_context_set_subscribe_callback(p->context, subscribe_cb, p); pa = pa_context_subscribe(p->context, PA_SUBSCRIPTION_MASK_SERVER, NULL, NULL); if(pa) pa_operation_unref(pa); p->connected = true; return p; fail: if (rerror) *rerror = error; pa_sound_device_free(p); return NULL; } static void pa_sound_device_update_context_status(pa_handle *p) { if(p->connected || !p->context || pa_context_get_state(p->context) != PA_CONTEXT_READY) return; p->connected = true; pa_context_set_subscribe_callback(p->context, subscribe_cb, p); pa_operation *pa = pa_context_subscribe(p->context, PA_SUBSCRIPTION_MASK_SERVER, NULL, NULL); if(pa) pa_operation_unref(pa); } static bool pa_sound_device_handle_context_recreate(pa_handle *p) { if(p->context) { pa_context_disconnect(p->context); pa_context_unref(p->context); p->context = NULL; p->connected = false; } if (!(p->context = pa_context_new_with_proplist(pa_mainloop_get_api(p->mainloop), p->node_name, p->proplist))) { fprintf(stderr, "gsr error: pa_context_new_with_proplist failed\n"); goto fail; } if(pa_context_connect(p->context, nullptr, PA_CONTEXT_NOFLAGS, NULL) < 0) { fprintf(stderr, "gsr error: pa_context_connect failed\n"); goto fail; } pa_mainloop_iterate(p->mainloop, 0, NULL); pa_sound_device_update_context_status(p); return true; fail: if(p->context) { pa_context_disconnect(p->context); pa_context_unref(p->context); p->context = NULL; } return false; } static bool pa_sound_device_should_reconnect(pa_handle *p, double now, char *device_name, size_t device_name_size) { std::lock_guard lock(p->reconnect_mutex); if(!p->reconnect && (!p->stream || !PA_STREAM_IS_GOOD(pa_stream_get_state(p->stream)))) { p->reconnect = true; p->reconnect_last_tried_seconds = now; } if(p->reconnect && now - p->reconnect_last_tried_seconds >= RECONNECT_TRY_TIMEOUT_SECONDS) { p->reconnect_last_tried_seconds = now; // TODO: Size check snprintf(device_name, device_name_size, "%s", p->device_name); return true; } return false; } static bool pa_sound_device_handle_reconnect(pa_handle *p, char *device_name, size_t device_name_size, double now) { if(!pa_sound_device_should_reconnect(p, now, device_name, device_name_size)) return true; if(p->stream) { pa_stream_disconnect(p->stream); pa_stream_unref(p->stream); p->stream = NULL; pa_sound_device_handle_context_recreate(p); if(!p->connected) return false; } pa_proplist *proplist = pa_proplist_new(); // This prevents microphone recording indicator from being shown on KDE pa_proplist_sets(proplist, "node.virtual", "true"); if(!(p->stream = pa_stream_new_with_proplist(p->context, p->stream_name, &p->ss, NULL, proplist))) { //pa_context_errno(p->context); pa_proplist_free(proplist); return false; } pa_proplist_free(proplist); const int r = pa_stream_connect_record(p->stream, device_name, &p->attr, (pa_stream_flags_t)(PA_STREAM_INTERPOLATE_TIMING|PA_STREAM_ADJUST_LATENCY|PA_STREAM_AUTO_TIMING_UPDATE|PA_STREAM_DONT_MOVE)); if(r < 0) { //pa_context_errno(p->context); return false; } pa_mainloop_iterate(p->mainloop, 0, NULL); std::lock_guard lock(p->reconnect_mutex); p->reconnect = false; return true; } static int pa_sound_device_read(pa_handle *p, double timeout_seconds) { assert(p); const double start_time = clock_get_monotonic_seconds(); char device_name[DEVICE_NAME_MAX_SIZE]; bool success = false; int r = 0; int *rerror = &r; pa_usec_t latency = 0; int negative = 0; pa_mainloop_iterate(p->mainloop, 0, NULL); if(!p->context) { if(!pa_sound_device_handle_context_recreate(p)) goto fail; } pa_sound_device_update_context_status(p); if(!p->connected) goto fail; if(!pa_sound_device_handle_reconnect(p, device_name, sizeof(device_name), start_time) || !p->stream) goto fail; if(pa_stream_get_state(p->stream) != PA_STREAM_READY) goto fail; CHECK_DEAD_GOTO(p, rerror, fail); while (p->output_index < p->output_length) { if(clock_get_monotonic_seconds() - start_time >= timeout_seconds) return -1; if(!p->read_data) { pa_mainloop_prepare(p->mainloop, 1 * 1000); // 1 ms pa_mainloop_poll(p->mainloop); pa_mainloop_dispatch(p->mainloop); if(pa_stream_peek(p->stream, &p->read_data, &p->read_length) < 0) goto fail; if(!p->read_data && p->read_length == 0) continue; if(!p->read_data && p->read_length > 0) { // There is a hole in the stream :( drop it. Maybe we should generate silence instead? TODO if(pa_stream_drop(p->stream) != 0) goto fail; continue; } if(p->read_length <= 0) { p->read_data = NULL; if(pa_stream_drop(p->stream) != 0) goto fail; CHECK_DEAD_GOTO(p, rerror, fail); continue; } pa_operation_unref(pa_stream_update_timing_info(p->stream, NULL, NULL)); // TODO: Deal with one pa_stream_peek not being enough. In that case we need to add multiple of these together(?) if(pa_stream_get_latency(p->stream, &latency, &negative) >= 0) { p->latency_seconds = negative ? -(double)latency : latency; if(p->latency_seconds < 0.0) p->latency_seconds = 0.0; p->latency_seconds *= 0.0000001; } } const size_t space_free_in_output_buffer = p->output_length - p->output_index; if(space_free_in_output_buffer < p->read_length) { memcpy(p->output_data + p->output_index, (const uint8_t*)p->read_data + p->read_index, space_free_in_output_buffer); p->output_index = 0; p->read_index += space_free_in_output_buffer; p->read_length -= space_free_in_output_buffer; break; } else { memcpy(p->output_data + p->output_index, (const uint8_t*)p->read_data + p->read_index, p->read_length); p->output_index += p->read_length; p->read_data = NULL; p->read_length = 0; p->read_index = 0; if(pa_stream_drop(p->stream) != 0) goto fail; if(p->output_index == p->output_length) { p->output_index = 0; break; } } } success = true; fail: return success ? 0 : -1; } static pa_sample_format_t audio_format_to_pulse_audio_format(AudioFormat audio_format) { switch(audio_format) { case S16: return PA_SAMPLE_S16LE; case S32: return PA_SAMPLE_S32LE; case F32: return PA_SAMPLE_FLOAT32LE; } assert(false); return PA_SAMPLE_S16LE; } static int audio_format_to_get_bytes_per_sample(AudioFormat audio_format) { switch(audio_format) { case S16: return 2; case S32: return 4; case F32: return 4; } assert(false); return 2; } int sound_device_get_by_name(SoundDevice *device, const char *node_name, const char *device_name, const char *description, unsigned int num_channels, unsigned int period_frame_size, AudioFormat audio_format) { pa_sample_spec ss; ss.format = audio_format_to_pulse_audio_format(audio_format); ss.rate = 48000; ss.channels = num_channels; pa_buffer_attr buffer_attr; buffer_attr.fragsize = period_frame_size * audio_format_to_get_bytes_per_sample(audio_format) * num_channels; // 2/4 bytes/sample, @num_channels channels buffer_attr.tlength = -1; buffer_attr.prebuf = -1; buffer_attr.minreq = -1; buffer_attr.maxlength = buffer_attr.fragsize; int error = 0; pa_handle *handle = pa_sound_device_new(nullptr, node_name, device_name, description, &ss, &buffer_attr, &error); if(!handle) { fprintf(stderr, "gsr error: pa_sound_device_new() failed: %s. Audio input device %s might not be valid\n", pa_strerror(error), device_name); return -1; } device->handle = handle; device->frames = period_frame_size; return 0; } void sound_device_close(SoundDevice *device) { if(device->handle) pa_sound_device_free((pa_handle*)device->handle); device->handle = NULL; } int sound_device_read_next_chunk(SoundDevice *device, void **buffer, double timeout_sec, double *latency_seconds) { pa_handle *pa = (pa_handle*)device->handle; if(pa_sound_device_read(pa, timeout_sec) < 0) { //fprintf(stderr, "pa_simple_read() failed: %s\n", pa_strerror(error)); *latency_seconds = 0.0; return -1; } *buffer = pa->output_data; *latency_seconds = pa->latency_seconds; return device->frames; } static void pa_state_cb(pa_context *c, void *userdata) { pa_context_state state = pa_context_get_state(c); int *pa_ready = (int*)userdata; switch(state) { case PA_CONTEXT_UNCONNECTED: case PA_CONTEXT_CONNECTING: case PA_CONTEXT_AUTHORIZING: case PA_CONTEXT_SETTING_NAME: default: break; case PA_CONTEXT_FAILED: case PA_CONTEXT_TERMINATED: *pa_ready = 2; break; case PA_CONTEXT_READY: *pa_ready = 1; break; } } static void pa_sourcelist_cb(pa_context*, const pa_source_info *source_info, int eol, void *userdata) { if(eol > 0) return; AudioDevices *audio_devices = (AudioDevices*)userdata; audio_devices->audio_inputs.push_back({ source_info->name, source_info->description }); } static void pa_server_info_cb(pa_context*, const pa_server_info *server_info, void *userdata) { AudioDevices *audio_devices = (AudioDevices*)userdata; if(server_info->default_sink_name) audio_devices->default_output = std::string(server_info->default_sink_name) + ".monitor"; if(server_info->default_source_name) audio_devices->default_input = server_info->default_source_name; } static void server_info_callback(pa_context*, const pa_server_info *server_info, void *userdata) { bool *is_server_pipewire = (bool*)userdata; if(server_info->server_name && strstr(server_info->server_name, "PipeWire")) *is_server_pipewire = true; } static void get_pulseaudio_default_inputs(AudioDevices &audio_devices) { int state = 0; int pa_ready = 0; pa_operation *pa_op = NULL; pa_mainloop *main_loop = pa_mainloop_new(); if(!main_loop) return; pa_context *ctx = pa_context_new(pa_mainloop_get_api(main_loop), "gpu-screen-recorder"); if(pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) goto done; pa_context_set_state_callback(ctx, pa_state_cb, &pa_ready); for(;;) { // Not ready if(pa_ready == 0) { pa_mainloop_iterate(main_loop, 1, NULL); continue; } switch(state) { case 0: { pa_op = pa_context_get_server_info(ctx, pa_server_info_cb, &audio_devices); ++state; break; } } // Couldn't get connection to the server if(pa_ready == 2 || (state == 1 && pa_op && pa_operation_get_state(pa_op) == PA_OPERATION_DONE)) break; pa_mainloop_iterate(main_loop, 1, NULL); } done: if(pa_op) pa_operation_unref(pa_op); pa_context_disconnect(ctx); pa_context_unref(ctx); pa_mainloop_free(main_loop); } AudioDevices get_pulseaudio_inputs() { AudioDevices audio_devices; int state = 0; int pa_ready = 0; pa_operation *pa_op = NULL; // TODO: Do this in the same connection below instead of two separate connections get_pulseaudio_default_inputs(audio_devices); pa_mainloop *main_loop = pa_mainloop_new(); if(!main_loop) return audio_devices; pa_context *ctx = pa_context_new(pa_mainloop_get_api(main_loop), "gpu-screen-recorder"); if(pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) goto done; pa_context_set_state_callback(ctx, pa_state_cb, &pa_ready); for(;;) { // Not ready if(pa_ready == 0) { pa_mainloop_iterate(main_loop, 1, NULL); continue; } switch(state) { case 0: { pa_op = pa_context_get_source_info_list(ctx, pa_sourcelist_cb, &audio_devices); ++state; break; } } // Couldn't get connection to the server if(pa_ready == 2 || (state == 1 && pa_op && pa_operation_get_state(pa_op) == PA_OPERATION_DONE)) break; pa_mainloop_iterate(main_loop, 1, NULL); } done: if(pa_op) pa_operation_unref(pa_op); pa_context_disconnect(ctx); pa_context_unref(ctx); pa_mainloop_free(main_loop); return audio_devices; } bool pulseaudio_server_is_pipewire() { int state = 0; int pa_ready = 0; pa_operation *pa_op = NULL; bool is_server_pipewire = false; pa_mainloop *main_loop = pa_mainloop_new(); if(!main_loop) return is_server_pipewire; pa_context *ctx = pa_context_new(pa_mainloop_get_api(main_loop), "gpu-screen-recorder"); if(pa_context_connect(ctx, NULL, PA_CONTEXT_NOFLAGS, NULL) < 0) goto done; pa_context_set_state_callback(ctx, pa_state_cb, &pa_ready); for(;;) { // Not ready if(pa_ready == 0) { pa_mainloop_iterate(main_loop, 1, NULL); continue; } switch(state) { case 0: { pa_op = pa_context_get_server_info(ctx, server_info_callback, &is_server_pipewire); ++state; break; } } // Couldn't get connection to the server if(pa_ready == 2 || (state == 1 && pa_op && pa_operation_get_state(pa_op) == PA_OPERATION_DONE)) break; pa_mainloop_iterate(main_loop, 1, NULL); } done: if(pa_op) pa_operation_unref(pa_op); pa_context_disconnect(ctx); pa_context_unref(ctx); pa_mainloop_free(main_loop); return is_server_pipewire; } fsdsfdsfdsfdsf-5.13.8/src/utils.c000066400000000000000000000576401520215207700167140ustar00rootroot00000000000000#include "../include/utils.h" #include "../include/window/window.h" #include "../include/capture/capture.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DRM_NUM_BUF_ATTRS 4 double clock_get_monotonic_seconds(void) { struct timespec ts; ts.tv_sec = 0; ts.tv_nsec = 0; clock_gettime(CLOCK_MONOTONIC, &ts); return (double)ts.tv_sec + (double)ts.tv_nsec * 0.000000001; } bool generate_random_characters(char *buffer, int buffer_size, const char *alphabet, size_t alphabet_size) { /* TODO: Use other functions on other platforms than linux */ if(getrandom(buffer, buffer_size, 0) < buffer_size) { fprintf(stderr, "Failed to get random bytes, error: %s\n", strerror(errno)); return false; } for(int i = 0; i < buffer_size; ++i) { unsigned char c = *(unsigned char*)&buffer[i]; buffer[i] = alphabet[c % alphabet_size]; } return true; } bool generate_random_characters_standard_alphabet(char *buffer, int buffer_size) { return generate_random_characters(buffer, buffer_size, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", 62); } static const XRRModeInfo* get_mode_info(const XRRScreenResources *sr, RRMode id) { for(int i = 0; i < sr->nmode; ++i) { if(sr->modes[i].id == id) return &sr->modes[i]; } return NULL; } static gsr_monitor_rotation x11_rotation_to_gsr_rotation(int rot) { switch(rot) { case RR_Rotate_0: return GSR_MONITOR_ROT_0; case RR_Rotate_90: return GSR_MONITOR_ROT_90; case RR_Rotate_180: return GSR_MONITOR_ROT_180; case RR_Rotate_270: return GSR_MONITOR_ROT_270; } return GSR_MONITOR_ROT_0; } static uint32_t x11_output_get_connector_id(Display *dpy, RROutput output, Atom randr_connector_id_atom) { Atom type = 0; int format = 0; unsigned long bytes_after = 0; unsigned long nitems = 0; unsigned char *prop = NULL; XRRGetOutputProperty(dpy, output, randr_connector_id_atom, 0, 128, false, false, AnyPropertyType, &type, &format, &nitems, &bytes_after, &prop); long result = 0; if(type == XA_INTEGER && format == 32) result = *(long*)prop; free(prop); return result; } static vec2i get_monitor_size_rotated(int width, int height, gsr_monitor_rotation rotation) { vec2i size = { .x = width, .y = height }; if(rotation == GSR_MONITOR_ROT_90 || rotation == GSR_MONITOR_ROT_270) { int tmp_x = size.x; size.x = size.y; size.y = tmp_x; } return size; } void for_each_active_monitor_output_x11_not_cached(Display *display, active_monitor_callback callback, void *userdata) { XRRScreenResources *screen_res = XRRGetScreenResources(display, DefaultRootWindow(display)); if(!screen_res) return; const Atom randr_connector_id_atom = XInternAtom(display, "CONNECTOR_ID", False); char display_name[256]; for(int i = 0; i < screen_res->noutput; ++i) { XRROutputInfo *out_info = XRRGetOutputInfo(display, screen_res, screen_res->outputs[i]); if(out_info && out_info->crtc && out_info->connection == RR_Connected) { XRRCrtcInfo *crt_info = XRRGetCrtcInfo(display, screen_res, out_info->crtc); if(crt_info && crt_info->mode) { // We want to use the current mode info width/height (mode_info->width/height) instead of crtc info width/height (crt_info->width/height) because crtc info // is scaled if the monitor is scaled (xrandr --output DP-1 --scale 1.5). Normally this is not an issue for x11 applications, // but gpu screen recorder captures the drm framebuffer instead of x11 api. This drm framebuffer which doesn't increase in size when using xrandr scaling. // Maybe a better option would be to get the drm crtc size instead. const XRRModeInfo *mode_info = get_mode_info(screen_res, crt_info->mode); if(mode_info) { snprintf(display_name, sizeof(display_name), "%.*s", (int)out_info->nameLen, out_info->name); const gsr_monitor_rotation rotation = x11_rotation_to_gsr_rotation(crt_info->rotation); const vec2i monitor_size = get_monitor_size_rotated(mode_info->width, mode_info->height, rotation); const gsr_monitor monitor = { .name = display_name, .name_len = out_info->nameLen, .pos = { .x = crt_info->x, .y = crt_info->y }, .size = monitor_size, .logical_pos = { .x = crt_info->x, .y = crt_info->y }, .logical_size = monitor_size, .connector_id = x11_output_get_connector_id(display, screen_res->outputs[i], randr_connector_id_atom), .rotation = rotation, .monitor_identifier = out_info->crtc }; callback(&monitor, userdata); } } if(crt_info) XRRFreeCrtcInfo(crt_info); } if(out_info) XRRFreeOutputInfo(out_info); } XRRFreeScreenResources(screen_res); } /* TODO: Support more connector types */ int get_connector_type_by_name(const char *name) { int len = strlen(name); if(len >= 5 && strncmp(name, "HDMI-", 5) == 0) return 1; else if(len >= 3 && strncmp(name, "DP-", 3) == 0) return 2; else if(len >= 12 && strncmp(name, "DisplayPort-", 12) == 0) return 3; else if(len >= 4 && strncmp(name, "eDP-", 4) == 0) return 4; else if(len >= 4 && strncmp(name, "DVI-", 4) == 0) return 5; else return -1; } int get_connector_type_id_by_name(const char *name) { int len = strlen(name); int num_start = 0; for(int i = len - 1; i >= 0; --i) { const bool is_num = name[i] >= '0' && name[i] <= '9'; if(!is_num) { num_start = i + 1; break; } } const int num_len = len - num_start; if(num_len <= 0) return -1; return atoi(name + num_start); } uint32_t monitor_identifier_from_type_and_count(int monitor_type_index, int monitor_type_count) { return ((uint32_t)monitor_type_index << 16) | ((uint32_t)monitor_type_count); } static bool connector_get_property_by_name(int drmfd, drmModeConnectorPtr props, const char *name, uint64_t *result) { for(int i = 0; i < props->count_props; ++i) { drmModePropertyPtr prop = drmModeGetProperty(drmfd, props->props[i]); if(prop) { if(strcmp(name, prop->name) == 0) { *result = props->prop_values[i]; drmModeFreeProperty(prop); return true; } drmModeFreeProperty(prop); } } return false; } static void for_each_active_monitor_output_drm(const char *card_path, active_monitor_callback callback, void *userdata) { int fd = open(card_path, O_RDONLY); if(fd == -1) { fprintf(stderr, "gsr error: for_each_active_monitor_output_drm failed, failed to open \"%s\", error: %s\n", card_path, strerror(errno)); return; } drmSetClientCap(fd, DRM_CLIENT_CAP_ATOMIC, 1); char display_name[256]; drmModeResPtr resources = drmModeGetResources(fd); if(resources) { for(int i = 0; i < resources->count_connectors; ++i) { drmModeConnectorPtr connector = drmModeGetConnectorCurrent(fd, resources->connectors[i]); if(!connector) continue; if(connector->connection != DRM_MODE_CONNECTED) { drmModeFreeConnector(connector); continue; } uint64_t crtc_id = 0; connector_get_property_by_name(fd, connector, "CRTC_ID", &crtc_id); drmModeCrtcPtr crtc = drmModeGetCrtc(fd, crtc_id); const char *connection_name = drmModeGetConnectorTypeName(connector->connector_type); if(connection_name && crtc_id > 0 && crtc) { const int connector_type_index_name = get_connector_type_by_name(display_name); const int display_name_len = snprintf(display_name, sizeof(display_name), "%s-%u", connection_name, connector->connector_type_id); const gsr_monitor monitor = { .name = display_name, .name_len = display_name_len, .pos = { .x = crtc->x, .y = crtc->y }, .size = { .x = (int)crtc->width, .y = (int)crtc->height }, .logical_pos = { .x = crtc->x, .y = crtc->y }, .logical_size = { .x = (int)crtc->width, .y = (int)crtc->height }, .connector_id = connector->connector_id, .rotation = GSR_MONITOR_ROT_0, .monitor_identifier = connector_type_index_name != -1 ? monitor_identifier_from_type_and_count(connector_type_index_name, connector->connector_type_id) : 0 }; callback(&monitor, userdata); } if(crtc) drmModeFreeCrtc(crtc); drmModeFreeConnector(connector); } drmModeFreeResources(resources); } close(fd); } void for_each_active_monitor_output(const gsr_window *window, const char *card_path, gsr_connection_type connection_type, active_monitor_callback callback, void *userdata) { switch(connection_type) { case GSR_CONNECTION_X11: case GSR_CONNECTION_WAYLAND: gsr_window_for_each_active_monitor_output_cached(window, callback, userdata); break; case GSR_CONNECTION_DRM: for_each_active_monitor_output_drm(card_path, callback, userdata); break; } } static void get_monitor_by_name_callback(const gsr_monitor *monitor, void *userdata) { get_monitor_by_name_userdata *data = (get_monitor_by_name_userdata*)userdata; if(!data->found_monitor && strcmp(data->name, monitor->name) == 0) { data->monitor->pos = monitor->pos; data->monitor->size = monitor->size; data->monitor->logical_pos = monitor->logical_pos; data->monitor->logical_size = monitor->logical_size; data->monitor->connector_id = monitor->connector_id; data->monitor->rotation = monitor->rotation; data->monitor->monitor_identifier = monitor->monitor_identifier; data->found_monitor = true; } } bool get_monitor_by_name(const gsr_egl *egl, gsr_connection_type connection_type, const char *name, gsr_monitor *monitor) { get_monitor_by_name_userdata userdata; userdata.name = name; userdata.name_len = strlen(name); userdata.monitor = monitor; userdata.found_monitor = false; for_each_active_monitor_output(egl->window, egl->card_path, connection_type, get_monitor_by_name_callback, &userdata); return userdata.found_monitor; } typedef struct { const gsr_monitor *monitor; gsr_monitor_rotation rotation; vec2i position; bool match_found; } get_monitor_by_connector_id_userdata; static void get_monitor_by_name_wayland_callback(const gsr_monitor *monitor, void *userdata) { get_monitor_by_connector_id_userdata *data = (get_monitor_by_connector_id_userdata*)userdata; if(monitor->name && data->monitor->name && strcmp(monitor->name, data->monitor->name) == 0) { data->rotation = monitor->rotation; data->position = monitor->pos; data->match_found = true; } } static void get_monitor_by_connector_id_callback(const gsr_monitor *monitor, void *userdata) { get_monitor_by_connector_id_userdata *data = (get_monitor_by_connector_id_userdata*)userdata; if(monitor->connector_id == data->monitor->connector_id || (!monitor->connector_id && monitor->monitor_identifier == data->monitor->monitor_identifier)) { data->rotation = monitor->rotation; data->position = monitor->pos; data->match_found = true; } } bool drm_monitor_get_display_server_data(const gsr_window *window, const gsr_monitor *monitor, gsr_monitor_rotation *monitor_rotation, vec2i *monitor_position) { *monitor_rotation = GSR_MONITOR_ROT_0; *monitor_position = (vec2i){0, 0}; if(gsr_window_get_display_server(window) == GSR_DISPLAY_SERVER_WAYLAND) { { get_monitor_by_connector_id_userdata userdata; userdata.monitor = monitor; userdata.rotation = GSR_MONITOR_ROT_0; userdata.position = (vec2i){0, 0}; userdata.match_found = false; gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_name_wayland_callback, &userdata); if(userdata.match_found) { *monitor_rotation = userdata.rotation; *monitor_position = userdata.position; return true; } } { get_monitor_by_connector_id_userdata userdata; userdata.monitor = monitor; userdata.rotation = GSR_MONITOR_ROT_0; userdata.position = (vec2i){0, 0}; userdata.match_found = false; gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_connector_id_callback, &userdata); *monitor_rotation = userdata.rotation; *monitor_position = userdata.position; return userdata.match_found; } } else { get_monitor_by_connector_id_userdata userdata; userdata.monitor = monitor; userdata.rotation = GSR_MONITOR_ROT_0; userdata.position = (vec2i){0, 0}; userdata.match_found = false; gsr_window_for_each_active_monitor_output_cached(window, get_monitor_by_connector_id_callback, &userdata); *monitor_rotation = userdata.rotation; *monitor_position = userdata.position; return userdata.match_found; } } bool gl_get_gpu_info(gsr_egl *egl, gsr_gpu_info *info) { const char *software_renderers[] = { "llvmpipe", "SWR", "softpipe", NULL }; bool supported = true; const unsigned char *gl_vendor = egl->glGetString(GL_VENDOR); const unsigned char *gl_renderer = egl->glGetString(GL_RENDERER); info->gpu_version = 0; info->is_steam_deck = false; if(!gl_vendor) { fprintf(stderr, "gsr error: failed to get gpu vendor\n"); supported = false; goto end; } if(gl_renderer) { for(int i = 0; software_renderers[i]; ++i) { if(strstr((const char*)gl_renderer, software_renderers[i])) { fprintf(stderr, "gsr error: your opengl environment is not properly setup. It's using %s (software rendering) for opengl instead of your graphics card. Please make sure your graphics driver is properly installed\n", software_renderers[i]); supported = false; goto end; } } } if(strstr((const char*)gl_vendor, "AMD")) info->vendor = GSR_GPU_VENDOR_AMD; else if(strstr((const char*)gl_vendor, "Mesa") && gl_renderer && strstr((const char*)gl_renderer, "AMD")) info->vendor = GSR_GPU_VENDOR_AMD; else if(strstr((const char*)gl_vendor, "Intel")) info->vendor = GSR_GPU_VENDOR_INTEL; else if(strstr((const char*)gl_vendor, "NVIDIA")) info->vendor = GSR_GPU_VENDOR_NVIDIA; else if(strstr((const char*)gl_vendor, "Broadcom")) info->vendor = GSR_GPU_VENDOR_BROADCOM; else { fprintf(stderr, "gsr error: unknown gpu vendor: %s\n", gl_vendor); supported = false; goto end; } if(gl_renderer) { if(info->vendor == GSR_GPU_VENDOR_NVIDIA) sscanf((const char*)gl_renderer, "%*s %*s %*s %d", &info->gpu_version); info->is_steam_deck = strstr((const char*)gl_renderer, "vangogh") != NULL; } end: return supported; } bool try_card_has_valid_plane(const char *card_path) { drmVersion *ver = NULL; drmModePlaneResPtr planes = NULL; bool found_screen_card = false; int fd = open(card_path, O_RDONLY); if(fd == -1) return false; ver = drmGetVersion(fd); if(!ver || strstr(ver->name, "nouveau")) goto next; drmSetClientCap(fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1); planes = drmModeGetPlaneResources(fd); if(!planes) goto next; for(uint32_t j = 0; j < planes->count_planes; ++j) { drmModePlanePtr plane = drmModeGetPlane(fd, planes->planes[j]); if(!plane) continue; if(plane->fb_id) found_screen_card = true; drmModeFreePlane(plane); if(found_screen_card) break; } next: if(planes) drmModeFreePlaneResources(planes); if(ver) drmFreeVersion(ver); close(fd); if(found_screen_card) return true; return false; } bool gsr_get_valid_card_path(gsr_egl *egl, char *output, bool is_monitor_capture) { if(egl->dri_card_path) { snprintf(output, 128, "%s", egl->dri_card_path); return is_monitor_capture ? try_card_has_valid_plane(output) : true; } for(int i = 0; i < 10; ++i) { snprintf(output, 128, DRM_DEV_NAME, DRM_DIR_NAME, i); if(try_card_has_valid_plane(output)) return true; } return false; } bool gsr_card_path_get_render_path(const char *card_path, char *render_path) { int fd = open(card_path, O_RDONLY); if(fd == -1) return false; char *render_path_tmp = drmGetRenderDeviceNameFromFd(fd); if(render_path_tmp) { snprintf(render_path, 128, "%s", render_path_tmp); free(render_path_tmp); close(fd); return true; } close(fd); return false; } int create_directory_recursive(char *path) { int path_len = strlen(path); char *p = path; char *end = path + path_len; for(;;) { char *slash_p = strchr(p, '/'); // Skips first '/', we don't want to try and create the root directory if(slash_p == path) { ++p; continue; } if(!slash_p) slash_p = end; char prev_char = *slash_p; *slash_p = '\0'; int err = mkdir(path, S_IRWXU); *slash_p = prev_char; if(err == -1 && errno != EEXIST) return err; if(slash_p == end) break; else p = slash_p + 1; } return 0; } void setup_dma_buf_attrs(intptr_t *img_attr, uint32_t format, uint32_t width, uint32_t height, const int *fds, const uint32_t *offsets, const uint32_t *pitches, const uint64_t *modifiers, int num_planes, bool use_modifier) { const uint32_t plane_fd_attrs[DRM_NUM_BUF_ATTRS] = { EGL_DMA_BUF_PLANE0_FD_EXT, EGL_DMA_BUF_PLANE1_FD_EXT, EGL_DMA_BUF_PLANE2_FD_EXT, EGL_DMA_BUF_PLANE3_FD_EXT }; const uint32_t plane_offset_attrs[DRM_NUM_BUF_ATTRS] = { EGL_DMA_BUF_PLANE0_OFFSET_EXT, EGL_DMA_BUF_PLANE1_OFFSET_EXT, EGL_DMA_BUF_PLANE2_OFFSET_EXT, EGL_DMA_BUF_PLANE3_OFFSET_EXT }; const uint32_t plane_pitch_attrs[DRM_NUM_BUF_ATTRS] = { EGL_DMA_BUF_PLANE0_PITCH_EXT, EGL_DMA_BUF_PLANE1_PITCH_EXT, EGL_DMA_BUF_PLANE2_PITCH_EXT, EGL_DMA_BUF_PLANE3_PITCH_EXT }; const uint32_t plane_modifier_lo_attrs[DRM_NUM_BUF_ATTRS] = { EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT, EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT, EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT, EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT }; const uint32_t plane_modifier_hi_attrs[DRM_NUM_BUF_ATTRS] = { EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT, EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT, EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT, EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT }; size_t img_attr_index = 0; img_attr[img_attr_index++] = EGL_LINUX_DRM_FOURCC_EXT; img_attr[img_attr_index++] = format; img_attr[img_attr_index++] = EGL_WIDTH; img_attr[img_attr_index++] = width; img_attr[img_attr_index++] = EGL_HEIGHT; img_attr[img_attr_index++] = height; assert(num_planes <= DRM_NUM_BUF_ATTRS); for(int i = 0; i < num_planes; ++i) { img_attr[img_attr_index++] = plane_fd_attrs[i]; img_attr[img_attr_index++] = fds[i]; img_attr[img_attr_index++] = plane_offset_attrs[i]; img_attr[img_attr_index++] = offsets[i]; img_attr[img_attr_index++] = plane_pitch_attrs[i]; img_attr[img_attr_index++] = pitches[i]; if(use_modifier) { img_attr[img_attr_index++] = plane_modifier_lo_attrs[i]; img_attr[img_attr_index++] = modifiers[i] & 0xFFFFFFFFULL; img_attr[img_attr_index++] = plane_modifier_hi_attrs[i]; img_attr[img_attr_index++] = modifiers[i] >> 32ULL; } } img_attr[img_attr_index++] = EGL_NONE; assert(img_attr_index <= 44); } vec2i scale_keep_aspect_ratio(vec2i from, vec2i to) { if(from.x == 0 || from.y == 0) return (vec2i){0, 0}; const double height_to_width_ratio = (double)from.y / (double)from.x; from.x = to.x; from.y = from.x * height_to_width_ratio; if(from.y > to.y) { const double width_height_ratio = (double)from.x / (double)from.y; from.y = to.y; from.x = from.y * width_height_ratio; } return from; } vec2i gsr_capture_get_target_position(vec2i output_size, gsr_capture_metadata *capture_metadata) { vec2i target_pos = {0, 0}; switch(capture_metadata->halign) { case GSR_CAPTURE_ALIGN_START: break; case GSR_CAPTURE_ALIGN_CENTER: target_pos.x = capture_metadata->video_size.x/2 - output_size.x/2; break; case GSR_CAPTURE_ALIGN_END: target_pos.x = capture_metadata->video_size.x - output_size.x; break; } switch(capture_metadata->valign) { case GSR_CAPTURE_ALIGN_START: break; case GSR_CAPTURE_ALIGN_CENTER: target_pos.y = capture_metadata->video_size.y/2 - output_size.y/2; break; case GSR_CAPTURE_ALIGN_END: target_pos.y = capture_metadata->video_size.y - output_size.y; break; } target_pos.x += capture_metadata->position.x; target_pos.y += capture_metadata->position.y; return target_pos; } unsigned int gl_create_texture(gsr_egl *egl, int width, int height, int internal_format, unsigned int format, int filter) { unsigned int texture_id = 0; egl->glGenTextures(1, &texture_id); egl->glBindTexture(GL_TEXTURE_2D, texture_id); //egl->glTexImage2D(GL_TEXTURE_2D, 0, internal_format, width, height, 0, format, GL_UNSIGNED_BYTE, NULL); // Needed for hevc_10bit for nvenc (cuGraphicsGLRegisterImage) egl->glTexStorage2D(GL_TEXTURE_2D, 1, internal_format, width, height); egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter); egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter); egl->glBindTexture(GL_TEXTURE_2D, 0); return texture_id; } /* TODO: Test with optimus and open kernel modules */ bool get_nvidia_driver_version(int *major, int *minor) { *major = 0; *minor = 0; FILE *f = fopen("/proc/driver/nvidia/version", "rb"); if(!f) { fprintf(stderr, "gsr warning: failed to get nvidia driver version (failed to read /proc/driver/nvidia/version)\n"); return false; } char buffer[2048]; size_t bytes_read = fread(buffer, 1, sizeof(buffer) - 1, f); buffer[bytes_read] = '\0'; bool success = false; const char *p = strstr(buffer, "Kernel Module"); if(p) { p += 13; int driver_major_version = 0, driver_minor_version = 0; if(sscanf(p, "%d.%d", &driver_major_version, &driver_minor_version) == 2) { *major = driver_major_version; *minor = driver_minor_version; success = true; } } if(!success) fprintf(stderr, "gsr warning: failed to get nvidia driver version\n"); fclose(f); return success; } fsdsfdsfdsfdsf-5.13.8/src/window/000077500000000000000000000000001520215207700167035ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/src/window/wayland.c000066400000000000000000000352241520215207700205140ustar00rootroot00000000000000#include "../../include/window/wayland.h" #include "../../include/vec2.h" #include "../../include/defs.h" #include #include #include #include #include #include #include "xdg-output-unstable-v1-client-protocol.h" #define GSR_MAX_OUTPUTS 32 typedef struct gsr_window_wayland gsr_window_wayland; typedef struct { uint32_t wl_name; struct wl_output *output; struct zxdg_output_v1 *xdg_output; vec2i pos; vec2i size; vec2i logical_size; int32_t transform; char *name; } gsr_wayland_output; struct gsr_window_wayland { struct wl_display *display; struct wl_egl_window *window; struct wl_registry *registry; struct wl_surface *surface; struct wl_compositor *compositor; gsr_wayland_output outputs[GSR_MAX_OUTPUTS]; int num_outputs; struct zxdg_output_manager_v1 *xdg_output_manager; }; static void output_handle_geometry(void *data, struct wl_output *wl_output, int32_t x, int32_t y, int32_t phys_width, int32_t phys_height, int32_t subpixel, const char *make, const char *model, int32_t transform) { (void)wl_output; (void)phys_width; (void)phys_height; (void)subpixel; (void)make; (void)model; gsr_wayland_output *gsr_output = data; gsr_output->pos.x = x; gsr_output->pos.y = y; gsr_output->transform = transform; } static void output_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int32_t width, int32_t height, int32_t refresh) { (void)wl_output; (void)flags; (void)refresh; gsr_wayland_output *gsr_output = data; gsr_output->size.x = width; gsr_output->size.y = height; } static void output_handle_done(void *data, struct wl_output *wl_output) { (void)data; (void)wl_output; } static void output_handle_scale(void* data, struct wl_output *wl_output, int32_t factor) { (void)data; (void)wl_output; (void)factor; } static void output_handle_name(void *data, struct wl_output *wl_output, const char *name) { (void)wl_output; gsr_wayland_output *gsr_output = data; if(gsr_output->name) { free(gsr_output->name); gsr_output->name = NULL; } gsr_output->name = strdup(name); } static void output_handle_description(void *data, struct wl_output *wl_output, const char *description) { (void)data; (void)wl_output; (void)description; } static const struct wl_output_listener output_listener = { .geometry = output_handle_geometry, .mode = output_handle_mode, .done = output_handle_done, .scale = output_handle_scale, .name = output_handle_name, .description = output_handle_description, }; static void registry_add_object(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) { (void)version; gsr_window_wayland *window_wayland = data; if(strcmp(interface, "wl_compositor") == 0) { if(window_wayland->compositor) return; window_wayland->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 1); } else if(strcmp(interface, wl_output_interface.name) == 0) { if(version < 4) { fprintf(stderr, "gsr warning: wl output interface version is < 4, expected >= 4 to capture a monitor\n"); return; } if(window_wayland->num_outputs == GSR_MAX_OUTPUTS) { fprintf(stderr, "gsr warning: reached maximum outputs (%d), ignoring output %u\n", GSR_MAX_OUTPUTS, name); return; } gsr_wayland_output *gsr_output = &window_wayland->outputs[window_wayland->num_outputs]; window_wayland->num_outputs++; *gsr_output = (gsr_wayland_output) { .wl_name = name, .output = wl_registry_bind(registry, name, &wl_output_interface, 4), .pos = { .x = 0, .y = 0 }, .size = { .x = 0, .y = 0 }, .logical_size = { .x = 0, .y = 0 }, .transform = 0, .name = NULL, }; wl_output_add_listener(gsr_output->output, &output_listener, gsr_output); } else if(strcmp(interface, zxdg_output_manager_v1_interface.name) == 0) { if(version < 1) { fprintf(stderr, "gsr warning: xdg output interface version is < 1, expected >= 1 to capture a monitor\n"); return; } if(window_wayland->xdg_output_manager) return; window_wayland->xdg_output_manager = wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface, 1); } } static void registry_remove_object(void *data, struct wl_registry *registry, uint32_t name) { (void)data; (void)registry; (void)name; // TODO: Remove output } static struct wl_registry_listener registry_listener = { .global = registry_add_object, .global_remove = registry_remove_object, }; static void xdg_output_logical_position(void *data, struct zxdg_output_v1 *zxdg_output_v1, int32_t x, int32_t y) { (void)zxdg_output_v1; gsr_wayland_output *gsr_xdg_output = data; gsr_xdg_output->pos.x = x; gsr_xdg_output->pos.y = y; } static void xdg_output_handle_logical_size(void *data, struct zxdg_output_v1 *xdg_output, int32_t width, int32_t height) { (void)xdg_output; gsr_wayland_output *gsr_xdg_output = data; gsr_xdg_output->logical_size.x = width; gsr_xdg_output->logical_size.y = height; } static void xdg_output_handle_done(void *data, struct zxdg_output_v1 *xdg_output) { (void)data; (void)xdg_output; } static void xdg_output_handle_name(void *data, struct zxdg_output_v1 *xdg_output, const char *name) { (void)data; (void)xdg_output; (void)name; } static void xdg_output_handle_description(void *data, struct zxdg_output_v1 *xdg_output, const char *description) { (void)data; (void)xdg_output; (void)description; } static const struct zxdg_output_v1_listener xdg_output_listener = { .logical_position = xdg_output_logical_position, .logical_size = xdg_output_handle_logical_size, .done = xdg_output_handle_done, .name = xdg_output_handle_name, .description = xdg_output_handle_description, }; static void gsr_window_wayland_set_monitor_outputs_from_xdg_output(gsr_window_wayland *self) { if(!self->xdg_output_manager) { fprintf(stderr, "gsr warning: zxdg_output_manager not found. registered monitor positions might be incorrect\n"); return; } for(int i = 0; i < self->num_outputs; ++i) { self->outputs[i].xdg_output = zxdg_output_manager_v1_get_xdg_output(self->xdg_output_manager, self->outputs[i].output); zxdg_output_v1_add_listener(self->outputs[i].xdg_output, &xdg_output_listener, &self->outputs[i]); } // Fetch xdg_output wl_display_roundtrip(self->display); } // static int monitor_sort_x_pos(const void* a, const void* b) { // const gsr_wayland_output *arg1 = *(const gsr_wayland_output**)a; // const gsr_wayland_output *arg2 = *(const gsr_wayland_output**)b; // return arg1->logical_pos.x - arg2->logical_pos.x; // } // static int monitor_sort_y_pos(const void* a, const void* b) { // const gsr_wayland_output *arg1 = *(const gsr_wayland_output**)a; // const gsr_wayland_output *arg2 = *(const gsr_wayland_output**)b; // return arg1->logical_pos.y - arg2->logical_pos.y; // } static void gsr_window_wayland_set_monitor_real_positions(gsr_window_wayland *self) { gsr_wayland_output *sorted_outputs[GSR_MAX_OUTPUTS]; for(int i = 0; i < self->num_outputs; ++i) { sorted_outputs[i] = &self->outputs[i]; } // TODO: set correct physical positions // qsort(sorted_outputs, self->num_outputs, sizeof(gsr_wayland_output*), monitor_sort_x_pos); // int x_pos = 0; // for(int i = 0; i < self->num_outputs; ++i) { // fprintf(stderr, "monitor: %s\n", sorted_outputs[i]->name); // sorted_outputs[i]->pos.x = x_pos; // x_pos += sorted_outputs[i]->logical_size.x; // } // qsort(sorted_outputs, self->num_outputs, sizeof(gsr_wayland_output*), monitor_sort_y_pos); // int y_pos = 0; // for(int i = 0; i < self->num_outputs; ++i) { // sorted_outputs[i]->pos.y = y_pos; // y_pos += sorted_outputs[i]->logical_size.y; // } } static void gsr_window_wayland_deinit(gsr_window_wayland *self) { if(self->window) { wl_egl_window_destroy(self->window); self->window = NULL; } if(self->surface) { wl_surface_destroy(self->surface); self->surface = NULL; } for(int i = 0; i < self->num_outputs; ++i) { if(self->outputs[i].output) { wl_output_destroy(self->outputs[i].output); self->outputs[i].output = NULL; } if(self->outputs[i].name) { free(self->outputs[i].name); self->outputs[i].name = NULL; } if(self->outputs[i].xdg_output) { zxdg_output_v1_destroy(self->outputs[i].xdg_output); self->outputs[i].output = NULL; } } self->num_outputs = 0; if(self->xdg_output_manager) { zxdg_output_manager_v1_destroy(self->xdg_output_manager); self->xdg_output_manager = NULL; } if(self->compositor) { wl_compositor_destroy(self->compositor); self->compositor = NULL; } if(self->registry) { wl_registry_destroy(self->registry); self->registry = NULL; } if(self->display) { wl_display_disconnect(self->display); self->display = NULL; } } static bool gsr_window_wayland_init(gsr_window_wayland *self) { self->display = wl_display_connect(NULL); if(!self->display) { fprintf(stderr, "gsr error: gsr_window_wayland_init failed: failed to connect to the Wayland server\n"); goto fail; } self->registry = wl_display_get_registry(self->display); // TODO: Error checking wl_registry_add_listener(self->registry, ®istry_listener, self); // TODO: Error checking // Fetch globals wl_display_roundtrip(self->display); // Fetch wl_output wl_display_roundtrip(self->display); gsr_window_wayland_set_monitor_outputs_from_xdg_output(self); gsr_window_wayland_set_monitor_real_positions(self); if(!self->compositor) { fprintf(stderr, "gsr error: gsr_window_wayland_init failed: failed to find compositor\n"); goto fail; } self->surface = wl_compositor_create_surface(self->compositor); if(!self->surface) { fprintf(stderr, "gsr error: gsr_window_wayland_init failed: failed to create surface\n"); goto fail; } self->window = wl_egl_window_create(self->surface, 16, 16); if(!self->window) { fprintf(stderr, "gsr error: gsr_window_wayland_init failed: failed to create window\n"); goto fail; } return true; fail: gsr_window_wayland_deinit(self); return false; } static void gsr_window_wayland_destroy(gsr_window *window) { gsr_window_wayland *self = window->priv; gsr_window_wayland_deinit(self); free(self); free(window); } static bool gsr_window_wayland_process_event(gsr_window *window) { gsr_window_wayland *self = window->priv; // TODO: pselect on wl_display_get_fd before doing dispatch const bool events_available = wl_display_dispatch_pending(self->display) > 0; wl_display_flush(self->display); return events_available; } static gsr_display_server gsr_wayland_get_display_server(void) { return GSR_DISPLAY_SERVER_WAYLAND; } static void* gsr_window_wayland_get_display(gsr_window *window) { gsr_window_wayland *self = window->priv; return self->display; } static void* gsr_window_wayland_get_window(gsr_window *window) { gsr_window_wayland *self = window->priv; return self->window; } static gsr_monitor_rotation wayland_transform_to_gsr_rotation(int32_t rot) { switch(rot) { case 0: return GSR_MONITOR_ROT_0; case 1: return GSR_MONITOR_ROT_90; case 2: return GSR_MONITOR_ROT_180; case 3: return GSR_MONITOR_ROT_270; } return GSR_MONITOR_ROT_0; } static vec2i get_monitor_size_rotated(int width, int height, gsr_monitor_rotation rotation) { vec2i size = { .x = width, .y = height }; if(rotation == GSR_MONITOR_ROT_90 || rotation == GSR_MONITOR_ROT_270) { int tmp_x = size.x; size.x = size.y; size.y = tmp_x; } return size; } static void gsr_window_wayland_for_each_active_monitor_output_cached(const gsr_window *window, active_monitor_callback callback, void *userdata) { const gsr_window_wayland *self = window->priv; for(int i = 0; i < self->num_outputs; ++i) { const gsr_wayland_output *output = &self->outputs[i]; if(!output->name) continue; const gsr_monitor_rotation rotation = wayland_transform_to_gsr_rotation(output->transform); vec2i size = { .x = output->size.x, .y = output->size.y }; size = get_monitor_size_rotated(size.x, size.y, rotation); vec2i logical_size = { .x = output->logical_size.x, .y = output->logical_size.y }; if(logical_size.x == 0 || logical_size.y == 0) logical_size = size; const int connector_type_index = get_connector_type_by_name(output->name); const int connector_type_id = get_connector_type_id_by_name(output->name); const gsr_monitor monitor = { .name = output->name, .name_len = strlen(output->name), .pos = { .x = output->pos.x, .y = output->pos.y }, .size = size, .logical_pos = { .x = output->pos.x, .y = output->pos.y }, .logical_size = logical_size, .connector_id = 0, .rotation = rotation, .monitor_identifier = (connector_type_index != -1 && connector_type_id != -1) ? monitor_identifier_from_type_and_count(connector_type_index, connector_type_id) : 0 }; callback(&monitor, userdata); } } gsr_window* gsr_window_wayland_create(void) { gsr_window *window = calloc(1, sizeof(gsr_window)); if(!window) return window; gsr_window_wayland *window_wayland = calloc(1, sizeof(gsr_window_wayland)); if(!window_wayland) { free(window); return NULL; } if(!gsr_window_wayland_init(window_wayland)) { free(window_wayland); free(window); return NULL; } *window = (gsr_window) { .destroy = gsr_window_wayland_destroy, .process_event = gsr_window_wayland_process_event, .get_event_data = NULL, .get_display_server = gsr_wayland_get_display_server, .get_display = gsr_window_wayland_get_display, .get_window = gsr_window_wayland_get_window, .for_each_active_monitor_output_cached = gsr_window_wayland_for_each_active_monitor_output_cached, .priv = window_wayland }; return window; } fsdsfdsfdsfdsf-5.13.8/src/window/window.c000066400000000000000000000015111520215207700203540ustar00rootroot00000000000000#include "../../include/window/window.h" #include void gsr_window_destroy(gsr_window *self); bool gsr_window_process_event(gsr_window *self) { return self->process_event(self); } XEvent* gsr_window_get_event_data(gsr_window *self) { if(self->get_event_data) return self->get_event_data(self); return NULL; } gsr_display_server gsr_window_get_display_server(const gsr_window *self) { return self->get_display_server(); } void* gsr_window_get_display(gsr_window *self) { return self->get_display(self); } void* gsr_window_get_window(gsr_window *self) { return self->get_window(self); } void gsr_window_for_each_active_monitor_output_cached(const gsr_window *self, active_monitor_callback callback, void *userdata) { self->for_each_active_monitor_output_cached(self, callback, userdata); } fsdsfdsfdsfdsf-5.13.8/src/window/x11.c000066400000000000000000000115751520215207700174710ustar00rootroot00000000000000#include "../../include/window/x11.h" #include "../../include/vec2.h" #include "../../include/defs.h" #include "../../include/utils.h" #include #include #include #include #include #define GSR_MAX_OUTPUTS 32 typedef struct { char *name; vec2i pos; vec2i size; uint32_t connector_id; gsr_monitor_rotation rotation; uint32_t monitor_identifier; /* crtc id */ } gsr_x11_output; typedef struct { Display *display; Window window; gsr_x11_output outputs[GSR_MAX_OUTPUTS]; int num_outputs; XEvent xev; } gsr_window_x11; static void store_x11_monitor(const gsr_monitor *monitor, void *userdata) { gsr_window_x11 *window_x11 = userdata; if(window_x11->num_outputs == GSR_MAX_OUTPUTS) { fprintf(stderr, "gsr warning: reached maximum outputs (%d), ignoring output %s\n", GSR_MAX_OUTPUTS, monitor->name); return; } char *monitor_name = strdup(monitor->name); if(!monitor_name) return; const int index = window_x11->num_outputs; window_x11->outputs[index].name = monitor_name; window_x11->outputs[index].pos = monitor->pos; window_x11->outputs[index].size = monitor->size; window_x11->outputs[index].connector_id = monitor->connector_id; window_x11->outputs[index].rotation = monitor->rotation; window_x11->outputs[index].monitor_identifier = monitor->monitor_identifier; ++window_x11->num_outputs; } static void gsr_window_x11_deinit(gsr_window_x11 *self) { if(self->window) { XDestroyWindow(self->display, self->window); self->window = None; } for(int i = 0; i < self->num_outputs; ++i) { if(self->outputs[i].name) { free(self->outputs[i].name); self->outputs[i].name = NULL; } } self->num_outputs = 0; } static bool gsr_window_x11_init(gsr_window_x11 *self) { self->window = XCreateWindow(self->display, DefaultRootWindow(self->display), 0, 0, 16, 16, 0, CopyFromParent, InputOutput, CopyFromParent, 0, NULL); if(!self->window) { fprintf(stderr, "gsr error: gsr_window_x11_init failed: failed to create gl window\n"); return false; } self->num_outputs = 0; for_each_active_monitor_output_x11_not_cached(self->display, store_x11_monitor, self); return true; } static void gsr_window_x11_destroy(gsr_window *window) { gsr_window_x11 *self = window->priv; gsr_window_x11_deinit(self); free(self); free(window); } static bool gsr_window_x11_process_event(gsr_window *window) { gsr_window_x11 *self = window->priv; if(XPending(self->display)) { XNextEvent(self->display, &self->xev); return true; } return false; } static XEvent* gsr_window_x11_get_event_data(gsr_window *window) { gsr_window_x11 *self = window->priv; return &self->xev; } static gsr_display_server gsr_window_x11_get_display_server(void) { return GSR_DISPLAY_SERVER_X11; } static void* gsr_window_x11_get_display(gsr_window *window) { gsr_window_x11 *self = window->priv; return self->display; } static void* gsr_window_x11_get_window(gsr_window *window) { gsr_window_x11 *self = window->priv; return (void*)self->window; } static void gsr_window_x11_for_each_active_monitor_output_cached(const gsr_window *window, active_monitor_callback callback, void *userdata) { const gsr_window_x11 *self = window->priv; for(int i = 0; i < self->num_outputs; ++i) { const gsr_x11_output *output = &self->outputs[i]; const gsr_monitor monitor = { .name = output->name, .name_len = strlen(output->name), .pos = output->pos, .size = output->size, .logical_pos = output->pos, .logical_size = output->size, .connector_id = output->connector_id, .rotation = output->rotation, .monitor_identifier = output->monitor_identifier }; callback(&monitor, userdata); } } gsr_window* gsr_window_x11_create(Display *display) { gsr_window *window = calloc(1, sizeof(gsr_window)); if(!window) return window; gsr_window_x11 *window_x11 = calloc(1, sizeof(gsr_window_x11)); if(!window_x11) { free(window); return NULL; } window_x11->display = display; if(!gsr_window_x11_init(window_x11)) { free(window_x11); free(window); return NULL; } *window = (gsr_window) { .destroy = gsr_window_x11_destroy, .process_event = gsr_window_x11_process_event, .get_event_data = gsr_window_x11_get_event_data, .get_display_server = gsr_window_x11_get_display_server, .get_display = gsr_window_x11_get_display, .get_window = gsr_window_x11_get_window, .for_each_active_monitor_output_cached = gsr_window_x11_for_each_active_monitor_output_cached, .priv = window_x11 }; return window; } fsdsfdsfdsfdsf-5.13.8/src/window_texture.c000066400000000000000000000100171520215207700206260ustar00rootroot00000000000000#include "../include/window_texture.h" #include static int x11_supports_composite_named_window_pixmap(Display *display) { int extension_major; int extension_minor; if(!XCompositeQueryExtension(display, &extension_major, &extension_minor)) return 0; int major_version; int minor_version; return XCompositeQueryVersion(display, &major_version, &minor_version) && (major_version > 0 || minor_version >= 2); } int window_texture_init(WindowTexture *window_texture, Display *display, Window window, gsr_egl *egl) { window_texture->display = display; window_texture->window = window; window_texture->pixmap = None; window_texture->image = NULL; window_texture->texture_id = 0; window_texture->redirected = 0; window_texture->egl = egl; window_texture->window_width = 0; window_texture->window_height = 0; if(!x11_supports_composite_named_window_pixmap(display)) return 1; XCompositeRedirectWindow(display, window, CompositeRedirectAutomatic); window_texture->redirected = 1; return window_texture_on_resize(window_texture); } static void window_texture_cleanup(WindowTexture *self, int delete_texture) { if(delete_texture && self->texture_id) { self->egl->glDeleteTextures(1, &self->texture_id); self->texture_id = 0; } if(self->image) { self->egl->eglDestroyImage(self->egl->egl_display, self->image); self->image = NULL; } if(self->pixmap) { XFreePixmap(self->display, self->pixmap); self->pixmap = None; } } void window_texture_deinit(WindowTexture *self) { if(self->redirected) { XCompositeUnredirectWindow(self->display, self->window, CompositeRedirectAutomatic); self->redirected = 0; } window_texture_cleanup(self, 1); } int window_texture_on_resize(WindowTexture *self) { window_texture_cleanup(self, 0); int result = 0; Pixmap pixmap = None; unsigned int texture_id = 0; EGLImage image = NULL; const intptr_t pixmap_attrs[] = { EGL_IMAGE_PRESERVED_KHR, EGL_TRUE, EGL_NONE, }; Window root_window; int window_x, window_y; unsigned int window_border, window_depth; XGetGeometry(self->display, self->window, &root_window, &window_x, &window_y, &self->window_width, &self->window_height, &window_border, &window_depth); pixmap = XCompositeNameWindowPixmap(self->display, self->window); if(!pixmap) { result = 2; goto cleanup; } if(self->texture_id == 0) { self->egl->glGenTextures(1, &texture_id); if(texture_id == 0) { result = 3; goto cleanup; } self->egl->glBindTexture(GL_TEXTURE_2D, texture_id); } else { self->egl->glBindTexture(GL_TEXTURE_2D, self->texture_id); texture_id = self->texture_id; } self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); self->egl->glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); while(self->egl->glGetError()) {} while(self->egl->eglGetError() != EGL_SUCCESS) {} image = self->egl->eglCreateImage(self->egl->egl_display, NULL, EGL_NATIVE_PIXMAP_KHR, (EGLClientBuffer)pixmap, pixmap_attrs); if(!image) { result = 4; goto cleanup; } self->egl->glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, image); if(self->egl->glGetError() != 0 || self->egl->eglGetError() != EGL_SUCCESS) { result = 5; goto cleanup; } self->pixmap = pixmap; self->texture_id = texture_id; self->image = image; cleanup: self->egl->glBindTexture(GL_TEXTURE_2D, 0); if(result != 0) { if(image) self->egl->eglDestroyImage(self->egl->egl_display, image); if(texture_id != 0) self->egl->glDeleteTextures(1, &texture_id); if(pixmap) XFreePixmap(self->display, pixmap); } return result; } unsigned int window_texture_get_opengl_texture_id(WindowTexture *self) { return self->texture_id; } fsdsfdsfdsfdsf-5.13.8/study/000077500000000000000000000000001520215207700157555ustar00rootroot00000000000000fsdsfdsfdsfdsf-5.13.8/study/color_space_transform_matrix.png000066400000000000000000000157761520215207700244530ustar00rootroot00000000000000PNG  IHDRoXbsBITOIDATxOhu8 u骚QҚbQ %A:8 ևvgb|A:HΐDP6ѝDjLkA\r0G*?%Qc?=j;v:gy3y>{{{ #Q @љz%RA@ "HAW @ J^ +AD z%RA| sFI– :OFIR-J%IrnQP(D%z=io8/Xf2tsTm"Febۑ0H=1c|REQDeP(`ؘJ%dbEPeY4G'V["˲#>#,ˑ $IQRz+IIYbXi\ X,ʲ<33Tqcrr13ccc Iꕌqƍaܹssss /0Û˖0._,z;kkk$eYHLOO#ĶmƘhL&i5 ۶%Izm0 z ׸S.)lVUJ%IdY末HX]]er9X>___'VkĴWuUU9Uo9emg2dIbŌeƘ,Νym]C5jYciVs||?Jt˄-$Wii]JR1fY4ưCL&Hd2UUK(^[kXÒ$^Ze-,,,q u땢(P(81;EaIϕJE{$U%uNk|᜗eXebbw`#V@8 ͋^t4-r::zU.KMt۶si+N O7RŲ,˲zs0uFXa}`p.d4͉ϋa`ddd$9ۗLӜ~w .oF.[Tvpއ~XN|?KЍP.?po(266iZAp4ifff6ZڈgeeŻ}rrX,.,,h~[#C2lt^=4>;f&_o;A$Ws9d2Xp߫W$xL1&+WFFF0eYUUe充ϣ:>~qqq~~G奥7ooc,J>1)\>OTy;;: Sk׮)5^B*5hV8s2b߼ie/zwpƆ;hhlAxd2 WVVXԪsKW5KƠs`nŃ|B6=z oiKQC\k~bQ J(14E A8i:cs`x-ׯ_4 Ri0lYVz&l\yӶR$4/_ m߻w̙3"6tff0"jBUU]MӬT*bnnN ƈ[ *eY-U0 ˲pU0lo7O 9z%ґfh9D8pν$+쩩)#&`qq0 YEm;^)]4V}Ь ցRX&''1Na6z}4[`xtR2ſa@IH*V )jil0-h p^Er@ ⌀&w3aq`ccz =Deg.Gut:QA߈#bNZUu#j~vv6̳w!IHP )n9?vFE>wql/)˲aL&kW󀦰m)*^`k4mJ-d3jiGIP HV90m&jn+漍k4 0T*iUU v,Ab4fvf@|߮*Z'ZHF,!0s&M[nasJ Ѡςr2sss^Ul3f R CǨ9^~]\.wM緒$9s!جf 7r\mmtp4Q ^ĉ===wp+۷xJU]׻3MVB 8ǧ: I488É'z{{O> @Q9+D-E ӣahh&<:]vwvv766У4MX#`b180d===/rRC49$P(8=s_cc7jQ/pE  ]64z^8?g̑? I^{59r[ơk4 ͕x"4Jӧ٬ii-N)ooo߻wO7x#in__r Nz<4ryyI:N䝰!A˹s\4>U"rBaJ;zfɓwyk_wO>?w;V3'O79~xs7~#o%a裏޽[uo~\ZЃ?5%l|[wKAEq8a y\ԡW8[eJ2deUUeYnkV\.˵aرc_׽+U{eY{w-;v?\[[kQkErOz-ǯ|+lǻ/~Gm{ttԫ^_|şUC;Ws4 '2Ƅ|jjwߝa%v{>Ȟd2mR9Iɤ(Us;vʕ+IRYYY Wy:_|HӐaR`Z,STwڎ8aMڹuooNLLx7gik$I6WG^ԑ#a.<<-Gs H*u={֊u>nСѸeY"'i 0/ҁ'Sӧ!eY-lEQ[s~)wqq1R d~b9TJl6{ŅI;^ _zo1E~7$D؎Y1Mj;]DPt:ʱuFGGE6K.]GZ![+=󵜽jfy_?{, \+us7CU.^Ch:?({C8ݍ7 ZUq8'WLy-&D-"Ң-ʯpXzMŽ{^T՚+2Ƙ,ˮ ( tl 0]xNPlȖSv Iam1!N(i U7[[?HsrlH$U;纮+RU8j£-_rezzzvv.F7/lr0dYU\.OtVE2B0y% @;aԙJб9~:mPN~bn:/ +O.zuuUrxQ:R2TUżlΝ;&Άa(]sD ǣi:Kض`&ayvbs/Ѽ(9ڒeC?.^W'm߇sL悽4[ <_XbτI&WP/|>MIǿolooWMDelaY9a qQsssN&ؾˁ08Pi)/0 $I[D^@Dڏ$P @ J^ k<{l{{;j)@Qvvvn߾ܿV2<o,..ܻwٳX\\h4SJD,\k%=z&J, AdE!J:ԘOOO3 j-!ȿaW+, %s\$QSHd7"4͍ D- ;mK/<~>h< һ9 }ee' 3 c3133Hʛv eœ$o,LR,x$i@Z4ziffFlAR`>z1vv>󱱱;wD-H`Xt굵5[o9oa.KR2 m쥥%4]ف1600-7lSat+s'J c<\.$LfbbB8p氄ض M+$I"n&qb`71!g|gsƍů8cccݣ5J,5 YpTjۂZ-?Ƙ$I\ɝ;,-- 1΍neHXŪa^ְ> JZ76~Uh,… ( :uS\a*|||1%K [eInݺK+ lllY" ]&bH㝵\aH;CWL1MPe&i+_\\d23 U圖f'bnd_DQu)UT1ۅǏwneykAsaBب mf+W$T kC8Y]]]^^jC>o |>ßh677744$F ޝᛆM 6a 4BUN^/R !lsw$pZs$6"1m|> gyX0VsL2`j_XXG+Bbz'Fqp2c"F-/ Mt VUնmMB I:ޱ^v]*r&!jRg}K/Uɓ'ǎn翷S>|S:‡ÃN<.KÇ'N OMM1ƒdoo/|X9 !Hڅ?Oks=HDj)AtǏz/1^sm4MSUUӧ/BC*|ŪQ={w7|siiɻ}~~sW-[~?͊|hFGGw|9>WWB_m[ˀ,===Zl^6dddO>~ѐ9>zhOeY. U;^CN+?oP5|ѣGϞ=;r1d<{,d8;l8Yf2YQC]0eclvggGux_DmG! _~e:+U- RUByjZMtȑpdu:*H&׿|9a~E?'Në0ss/D IR-8=瑛KՅ8%$־ FQ39) :;VY}GnXyX~&˲($T8WFz4 kAQJelllo?f逝@S˲|_1GRQd;mE PC< '''E.,,tzZ[mHwm|wmh<D42~(JkV܂:ֶSN Um?\6,!CmHCyWѣþ?|L&mB6&tCFHNQP*-Lm{}}=#ys-^(9]5M 2} VY/_<55(SEQTUuݕ?LPR!5U+1^zՕͅ!nÌ6,mi%#) JzCW63~E|]G+0,Gu*>"5<<, ނҫCK[D +n&I$atUL-|![9*ٶz{=I_#D]PUۉD_,DC4MdG{>zȶEѼșP۷ow!ڏT j8mhwMtU2(ԫ;4&RR)B:P(4r9h  ΎR'BgVgH$EqPtQHg'JMOOg+*TUMӊ v7sdHCƁC jqhm[UUl1$Í>P`f5;;۩^%\78tE "8@^ +AD z%RA@ ".TS IENDB`fsdsfdsfdsfdsf-5.13.8/study/create_matrix.py000077500000000000000000000033451520215207700211660ustar00rootroot00000000000000#!/usr/bin/env python3 import sys def usage(): print("usage: Kr Kg Kb full|limited") print("examples:") print(" create_matrix.py 0.2126 0.7152 0.0722 full") print(" create_matrix.py 0.2126 0.7152 0.0722 limited") exit(1) def a(v): if v >= 0: return " %f" % v else: return "%f" % v def main(argv): if len(argv) != 5: usage() Kr = float(sys.argv[1]) Kg = float(sys.argv[2]) Kb = float(sys.argv[3]) color_range = sys.argv[4] luma_offset = 0.0 transform_range = 1.0 if color_range == "full": pass elif color_range == "limited": transform_range = (235.0 - 16.0) / 255.0 luma_offset = 16.0 / 255.0 matrix = [ [Kr, Kg, Kb], [-0.5 * (Kr / (1.0 - Kb)), -0.5 * (Kg / (1.0 - Kb)), 0.5], [0.5, -0.5 * (Kg / (1.0 - Kr)), -0.5 * (Kb / (1.0 -Kr))], [0.0, 0.5, 0.5] ] # Transform from row major to column major for glsl print("const mat4 RGBtoYUV = mat4(%f, %s, %s, %f," % (matrix[0][0] * transform_range, a(matrix[1][0] * transform_range), a(matrix[2][0] * transform_range), 0.0)) print(" %f, %s, %s, %f," % (matrix[0][1] * transform_range, a(matrix[1][1] * transform_range), a(matrix[2][1] * transform_range), 0.0)) print(" %f, %s, %s, %f," % (matrix[0][2] * transform_range, a(matrix[1][2] * transform_range), a(matrix[2][2] * transform_range), 0.0)) print(" %f, %s, %s, %f);" % (matrix[3][0] + luma_offset, a(matrix[3][1]), a(matrix[3][2]), 1.0)) main(sys.argv) fsdsfdsfdsfdsf-5.13.8/uninstall.sh000077500000000000000000000003461520215207700171600ustar00rootroot00000000000000#!/bin/sh -e script_dir=$(dirname "$0") cd "$script_dir" [ $(id -u) -ne 0 ] && echo "You need root privileges to run the uninstall script" && exit 1 ninja -C build uninstall echo "Successfully uninstalled gpu-screen-recorder"