pax_global_header00006660000000000000000000000064150123177060014514gustar00rootroot0000000000000052 comment=40fbe24654eaba6eccc8a2303fe32976a05af444 obs-vkcapture-1.5.2/000077500000000000000000000000001501231770600143065ustar00rootroot00000000000000obs-vkcapture-1.5.2/.github/000077500000000000000000000000001501231770600156465ustar00rootroot00000000000000obs-vkcapture-1.5.2/.github/ISSUE_TEMPLATE/000077500000000000000000000000001501231770600200315ustar00rootroot00000000000000obs-vkcapture-1.5.2/.github/ISSUE_TEMPLATE/bug_report.md000066400000000000000000000010241501231770600225200ustar00rootroot00000000000000--- name: Bug report about: Create a bug report title: '' labels: '' assignees: '' --- **Describe the bug** A clear and concise description of what the bug is. **Screenshots or video** If applicable, add screenshots or video to help explain your problem. **System (please complete the following information):** - OS: - GPU: - Mesa version: - obs-vkcapture version: **OBS log:** ``` Paste OBS log here. ``` **Game log:** ``` Paste game terminal output here. Make sure to set OBS_VKCAPTURE_QUIET=0 environment variable. ``` obs-vkcapture-1.5.2/.github/workflows/000077500000000000000000000000001501231770600177035ustar00rootroot00000000000000obs-vkcapture-1.5.2/.github/workflows/main.yml000066400000000000000000000014321501231770600213520ustar00rootroot00000000000000name: Main on: push: branches: [ "master" ] pull_request: branches: [ "master" ] env: BUILD_TYPE: Release jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Dependencies run: | sudo add-apt-repository ppa:obsproject/obs-studio sudo apt update sudo apt install libvulkan-dev obs-studio libgl-dev libegl-dev libx11-dev libxcb1-dev libxcb-xfixes0-dev libwayland-dev libwayland-bin - name: Configure run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} - name: Build run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} - name: Install run: sudo cmake --install ${{github.workspace}}/build --config ${{env.BUILD_TYPE}} obs-vkcapture-1.5.2/.gitignore000066400000000000000000000000061501231770600162720ustar00rootroot00000000000000build obs-vkcapture-1.5.2/CMakeLists.txt000066400000000000000000000131521501231770600170500ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.10) project(obs-vkcapture LANGUAGES C VERSION 1.5.2) include(GNUInstallDirs) find_package(Vulkan REQUIRED) set(OpenGL_GL_PREFERENCE LEGACY) find_package(OpenGL REQUIRED) find_package(PkgConfig) pkg_check_modules(EGL egl IMPORTED_TARGET) pkg_check_modules(X11 x11 IMPORTED_TARGET) pkg_check_modules(XCB xcb IMPORTED_TARGET) pkg_check_modules(XCB_XFIXES xcb-xfixes IMPORTED_TARGET) pkg_check_modules(WAYLAND_CLIENT wayland-client IMPORTED_TARGET) pkg_get_variable(WAYLAND_SCANNER wayland-scanner wayland_scanner) if (VULKAN_FOUND AND NOT TARGET Vulkan::Vulkan) add_library(Vulkan::Vulkan UNKNOWN IMPORTED) set_target_properties(Vulkan::Vulkan PROPERTIES IMPORTED_LOCATION "${VULKAN_LIBRARIES}" INTERFACE_INCLUDE_DIRECTORIES "${VULKAN_INCLUDE_DIRS}") endif() if (NOT Vulkan_VERSION) set(Vulkan_VERSION "1.3.221") endif() if (X11_FOUND) set(HAVE_X11_XLIB TRUE) endif() if (XCB_FOUND AND XCB_XFIXES_FOUND) set(HAVE_X11_XCB TRUE) endif() if (WAYLAND_CLIENT_FOUND AND WAYLAND_SCANNER) set(HAVE_WAYLAND TRUE) endif() option(BUILD_PLUGIN "Build OBS plugin" ON) if (${CMAKE_SIZEOF_VOID_P} EQUAL 4) set(LAYER_SUFFIX "_32") else() set(LAYER_SUFFIX "_64") endif() set(CMAKE_C_STANDARD 11) if (BUILD_PLUGIN) if (NOT TARGET OBS::libobs) find_package(libobs QUIET) endif() if (NOT TARGET libobs) find_package(LibObs QUIET) endif() if (TARGET OBS::libobs) set(PLUGIN_LIBS OBS::libobs) elseif (TARGET libobs) set(PLUGIN_LIBS libobs) else() pkg_check_modules(LIBOBS libobs IMPORTED_TARGET REQUIRED) set(PLUGIN_LIBS PkgConfig::LIBOBS) if (HAVE_WAYLAND) add_definitions(-DENABLE_WAYLAND=1) endif() endif() set(PLUGIN_SOURCES src/vkcapture.c) set(PLUGIN_LIBS ${PLUGIN_LIBS} obs-frontend-api PkgConfig::EGL) if (HAVE_X11_XCB) set(PLUGIN_SOURCES ${PLUGIN_SOURCES} src/xcursor-xcb.c) set(PLUGIN_LIBS ${PLUGIN_LIBS} PkgConfig::XCB PkgConfig::XCB_XFIXES) endif() if (HAVE_WAYLAND) set(screencopy_protocol "${CMAKE_CURRENT_SOURCE_DIR}/src/ext-screencopy-v1.xml") set(screencopy_header "${CMAKE_CURRENT_BINARY_DIR}/screencopy_unstable_v1.h") set(screencopy_source "${CMAKE_CURRENT_BINARY_DIR}/screencopy_unstable_v1.c") add_custom_command(OUTPUT ${screencopy_header} COMMAND ${WAYLAND_SCANNER} client-header ${screencopy_protocol} ${screencopy_header} DEPENDS ${screencopy_protocol}) add_custom_command(OUTPUT ${screencopy_source} COMMAND ${WAYLAND_SCANNER} private-code ${screencopy_protocol} ${screencopy_source} DEPENDS ${screencopy_protocol}) set(PLUGIN_SOURCES ${PLUGIN_SOURCES} src/wlcursor.c ${screencopy_header} ${screencopy_source}) set(PLUGIN_LIBS ${PLUGIN_LIBS} PkgConfig::WAYLAND_CLIENT) endif() add_library(linux-vkcapture MODULE ${PLUGIN_SOURCES}) target_link_libraries(linux-vkcapture ${PLUGIN_LIBS}) set_target_properties(linux-vkcapture PROPERTIES PREFIX "") target_include_directories(linux-vkcapture PRIVATE $) if (COMMAND install_obs_plugin_with_data) install_obs_plugin_with_data(linux-vkcapture data) else() install(TARGETS linux-vkcapture LIBRARY DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}/obs-plugins") file(GLOB locale_files data/locale/*.ini) install(FILES ${locale_files} DESTINATION "${CMAKE_INSTALL_FULL_DATAROOTDIR}/obs/obs-plugins/linux-vkcapture/locale") endif() endif() set(LAYER_SOURCES src/vklayer.c src/capture.c) add_library(VkLayer_obs_vkcapture MODULE ${LAYER_SOURCES}) set_target_properties(VkLayer_obs_vkcapture PROPERTIES LINK_FLAGS "-Wl,--version-script=\"${CMAKE_CURRENT_SOURCE_DIR}/src/vklayer.version\"") target_link_libraries(VkLayer_obs_vkcapture Vulkan::Vulkan) target_include_directories(VkLayer_obs_vkcapture PRIVATE $) if (HAVE_X11_XLIB) target_include_directories(VkLayer_obs_vkcapture PRIVATE $) endif() if (HAVE_X11_XCB) target_include_directories(VkLayer_obs_vkcapture PRIVATE $ $ ) endif() set(GL_SOURCES src/dlsym.c src/elfhacks.c src/glinject.c src/capture.c) add_library(obs_glcapture MODULE ${GL_SOURCES}) set_target_properties(obs_glcapture PROPERTIES LINK_FLAGS "-Wl,--version-script=\"${CMAKE_CURRENT_SOURCE_DIR}/src/glinject.version\"") target_link_libraries(obs_glcapture ${CMAKE_DL_LIBS} OpenGL::GL) target_include_directories(obs_glcapture PRIVATE $ $ ) configure_file(plugin-macros.h.in ${CMAKE_CURRENT_BINARY_DIR}/plugin-macros.h @ONLY) configure_file(src/obs_vkcapture.json.in ${CMAKE_CURRENT_BINARY_DIR}/obs_vkcapture${LAYER_SUFFIX}.json @ONLY) configure_file(src/obs-gamecapture.in ${CMAKE_CURRENT_BINARY_DIR}/obs-gamecapture @ONLY) install(TARGETS VkLayer_obs_vkcapture LIBRARY DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}") install(TARGETS obs_glcapture LIBRARY DESTINATION "${CMAKE_INSTALL_FULL_LIBDIR}/obs_glcapture") install(FILES ${CMAKE_CURRENT_BINARY_DIR}/obs_vkcapture${LAYER_SUFFIX}.json DESTINATION "${CMAKE_INSTALL_FULL_DATAROOTDIR}/vulkan/implicit_layer.d") install(PROGRAMS ${CMAKE_CURRENT_BINARY_DIR}/obs-gamecapture src/obs-vkcapture src/obs-glcapture DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}") obs-vkcapture-1.5.2/LICENSE000066400000000000000000000431751501231770600153250ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. {description} Copyright (C) {year} {fullname} This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. {signature of Ty Coon}, 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License.obs-vkcapture-1.5.2/README.md000066400000000000000000000027501501231770600155710ustar00rootroot00000000000000# OBS Linux Vulkan/OpenGL game capture OBS plugin for Vulkan/OpenGL game capture on Linux. AUR: [obs-vkcapture-git](https://aur.archlinux.org/packages/obs-vkcapture-git/) **Flatpak:** * OBS plugin: [com.obsproject.Studio.Plugin.OBSVkCapture](https://github.com/flathub/com.obsproject.Studio.Plugin.OBSVkCapture) * Capture tools: [org.freedesktop.Platform.VulkanLayer.OBSVkCapture](https://github.com/flathub/org.freedesktop.Platform.VulkanLayer.OBSVkCapture) ## About Flatpak If you use Flatpak OBS, you need to install Flatpak *OBS plugin*. If you use Flatpak Steam, you need to install Flatpak *Capture tools* to be able to capture games running inside Flatpak Steam runtine. For capturing games outside Flatpak runtime, you need native build regardless of if you are using Flatpak OBS or not. ## Dependencies * cmake * libobs * libvulkan * libgl * libegl * libX11 (optional) * libxcb (optional) * libwayland-client (optional) * wayland-scanner (optional) ## Building mkdir build && cd build cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release .. make && make install ## Usage 1. Add `Game Capture` to your OBS scene. 2. Start the game with capture enabled `obs-gamecapture %command%`. 3. (Recommended) Start the game with only Vulkan capture enabled `env OBS_VKCAPTURE=1 %command%`. ## Troubleshooting **NVIDIA** Driver version >= 515.43.04 and `nvidia-drm.modeset=1` kernel parameter are required. In Wayland session make sure OBS is running on Wayland and not XWayland. obs-vkcapture-1.5.2/data/000077500000000000000000000000001501231770600152175ustar00rootroot00000000000000obs-vkcapture-1.5.2/data/locale/000077500000000000000000000000001501231770600164565ustar00rootroot00000000000000obs-vkcapture-1.5.2/data/locale/cs-CZ.ini000066400000000000000000000004611501231770600200770ustar00rootroot00000000000000GameCapture="Záznam hry" Description="Linux Vulkan/OpenGL záznam hry" CaptureCursor="Zaznamenávat kurzor" CaptureWindow="Okno" CaptureAnyWindow="Zaznamenávat jakékoliv okno" CaptureAnyWindowExcept="Zaznamenávat jakékoliv okno kromě" AllowTransparency="Povolit průhlednost" ForceHDR="Vynutit HDR" obs-vkcapture-1.5.2/data/locale/de-DE.ini000066400000000000000000000003541501231770600200370ustar00rootroot00000000000000GameCapture="Spielaufnahme" CaptureCursor="Mauszeiger aufnehmen" CaptureWindow="Fenster" CaptureAnyWindow="Beliebiges Fenster erfassen" CaptureAnyWindowExcept="Beliebiges Fenster erfassen außer" AllowTransparency="Erlaube Transparenz" obs-vkcapture-1.5.2/data/locale/en-US.ini000066400000000000000000000004251501231770600201070ustar00rootroot00000000000000GameCapture="Game Capture" Description="Linux Vulkan/OpenGL game capture" CaptureCursor="Capture Cursor" CaptureWindow="Window" CaptureAnyWindow="Capture any window" CaptureAnyWindowExcept="Capture any window except" AllowTransparency="Allow Transparency" ForceHDR="Force HDR" obs-vkcapture-1.5.2/data/locale/es-ES.ini000066400000000000000000000003561501231770600200770ustar00rootroot00000000000000GameCapture="Captura de juego" CaptureCursor="Captura de Cursor" CaptureWindow="Ventana" CaptureAnyWindow="Capturar cualquier ventana" CaptureAnyWindowExcept="Capturar cualquier ventana excepto" AllowTransparency="Permitir transparencia" obs-vkcapture-1.5.2/data/locale/fr-FR.ini000066400000000000000000000005101501231770600200670ustar00rootroot00000000000000GameCapture="Capture de jeu" Description="Capture de jeu Linux Vulkan/OpenGL" CaptureCursor="Capturer le curseur" CaptureWindow="Fenêtre" CaptureAnyWindow="Capturer n'importe quelle fenêtre" CaptureAnyWindowExcept="Capturer n'importe quelle fenêtre sauf" AllowTransparency="Autoriser la transparence" ForceHDR="Forcer l'HDR" obs-vkcapture-1.5.2/data/locale/it-IT.ini000066400000000000000000000002541501231770600201060ustar00rootroot00000000000000GameCapture="Cattura gioco" CaptureCursor="Cattura cursore" CaptureWindow="Finestra" CaptureAnyWindow="Cattura qualsiasi finestra" AllowTransparency="Permetti trasparenza" obs-vkcapture-1.5.2/data/locale/ja-JP.ini000066400000000000000000000003141501231770600200560ustar00rootroot00000000000000GameCapture="ゲームキャプチャ" CaptureCursor="カーソルを映す" CaptureWindow="ウィンドウ" CaptureAnyWindow="任意のウィンドウを映す" AllowTransparency="透過を許可する" obs-vkcapture-1.5.2/data/locale/pl-PL.ini000066400000000000000000000005021501231770600201000ustar00rootroot00000000000000GameCapture="Przechwytywanie gry" Description="Przechwytywanie gier używających Vulkan/OpenGL na Linuksie" CaptureCursor="Przechwytuj kursor" CaptureWindow="Okno" CaptureAnyWindow="Przechwytuj dowolne okno" CaptureAnyWindowExcept="Przechwytuj dowolne okno, z wyjątkiem" AllowTransparency="Pozwól na przezroczystość" obs-vkcapture-1.5.2/data/locale/pt-BR.ini000066400000000000000000000004641501231770600201070ustar00rootroot00000000000000GameCapture="Captura de jogo" Description="Captura de jogo Vulkan/OpenGL no Linux" CaptureCursor="Cursor de captura" CaptureWindow="Janela" CaptureAnyWindow="Capturar qualquer janela" CaptureAnyWindowExcept="Capturar qualquer janela exceto" AllowTransparency="Permitir transparência" ForceHDR="Forçar HDR" obs-vkcapture-1.5.2/data/locale/ru-RU.ini000066400000000000000000000003631501231770600201330ustar00rootroot00000000000000GameCapture="Захват игры" CaptureCursor="Показывать курсор" CaptureWindow="Окно" CaptureAnyWindow="Захватывать любое окно" AllowTransparency="Использовать прозрачность" obs-vkcapture-1.5.2/data/locale/uk-UA.ini000066400000000000000000000006301501231770600201000ustar00rootroot00000000000000GameCapture="Захоплення гри" Description="Захоплення Vulkan/OpenGL ігор на Linux" CaptureCursor="Показувати вказівник" CaptureWindow="Вікно" CaptureAnyWindow="Захоплювати будь-яке вікно" CaptureAnyWindowExcept="Захоплювати будь-яке вікно, крім" AllowTransparency="Дозволити прозорість" obs-vkcapture-1.5.2/dist/000077500000000000000000000000001501231770600152515ustar00rootroot00000000000000obs-vkcapture-1.5.2/dist/PKGBUILD000066400000000000000000000031241501231770600163750ustar00rootroot00000000000000_pkgbase=obs-vkcapture pkgbase=${_pkgbase}-git pkgname=('obs-vkcapture-git' 'lib32-obs-vkcapture-git') pkgver=0.1 pkgrel=1 url='https://github.com/nowrep/obs-vkcapture' license=('GPL2') arch=('x86_64') depends=('vulkan-icd-loader' 'libgl' 'obs-studio>=27') makedepends=('git' 'gcc' 'cmake' 'vulkan-headers' 'lib32-gcc-libs' 'lib32-vulkan-icd-loader' 'lib32-libgl') source=("$_pkgbase::git+$url") sha512sums=('SKIP') pkgver() { cd "$_pkgbase" printf "r%s.%s" "$(git rev-list --count HEAD)" "$(git rev-parse --short HEAD)" } build() { cmake -B build -S "$_pkgbase" -DCMAKE_INSTALL_PREFIX=/usr \ -DCMAKE_INSTALL_LIBDIR=lib \ -DCMAKE_INSTALL_DATADIR=/share \ -DCMAKE_BUILD_TYPE=Release make -C build export CFLAGS="-m32 ${CFLAGS}" export CXXFLAGS="-m32 ${CXXFLAGS}" export LDFLAGS="-m32 ${LDFLAGS}" cmake -B build32 -S "$_pkgbase" -DCMAKE_INSTALL_PREFIX=/usr \ -DCMAKE_INSTALL_LIBDIR=lib32 \ -DCMAKE_INSTALL_DATADIR=/share \ -DCMAKE_LIBRARY_PATH=/usr/lib32 \ -DCMAKE_BUILD_TYPE=Release \ -DBUILD_PLUGIN=OFF make -C build32 } package_obs-vkcapture-git() { pkgdesc='OBS Linux Vulkan/OpenGL game capture' conflicts=('obs-vkcapture') provides=('obs-vkcapture') make -C build DESTDIR="$pkgdir" install } package_lib32-obs-vkcapture-git() { pkgdesc='OBS Linux Vulkan/OpenGL game capture (32-bit)' depends=('lib32-vulkan-icd-loader' 'lib32-libgl') conflicts=('lib32-obs-vkcapture') provides=('lib32-obs-vkcapture') make -C build32 DESTDIR="$pkgdir" install rm -r "$pkgdir/usr/bin" } obs-vkcapture-1.5.2/dist/flatpak/000077500000000000000000000000001501231770600166735ustar00rootroot00000000000000obs-vkcapture-1.5.2/dist/flatpak/com.obsproject.Studio.Plugin.VkCapture.metainfo.xml000066400000000000000000000006561501231770600305620ustar00rootroot00000000000000 com.obsproject.Studio.Plugin.VkCapture com.obsproject.Studio OBS Vulkan/OpenGL Capture OBS Linux Vulkan/OpenGL game capture https://github.com/nowrep/obs-vkcapture CC0-1.0 GPL-2.0 obs-vkcapture-1.5.2/dist/flatpak/com.obsproject.Studio.Plugin.VkCapture.yml000066400000000000000000000015351501231770600267570ustar00rootroot00000000000000id: com.obsproject.Studio.Plugin.VkCapture branch: stable runtime: com.obsproject.Studio runtime-version: stable sdk: org.kde.Sdk//5.15-21.08 build-extension: true separate-locales: false appstream-compose: false build-options: prefix: /app/plugins/VkCapture modules: - name: VkCapture buildsystem: cmake-ninja config-opts: - -DCMAKE_BUILD_TYPE=Release - -DLIBOBS_INCLUDE_DIR=/app/include/obs post-install: - install -Dm644 --target-directory=${FLATPAK_DEST}/share/metainfo ${FLATPAK_ID}.metainfo.xml - appstream-compose --basename=${FLATPAK_ID} --prefix=${FLATPAK_DEST} --origin=flatpak ${FLATPAK_ID} cleanup: - '/bin' sources: - type: git url: https://github.com/nowrep/obs-vkcapture.git tag: v1.1 - type: file path: com.obsproject.Studio.Plugin.VkCapture.metainfo.xml obs-vkcapture-1.5.2/plugin-macros.h.in000066400000000000000000000017571501231770600176560ustar00rootroot00000000000000/* obs-vkcapture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #ifndef PLUGINNAME_H #define PLUGINNAME_H #cmakedefine01 HAVE_X11_XCB #cmakedefine01 HAVE_X11_XLIB #cmakedefine01 HAVE_WAYLAND #define PLUGIN_NAME "linux-vkcapture" #define PLUGIN_VERSION "@CMAKE_PROJECT_VERSION@" #define blog(level, msg, ...) blog(level, "[" PLUGIN_NAME "] " msg, ##__VA_ARGS__) #endif // PLUGINNAME_H obs-vkcapture-1.5.2/src/000077500000000000000000000000001501231770600150755ustar00rootroot00000000000000obs-vkcapture-1.5.2/src/capture.c000066400000000000000000000141121501231770600167030ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #include "capture.h" #include "utils.h" #include #include #include #include #include #include #include #include static struct { int connfd; bool accepted; bool capturing; bool no_modifiers; bool linear; bool map_host; bool need_reinit; uint8_t device_uuid[16]; } data; static bool get_wine_exe(char *buf, size_t bufsize) { FILE *f = fopen("/proc/self/comm", "r"); if (!f) { return false; } size_t n = fread(buf, sizeof(char), bufsize, f); fclose(f); if (n < 1) { return false; } buf[n - 1] = '\0'; return true; } static bool get_exe(char *buf, size_t bufsize) { char exe[PATH_MAX]; ssize_t n = readlink("/proc/self/exe", exe, PATH_MAX); if (n <= 0) { return false; } exe[n] = '\0'; strncpy(buf, basename(exe), bufsize); buf[bufsize - 1] = '\0'; if (!strcmp(buf, "wine-preloader") || !strcmp(buf, "wine64-preloader")) { return get_wine_exe(buf, bufsize); } return true; } static bool capture_try_connect() { const char sockname[] = "/com/obsproject/vkcapture"; struct sockaddr_un addr; addr.sun_family = PF_LOCAL; addr.sun_path[0] = '\0'; // Abstract socket memcpy(&addr.sun_path[1], sockname, sizeof(sockname) - 1); int sock = socket(PF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0); int ret = connect(sock, (const struct sockaddr *)&addr, sizeof(addr.sun_family) + sizeof(sockname)); if (ret == -1) { close(sock); return false; } data.connfd = sock; struct capture_client_data cd; cd.type = CAPTURE_CLIENT_DATA_TYPE; get_exe(cd.exe, sizeof(cd.exe)); struct msghdr msg = {0}; struct iovec io = { .iov_base = &cd, .iov_len = CAPTURE_CLIENT_DATA_SIZE, }; msg.msg_iov = &io; msg.msg_iovlen = 1; const ssize_t sent = sendmsg(data.connfd, &msg, MSG_NOSIGNAL); if (sent < 0) { hlog("Socket sendmsg error %s", strerror(errno)); } return true; } void capture_init() { memset(&data, 0, sizeof(data)); data.connfd = -1; } void capture_update_socket() { static int64_t last_check = 0; const int64_t now = os_time_get_nano(); if (now - last_check < 1000000000) { return; } last_check = now; if (data.connfd < 0 && !capture_try_connect()) { return; } struct capture_control_data control; ssize_t n = recv(data.connfd, &control, sizeof(control), 0); if (n == sizeof(control)) { const bool old_no_modifiers = data.no_modifiers; const bool old_linear = data.linear; const bool old_map_host = data.map_host; data.accepted = control.capturing == 1; data.no_modifiers = control.no_modifiers == 1; data.linear = control.linear == 1; data.map_host = control.map_host == 1; memcpy(data.device_uuid, control.device_uuid, 16); if (data.capturing && (old_no_modifiers != data.no_modifiers || old_linear != data.linear || old_map_host != data.map_host)) { data.need_reinit = true; } } if (n == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) { return; } if (errno != ECONNRESET) { hlog("Socket recv error %s", strerror(errno)); } } if (n <= 0) { close(data.connfd); data.connfd = -1; data.accepted = false; } } void capture_init_shtex( int width, int height, int format, int strides[4], int offsets[4], uint64_t modifier, uint32_t winid, bool flip, uint32_t color_space, int nfd, int fds[4]) { struct capture_texture_data td = {0}; td.type = CAPTURE_TEXTURE_DATA_TYPE; td.nfd = nfd; td.width = width; td.height = height; td.format = format; memcpy(td.strides, strides, sizeof(int) * nfd); memcpy(td.offsets, offsets, sizeof(int) * nfd); td.modifier = modifier; td.winid = winid; td.flip = flip; td.color_space = color_space; struct msghdr msg = {0}; struct iovec io = { .iov_base = &td, .iov_len = CAPTURE_TEXTURE_DATA_SIZE, }; msg.msg_iov = &io; msg.msg_iovlen = 1; char cmsg_buf[CMSG_SPACE(sizeof(int) * 4)]; msg.msg_control = cmsg_buf; msg.msg_controllen = CMSG_SPACE(sizeof(int) * nfd); struct cmsghdr *cmsg = CMSG_FIRSTHDR(&msg); cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; cmsg->cmsg_len = CMSG_LEN(sizeof(int) * nfd); memcpy(CMSG_DATA(cmsg), fds, sizeof(int) * nfd); const ssize_t sent = sendmsg(data.connfd, &msg, MSG_NOSIGNAL); if (sent < 0) { hlog("Socket sendmsg error %s", strerror(errno)); } data.capturing = true; data.need_reinit = false; } void capture_stop() { data.capturing = false; } bool capture_should_stop() { return data.capturing && (data.connfd < 0 || !data.accepted || data.need_reinit); } bool capture_should_init() { return !data.capturing && data.connfd >= 0 && data.accepted; } bool capture_ready() { return data.capturing; } bool capture_allocate_no_modifiers() { return data.no_modifiers; } bool capture_allocate_linear() { return data.linear; } bool capture_allocate_map_host() { return data.map_host; } bool capture_compare_device_uuid(uint8_t uuid[16]) { return memcmp(data.device_uuid, uuid, 16) == 0; } obs-vkcapture-1.5.2/src/capture.h000066400000000000000000000074401501231770600167160ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #pragma once #include #include #include #ifndef DRM_FORMAT_XRGB8888 #define fourcc_code(a, b, c, d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | \ ((uint32_t)(c) << 16) | ((uint32_t)(d) << 24)) #define DRM_FORMAT_XRGB8888 fourcc_code('X', 'R', '2', '4') #define DRM_FORMAT_ARGB8888 fourcc_code('A', 'R', '2', '4') #define DRM_FORMAT_XBGR8888 fourcc_code('X', 'B', '2', '4') #define DRM_FORMAT_ABGR8888 fourcc_code('A', 'B', '2', '4') #define DRM_FORMAT_XRGB2101010 fourcc_code('X', 'R', '3', '0') #define DRM_FORMAT_ARGB2101010 fourcc_code('A', 'R', '3', '0') #define DRM_FORMAT_XBGR2101010 fourcc_code('X', 'B', '3', '0') #define DRM_FORMAT_ABGR2101010 fourcc_code('A', 'B', '3', '0') #define DRM_FORMAT_XBGR16161616 fourcc_code('X', 'B', '4', '8') #define DRM_FORMAT_ABGR16161616 fourcc_code('A', 'B', '4', '8') #define DRM_FORMAT_XBGR16161616F fourcc_code('X', 'B', '4', 'H') #define DRM_FORMAT_ABGR16161616F fourcc_code('A', 'B', '4', 'H') #define fourcc_mod_code(vendor, val) ((((uint64_t)vendor) << 56) | ((val) & 0x00ffffffffffffffULL)) #define DRM_FORMAT_MOD_INVALID fourcc_mod_code(0, ((1ULL << 56) - 1)) #define DRM_FORMAT_MOD_LINEAR fourcc_mod_code(0, 0) #define DRM_FORMAT_MOD_VENDOR_AMD 0x02 #define AMD_FMT_MOD_DCC_SHIFT 13 #define AMD_FMT_MOD_DCC_MASK 0x1 #define IS_AMD_FMT_MOD(val) (((val) >> 56) == DRM_FORMAT_MOD_VENDOR_AMD) #define AMD_FMT_MOD_GET(field, value) (((value) >> AMD_FMT_MOD_##field##_SHIFT) & AMD_FMT_MOD_##field##_MASK) #endif struct capture_client_data { uint8_t type; char exe[48]; uint8_t padding[79]; } __attribute__((packed)); #define CAPTURE_CLIENT_DATA_TYPE 10 #define CAPTURE_CLIENT_DATA_SIZE 128 static_assert(sizeof(struct capture_client_data) == CAPTURE_CLIENT_DATA_SIZE, "size mismatch"); struct capture_texture_data { uint8_t type; uint8_t nfd; int32_t width; int32_t height; int32_t format; int32_t strides[4]; int32_t offsets[4]; uint64_t modifier; uint32_t winid; uint8_t flip; uint32_t color_space; uint8_t padding[65]; } __attribute__((packed)); #define CAPTURE_TEXTURE_DATA_TYPE 11 #define CAPTURE_TEXTURE_DATA_SIZE 128 static_assert(sizeof(struct capture_texture_data) == CAPTURE_TEXTURE_DATA_SIZE, "size mismatch"); struct capture_control_data { uint8_t capturing; uint8_t no_modifiers; uint8_t linear; uint8_t map_host; uint8_t device_uuid[16]; uint8_t padding[12]; } __attribute__((packed)); #define CAPTURE_CONTROL_DATA_TYPE 10 #define CAPTURE_CONTROL_DATA_SIZE 32 static_assert(sizeof(struct capture_control_data) == CAPTURE_CONTROL_DATA_SIZE, "size mismatch"); void capture_init(); void capture_update_socket(); void capture_init_shtex( int width, int height, int format, int strides[4], int offsets[4], uint64_t modifier, uint32_t winid, bool flip, uint32_t color_space, int nfd, int fds[4]); void capture_stop(); bool capture_should_stop(); bool capture_should_init(); bool capture_ready(); bool capture_allocate_no_modifiers(); bool capture_allocate_linear(); bool capture_allocate_map_host(); bool capture_compare_device_uuid(uint8_t uuid[16]); obs-vkcapture-1.5.2/src/dlsym.c000066400000000000000000000054021501231770600163720ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #include "dlsym.h" #include "elfhacks.h" #include "utils.h" #include static bool dl_seen = false; static struct dl_funcs dl_f; static bool dl_init_funcs() { if (dl_seen) { return dl_f.valid; } dl_seen = true; dl_f.valid = false; eh_obj_t libdl; int ret = eh_find_obj(&libdl, "*libdl.so*"); if (ret == 0) { eh_find_sym(&libdl, "dlsym", (void**)&dl_f.dlsym); eh_find_sym(&libdl, "dlvsym", (void**)&dl_f.dlvsym); } eh_destroy_obj(&libdl); if (!dl_f.dlsym) { eh_obj_t libc; int ret = eh_find_obj(&libc, "*libc.so*"); if (ret == 0) { eh_find_sym(&libc, "dlsym", (void**)&dl_f.dlsym); eh_find_sym(&libc, "dlvsym", (void**)&dl_f.dlvsym); } eh_destroy_obj(&libc); } if (!dl_f.dlsym) { hlog("Failed to open libdl.so and libc.so"); return false; } dl_f.valid = true; return true; } #undef GETDLADDR void *real_dlsym(void *handle, const char *symbol) { if (!dl_init_funcs()) { return NULL; } return dl_f.dlsym(handle, symbol); } void *real_dlvsym(void *handle, const char *symbol, const char *version) { if (!dl_init_funcs()) { return NULL; } return dl_f.dlvsym(handle, symbol, version); } extern void *obs_vkcapture_glXGetProcAddress(const char *name); extern void *obs_vkcapture_eglGetProcAddress(const char *name); void *dlsym(void *handle, const char *symbol) { void *real_func = real_dlsym(handle, symbol); if (!real_func) { return NULL; } void *func = obs_vkcapture_glXGetProcAddress(symbol); if (!func) { func = obs_vkcapture_eglGetProcAddress(symbol); } return func ? func : real_func; } void *dlvsym(void *handle, const char *symbol, const char *version) { void *real_func = real_dlvsym(handle, symbol, version); if (!real_func) { return NULL; } void *func = obs_vkcapture_glXGetProcAddress(symbol); if (!func) { func = obs_vkcapture_eglGetProcAddress(symbol); } return func ? func : real_func; } obs-vkcapture-1.5.2/src/dlsym.h000066400000000000000000000020151501231770600163740ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #pragma once #include struct dl_funcs { void *(*dlsym)(void *handle, const char *symbol); void *(*dlvsym)(void *handle, const char *symbol, const char *version); bool valid; }; void *real_dlsym(void *handle, const char *symbol); void *real_dlvsym(void *handle, const char *symbol, const char *version); obs-vkcapture-1.5.2/src/elfhacks.c000066400000000000000000000335441501231770600170320ustar00rootroot00000000000000/** * \file src/elfhacks.c * \brief various ELF run-time hacks * \author Pyry Haulos * \date 2007-2008 * For conditions of distribution and use, see copyright notice in elfhacks.h */ #define _GNU_SOURCE #define UNUSED(x) (void)(x) #include #include #include #include #include #include #include #include "elfhacks.h" #ifndef __ELF_NATIVE_CLASS #include "sys/reg.h" #define __ELF_NATIVE_CLASS __WORDSIZE #endif /** * \addtogroup elfhacks * \{ */ struct eh_iterate_callback_args { eh_iterate_obj_callback_func callback; void *arg; }; int eh_check_addr(eh_obj_t *obj, const void *addr); int eh_find_callback(struct dl_phdr_info *info, size_t size, void *argptr); int eh_find_next_dyn(eh_obj_t *obj, ElfW_Sword tag, int i, ElfW(Dyn) **next); int eh_init_obj(eh_obj_t *obj); int eh_set_rela_plt(eh_obj_t *obj, int p, const char *sym, void *val); int eh_set_rel_plt(eh_obj_t *obj, int p, const char *sym, void *val); int eh_iterate_rela_plt(eh_obj_t *obj, int p, eh_iterate_rel_callback_func callback, void *arg); int eh_iterate_rel_plt(eh_obj_t *obj, int p, eh_iterate_rel_callback_func callback, void *arg); int eh_find_sym_hash(eh_obj_t *obj, const char *name, eh_sym_t *sym); int eh_find_sym_gnu_hash(eh_obj_t *obj, const char *name, eh_sym_t *sym); ElfW(Word) eh_hash_elf(const char *name); Elf32_Word eh_hash_gnu(const char *name); int eh_find_callback(struct dl_phdr_info *info, size_t size, void *argptr) { eh_obj_t *find = (eh_obj_t *) argptr; UNUSED(size); if (find->name == NULL) { if (strcmp(info->dlpi_name, "")) return 0; } else if (fnmatch(find->name, info->dlpi_name, 0)) return 0; if (find->name == NULL) /* TODO readlink? */ find->name = "/proc/self/exe"; else find->name = info->dlpi_name; find->addr = info->dlpi_addr; /* segment headers */ find->phdr = info->dlpi_phdr; find->phnum = info->dlpi_phnum; return 0; } int eh_iterate_callback(struct dl_phdr_info *info, size_t size, void *argptr) { struct eh_iterate_callback_args *args = argptr; eh_obj_t obj; int ret = 0; UNUSED(size); /* eh_init_obj needs phdr and phnum */ obj.phdr = info->dlpi_phdr; obj.phnum = info->dlpi_phnum; obj.addr = info->dlpi_addr; obj.name = info->dlpi_name; if ((ret = eh_init_obj(&obj))) { if (ret == ENOTSUP) /* just skip */ return 0; return ret; } if ((ret = args->callback(&obj, args->arg))) return ret; if ((ret = eh_destroy_obj(&obj))) return ret; return 0; } int eh_iterate_obj(eh_iterate_obj_callback_func callback, void *arg) { int ret; struct eh_iterate_callback_args args; args.callback = callback; args.arg = arg; if ((ret = dl_iterate_phdr(eh_iterate_callback, &args))) return ret; return 0; } int eh_find_obj(eh_obj_t *obj, const char *soname) { /* This function uses glibc-specific dl_iterate_phdr(). Another way could be parsing /proc/self/exe or using pmap() on Solaris or *BSD */ obj->phdr = NULL; obj->name = soname; dl_iterate_phdr(eh_find_callback, obj); if (!obj->phdr) return EAGAIN; return eh_init_obj(obj); } int eh_check_addr(eh_obj_t *obj, const void *addr) { /* Check that given address is inside program's memory maps. PT_LOAD program headers tell us where program has been loaded into. */ int p; for (p = 0; p < obj->phnum; p++) { if (obj->phdr[p].p_type == PT_LOAD) { if (((ElfW(Addr)) addr < obj->phdr[p].p_memsz + obj->phdr[p].p_vaddr + obj->addr) && ((ElfW(Addr)) addr >= obj->phdr[p].p_vaddr + obj->addr)) return 0; } } return EINVAL; } int eh_init_obj(eh_obj_t *obj) { /* ELF spec says in section header documentation, that: "An object file may have only one dynamic section." Let's assume it means that object has only one PT_DYNAMIC as well. */ int p; obj->dynamic = NULL; for (p = 0; p < obj->phnum; p++) { if (obj->phdr[p].p_type == PT_DYNAMIC) { if (obj->dynamic) return ENOTSUP; obj->dynamic = (ElfW(Dyn) *) (obj->phdr[p].p_vaddr + obj->addr); } } if (!obj->dynamic) return ENOTSUP; /* ELF spec says that program is allowed to have more than one .strtab but does not describe how string table indexes translate to multiple string tables. And spec says that only one SHT_HASH is allowed, does it mean that obj has only one DT_HASH? About .symtab it does not mention anything about if multiple symbol tables are allowed or not. Maybe st_shndx is the key here? */ obj->strtab = NULL; obj->hash = NULL; obj->gnu_hash = NULL; obj->symtab = NULL; p = 0; while (obj->dynamic[p].d_tag != DT_NULL) { if (obj->dynamic[p].d_tag == DT_STRTAB) { if (obj->strtab) return ENOTSUP; obj->strtab = (const char *) obj->dynamic[p].d_un.d_ptr; } else if (obj->dynamic[p].d_tag == DT_HASH) { if (obj->hash) return ENOTSUP; obj->hash = (ElfW(Word) *) obj->dynamic[p].d_un.d_ptr; } else if (obj->dynamic[p].d_tag == DT_GNU_HASH) { if (obj->gnu_hash) return ENOTSUP; obj->gnu_hash = (Elf32_Word *) obj->dynamic[p].d_un.d_ptr; } else if (obj->dynamic[p].d_tag == DT_SYMTAB) { if (obj->symtab) return ENOTSUP; obj->symtab = (ElfW(Sym) *) obj->dynamic[p].d_un.d_ptr; } p++; } /* This is here to catch b0rken headers (vdso) */ if ((eh_check_addr(obj, (const void *) obj->strtab)) | (eh_check_addr(obj, (const void *) obj->symtab))) return ENOTSUP; if (obj->hash) { /* DT_HASH found */ if (eh_check_addr(obj, (void *) obj->hash)) obj->hash = NULL; } else if (obj->gnu_hash) { /* DT_GNU_HASH found */ if (eh_check_addr(obj, (void *) obj->gnu_hash)) obj->gnu_hash = NULL; } return 0; } int eh_find_sym(eh_obj_t *obj, const char *name, void **to) { eh_sym_t sym; /* DT_GNU_HASH is faster ;) */ if (obj->gnu_hash) { if (!eh_find_sym_gnu_hash(obj, name, &sym)) { *to = (void *) (sym.sym->st_value + obj->addr); return 0; } } /* maybe it is in DT_HASH or DT_GNU_HASH is not present */ if (obj->hash) { if (!eh_find_sym_hash(obj, name, &sym)) { *to = (void *) (sym.sym->st_value + obj->addr); return 0; } } return EAGAIN; } ElfW(Word) eh_hash_elf(const char *name) { ElfW(Word) tmp, hash = 0; const unsigned char *uname = (const unsigned char *) name; int c; while ((c = *uname++) != '\0') { hash = (hash << 4) + c; if ((tmp = (hash & 0xf0000000)) != 0) { hash ^= tmp >> 24; hash ^= tmp; } } return hash; } int eh_find_sym_hash(eh_obj_t *obj, const char *name, eh_sym_t *sym) { ElfW(Word) hash, *chain; ElfW(Sym) *esym; unsigned int bucket_idx, idx; if (!obj->hash) return ENOTSUP; if (obj->hash[0] == 0) return EAGAIN; hash = eh_hash_elf(name); /* First item in DT_HASH is nbucket, second is nchain. hash % nbucket gives us our bucket index. */ bucket_idx = obj->hash[2 + (hash % obj->hash[0])]; chain = &obj->hash[2 + obj->hash[0] + bucket_idx]; idx = 0; sym->sym = NULL; /* we have to check symtab[bucket_idx] first */ esym = &obj->symtab[bucket_idx]; if (esym->st_name) { if (!strcmp(&obj->strtab[esym->st_name], name)) sym->sym = esym; } while ((sym->sym == NULL) && (chain[idx] != STN_UNDEF)) { esym = &obj->symtab[chain[idx]]; if (esym->st_name) { if (!strcmp(&obj->strtab[esym->st_name], name)) sym->sym = esym; } idx++; } /* symbol not found */ if (sym->sym == NULL) return EAGAIN; sym->obj = obj; sym->name = &obj->strtab[sym->sym->st_name]; return 0; } Elf32_Word eh_hash_gnu(const char *name) { Elf32_Word hash = 5381; const unsigned char *uname = (const unsigned char *) name; int c; while ((c = *uname++) != '\0') hash = (hash << 5) + hash + c; return hash & 0xffffffff; } int eh_find_sym_gnu_hash(eh_obj_t *obj, const char *name, eh_sym_t *sym) { Elf32_Word *buckets, *chain_zero, *hasharr; ElfW(Addr) *bitmask, bitmask_word; Elf32_Word symbias, bitmask_nwords, bucket, nbuckets, bitmask_idxbits, shift; Elf32_Word hash, hashbit1, hashbit2; ElfW(Sym) *esym; if (!obj->gnu_hash) return ENOTSUP; if (obj->gnu_hash[0] == 0) return EAGAIN; sym->sym = NULL; /* Initialize our hash table stuff DT_GNU_HASH is(?): [nbuckets] [symbias] [bitmask_nwords] [shift] [bitmask_nwords * ElfW(Addr)] <- bitmask [nbuckets * Elf32_Word] <- buckets ...chains? - symbias... */ nbuckets = obj->gnu_hash[0]; symbias = obj->gnu_hash[1]; bitmask_nwords = obj->gnu_hash[2]; /* must be power of two */ bitmask_idxbits = bitmask_nwords - 1; shift = obj->gnu_hash[3]; bitmask = (ElfW(Addr) *) &obj->gnu_hash[4]; buckets = &obj->gnu_hash[4 + (__ELF_NATIVE_CLASS / 32) * bitmask_nwords]; chain_zero = &buckets[nbuckets] - symbias; /* hash our symbol */ hash = eh_hash_gnu(name); /* bitmask stuff... no idea really :D */ bitmask_word = bitmask[(hash / __ELF_NATIVE_CLASS) & bitmask_idxbits]; hashbit1 = hash & (__ELF_NATIVE_CLASS - 1); hashbit2 = (hash >> shift) & (__ELF_NATIVE_CLASS - 1); /* wtf this does actually? */ if (!((bitmask_word >> hashbit1) & (bitmask_word >> hashbit2) & 1)) return EAGAIN; /* locate bucket */ bucket = buckets[hash % nbuckets]; if (bucket == 0) return EAGAIN; /* and find match in chain */ hasharr = &chain_zero[bucket]; do { if (((*hasharr ^ hash) >> 1) == 0) { /* hash matches, but does the name? */ esym = &obj->symtab[hasharr - chain_zero]; if (esym->st_name) { if (!strcmp(&obj->strtab[esym->st_name], name)) { sym->sym = esym; break; } } } } while ((*hasharr++ & 1u) == 0); /* symbol not found */ if (sym->sym == NULL) return EAGAIN; sym->obj = obj; sym->name = &obj->strtab[sym->sym->st_name]; return 0; } int eh_iterate_sym(eh_obj_t *obj, eh_iterate_sym_callback_func callback, void *arg) { UNUSED(obj); UNUSED(callback); UNUSED(arg); return ENOTSUP; } int eh_find_next_dyn(eh_obj_t *obj, ElfW_Sword tag, int i, ElfW(Dyn) **next) { /* first from i + 1 to end, then from start to i - 1 */ int p; *next = NULL; p = i + 1; while (obj->dynamic[p].d_tag != DT_NULL) { if (obj->dynamic[p].d_tag == tag) { *next = &obj->dynamic[p]; return 0; } p++; } p = 0; while ((obj->dynamic[i].d_tag != DT_NULL) && (p < i)) { if (obj->dynamic[p].d_tag == tag) { *next = &obj->dynamic[p]; return 0; } p++; } return EAGAIN; } int eh_set_rela_plt(eh_obj_t *obj, int p, const char *sym, void *val) { ElfW(Rela) *rela = (ElfW(Rela) *) obj->dynamic[p].d_un.d_ptr; ElfW(Dyn) *relasize; unsigned int i; /* DT_PLTRELSZ contains PLT relocs size in bytes */ if (eh_find_next_dyn(obj, DT_PLTRELSZ, p, &relasize)) return EINVAL; /* b0rken elf :/ */ for (i = 0; i < relasize->d_un.d_val / sizeof(ElfW(Rela)); i++) { if (!obj->symtab[ELFW_R_SYM(rela[i].r_info)].st_name) continue; if (!strcmp(&obj->strtab[obj->symtab[ELFW_R_SYM(rela[i].r_info)].st_name], sym)) *((void **) (rela[i].r_offset + obj->addr)) = val; } return 0; } int eh_set_rel_plt(eh_obj_t *obj, int p, const char *sym, void *val) { ElfW(Rel) *rel = (ElfW(Rel) *) obj->dynamic[p].d_un.d_ptr; ElfW(Dyn) *relsize; unsigned int i; if (eh_find_next_dyn(obj, DT_PLTRELSZ, p, &relsize)) return EINVAL; /* b0rken elf :/ */ for (i = 0; i < relsize->d_un.d_val / sizeof(ElfW(Rel)); i++) { if (!obj->symtab[ELFW_R_SYM(rel[i].r_info)].st_name) continue; if (!strcmp(&obj->strtab[obj->symtab[ELFW_R_SYM(rel[i].r_info)].st_name], sym)) *((void **) (rel[i].r_offset + obj->addr)) = val; } return 0; } int eh_set_rel(eh_obj_t *obj, const char *sym, void *val) { /* Elf spec states that object is allowed to have multiple .rel.plt and .rela.plt tables, so we will support 'em - here. */ ElfW(Dyn) *pltrel; int ret, p = 0; while (obj->dynamic[p].d_tag != DT_NULL) { /* DT_JMPREL contains .rel.plt or .rela.plt */ if (obj->dynamic[p].d_tag == DT_JMPREL) { /* DT_PLTREL tells if it is Rela or Rel */ eh_find_next_dyn(obj, DT_PLTREL, p, &pltrel); if (pltrel->d_un.d_val == DT_RELA) { if ((ret = eh_set_rela_plt(obj, p, sym, val))) return ret; } else if (pltrel->d_un.d_val == DT_REL) { if ((ret = eh_set_rel_plt(obj, p, sym, val))) return ret; } else return EINVAL; } p++; } return 0; } int eh_iterate_rela_plt(eh_obj_t *obj, int p, eh_iterate_rel_callback_func callback, void *arg) { ElfW(Rela) *rela = (ElfW(Rela) *) obj->dynamic[p].d_un.d_ptr; ElfW(Dyn) *relasize; eh_rel_t rel; eh_sym_t sym; unsigned int i, ret; rel.sym = &sym; rel.rel = NULL; rel.obj = obj; if (eh_find_next_dyn(obj, DT_PLTRELSZ, p, &relasize)) return EINVAL; for (i = 0; i < relasize->d_un.d_val / sizeof(ElfW(Rela)); i++) { rel.rela = &rela[i]; sym.sym = &obj->symtab[ELFW_R_SYM(rel.rela->r_info)]; if (sym.sym->st_name) sym.name = &obj->strtab[sym.sym->st_name]; else sym.name = NULL; if ((ret = callback(&rel, arg))) return ret; } return 0; } int eh_iterate_rel_plt(eh_obj_t *obj, int p, eh_iterate_rel_callback_func callback, void *arg) { ElfW(Rel) *relp = (ElfW(Rel) *) obj->dynamic[p].d_un.d_ptr; ElfW(Dyn) *relsize; eh_rel_t rel; eh_sym_t sym; unsigned int i, ret; rel.sym = &sym; rel.rela = NULL; rel.obj = obj; if (eh_find_next_dyn(obj, DT_PLTRELSZ, p, &relsize)) return EINVAL; for (i = 0; i < relsize->d_un.d_val / sizeof(ElfW(Rel)); i++) { rel.rel = &relp[i]; sym.sym = &obj->symtab[ELFW_R_SYM(rel.rel->r_info)]; if (sym.sym->st_name) sym.name = &obj->strtab[sym.sym->st_name]; else sym.name = NULL; if ((ret = callback(&rel, arg))) return ret; } return 0; } int eh_iterate_rel(eh_obj_t *obj, eh_iterate_rel_callback_func callback, void *arg) { ElfW(Dyn) *pltrel; int ret, p = 0; while (obj->dynamic[p].d_tag != DT_NULL) { if (obj->dynamic[p].d_tag == DT_JMPREL) { eh_find_next_dyn(obj, DT_PLTREL, p, &pltrel); if (pltrel->d_un.d_val == DT_RELA) { if ((ret = eh_iterate_rela_plt(obj, p, callback, arg))) return ret; } else if (pltrel->d_un.d_val == DT_REL) { if ((ret = eh_iterate_rel_plt(obj, p, callback, arg))) return ret; } else return EINVAL; } p++; } return 0; } int eh_destroy_obj(eh_obj_t *obj) { obj->phdr = NULL; return 0; } /** \} */ obs-vkcapture-1.5.2/src/elfhacks.h000066400000000000000000000127521501231770600170350ustar00rootroot00000000000000/** * \file src/elfhacks.h * \brief elfhacks application interface * \author Pyry Haulos * \date 2007-2008 */ /* elfhacks.h -- Various ELF run-time hacks version 0.4.1, March 9th, 2008 Copyright (C) 2007-2008 Pyry Haulos This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Pyry Haulos */ #pragma once #include #include #include #ifdef __cplusplus extern "C" { #endif // #define __PUBLIC __attribute__ ((visibility ("default"))) #define __PUBLIC #ifdef __x86_64__ # define __elf64 #endif #ifdef __i386__ # define __elf32 #endif #ifdef __aarch64__ # define __elf64 #endif #ifdef __arm__ # define __elf32 #endif #ifdef __powerpc64__ # define __elf64 #endif #ifdef __powerpc__ # define __elf32 #endif #ifdef __elf64 # define ELFW_R_SYM ELF64_R_SYM # define ElfW_Sword Elf64_Sxword #else # ifdef __elf32 # define ELFW_R_SYM ELF32_R_SYM # define ElfW_Sword Elf32_Sword # else # error neither __elf32 nor __elf64 is defined # endif #endif /** * \defgroup elfhacks elfhacks * Elfhacks is a collection of functions that aim for retvieving * or modifying progam's dynamic linking information at run-time. * \{ */ /** * \brief elfhacks program object */ typedef struct { /** file name */ const char *name; /** base address in memory */ ElfW(Addr) addr; /** program headers */ const ElfW(Phdr) *phdr; /** number of program headers */ ElfW(Half) phnum; /** .dynamic */ ElfW(Dyn) *dynamic; /** .symtab */ ElfW(Sym) *symtab; /** .strtab */ const char *strtab; /** symbol hash table (DT_HASH) */ ElfW(Word) *hash; /** symbol hash table (DT_GNU_HASH) */ Elf32_Word *gnu_hash; } eh_obj_t; /** * \brief elfhacks symbol */ typedef struct { /** symbol name */ const char *name; /** corresponding ElfW(Sym) */ ElfW(Sym) *sym; /** elfhacks object this symbol is associated to */ eh_obj_t *obj; } eh_sym_t; /** * \brief elfhacks relocation */ typedef struct { /** symbol this relocation is associated to */ eh_sym_t *sym; /** corresponding ElfW(Rel) (NULL if this is Rela) */ ElfW(Rel) *rel; /** corresponding ElfW(Rela) (NULL if this is Rel) */ ElfW(Rela) *rela; /** elfhacks program object */ eh_obj_t *obj; } eh_rel_t; /** * \brief Iterate objects callback */ typedef int (*eh_iterate_obj_callback_func)(eh_obj_t *obj, void *arg); /** * \brief Iterate symbols callback */ typedef int (*eh_iterate_sym_callback_func)(eh_sym_t *sym, void *arg); /** * \brief Iterate relocations callback */ typedef int (*eh_iterate_rel_callback_func)(eh_rel_t *rel, void *arg); /** * \brief Initializes eh_obj_t for given soname * * Matching is done using fnmatch() so wildcards and other standard * filename metacharacters and expressions work. * * If soname is NULL, this function returns the main program object. * \param obj elfhacks object * \param soname object's soname (see /proc/pid/maps) or NULL for main * \return 0 on success otherwise a positive error code */ __PUBLIC int eh_find_obj(eh_obj_t *obj, const char *soname); /** * \brief Walk through list of objects * \param callback callback function * \param arg argument passed to callback function * \return 0 on success otherwise an error code */ __PUBLIC int eh_iterate_obj(eh_iterate_obj_callback_func callback, void *arg); /** * \brief Finds symbol in object's .dynsym and retrvieves its value. * \param obj elfhacks program object * \param name symbol to find * \param to returned value * \return 0 on success otherwise a positive error code */ __PUBLIC int eh_find_sym(eh_obj_t *obj, const char *name, void **to); /** * \brief Walk through list of symbols in object * \param obj elfhacks program object * \param callback callback function * \param arg argument passed to callback function * \return 0 on success otherwise an error code */ __PUBLIC int eh_iterate_sym(eh_obj_t *obj, eh_iterate_sym_callback_func callback, void *arg); /** * \brief Iterates through object's .rel.plt and .rela.plt and sets every * occurrence of some symbol to the specified value. * \param obj elfhacks program object * \param sym symbol to replace * \param val new value * \return 0 on success otherwise a positive error code */ __PUBLIC int eh_set_rel(eh_obj_t *obj, const char *sym, void *val); /** * \brief Walk through object's .rel.plt and .rela.plt * \param obj elfhacks program object * \param callback callback function * \param arg argument passed to callback function */ __PUBLIC int eh_iterate_rel(eh_obj_t *obj, eh_iterate_rel_callback_func callback, void *arg); /** * \brief Destroy eh_obj_t object. * \param obj elfhacks program object * \return 0 on success otherwise a positive error code */ __PUBLIC int eh_destroy_obj(eh_obj_t *obj); /** \} */ #ifdef __cplusplus } #endif obs-vkcapture-1.5.2/src/ext-screencopy-v1.xml000066400000000000000000000347161501231770600211260ustar00rootroot00000000000000 Copyright © 2021-2022 Andri Yngvason 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 allows clients to ask the compositor to copy part of the screen content to a client buffer. 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. This object is a manager which offers requests to start capturing from a source. Create a capturing session for an output If the "render_cursors" flag is set, cursors shall be composited onto the captured frame. The cursor should not be composited onto the frame if this flag is not set. This is the frame capturing interface. It keeps track of changes between frames. After a screencopy session is created, buffer_info events will be emitted from the compositor to tell the client which buffer types and formats are supported for reading from the session. When the client knows all the buffer attributes, it can create a buffer, attach it to the screencopy session using the "attach_buffer" request, set the buffer damage using the "damage_buffer" request and then call the "commit" request. After "commit" has been called, the next time that a buffer is committed by the compositor, the contents of that buffer will be copied to the one committed to the screencopy session. A series of events will be generated, ending with the "ready" event, which means that the buffer is ready to be used and a buffer may be committed to the session again. The "failed" event may be sent at any time. When this happens, the client must destroy the session. Depending on the failure reason, the client can create a new session to replace it. Provides information about buffer parameters that need to be used for the main image. This event is sent for every supported buffer type after the session is created. The stride parameter is invalid for dmabuf and may be set to 0. Provides information about buffer parameters that need to be used for the cursor image. This event is sent for every supported buffer type after the session is created, and it may be different for each seat/input_type pair. The default seat will be referred to as "default" within this protocol, whether it be named so by the compositor or not. The stride parameter is invalid for dmabuf and may be set to 0. This event is sent once when all buffer info events have been sent. Attach a buffer to the session. Apply damage to the buffer which is to be committed next. This is for optimisation purposes. The compositor may use this information to reduce copying. The client must submit damage if it's using multiple buffers. Otherwise, the server might not copy into damaged regions of the buffer. These coordinates originate in the upper left corner of the buffer. Attach a cursor buffer to the session. The cursor for the given seat and input type will be copied to the buffer. The cursor buffer may exceed the dimensions specified in the "cursor_buffer_info" event. The cursor image will be drawn in the top, left corner of the buffer. If seat is NULL, the default seat is used. Apply damage to a named cursor buffer which is to be committed next. The whole cursor buffer will be considered damaged. If seat is NULL, the default seat is used. Commit the screencopy session. The frame will be copied to the attached buffer on next output commit. A ready event is generated when the buffer is ready. If the "on_damage" flag is set, the compositor should skip sending new frames to the client until there is damage. Destroys the session. This request can be sent at any time by the client. This event is sent before the ready event and holds the output transform of the source buffer. Note: This only applies to the main buffer, not the cursor buffer. The cursor buffer must always be sent without any rotation. This event is sent before the ready event. It may be generated multiple times for each commit. The arguments describe a box around an area that has changed since the last ready event. These coordinates originate in the upper left corner of the buffer. Sent when a cursor enters the captured area. It shall be generated before the "cursor_info" event when and only when a cursor enters the area. Sent when a cursor leaves the captured area. No "cursor_info" event is generated for for the given cursor. This event is generated for each cursor buffer that was attached to the session and for which the cursor is currently focused on the session area. It is generated once for each cursor buffer before the ready event. Cursors outside the session area do not get captured and no event will be generated for them. If the cursor image has changed, the cursor buffer will have been updated and the "has_damage" argument will be set to 1; otherwise 0. The given position is the position of the cursor's hotspot and it is relative to the main buffer's top left corner in transformed buffer pixel coordinates. The hotspot coordinates are relative to the cursor buffers upper left corner. This event indicates that the attempted frame copy has failed. After receiving this event, the client must destroy the object. This event indicates the time at which the frame is presented to the output in system monotonic time. The timestamp is expressed as tv_sec_hi, tv_sec_lo, tv_nsec triples, each component being an unsigned 32-bit value. Whole seconds are in tv_sec which is a 64-bit value combined from tv_sec_hi and tv_sec_lo, and the additional fractional part in tv_nsec as nanoseconds. Hence, for valid timestamps tv_nsec must be in [0, 999999999]. Called as soon as the frame is copied, indicating it is available for reading. obs-vkcapture-1.5.2/src/glinject.c000066400000000000000000001125741501231770600170520ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #define _GNU_SOURCE #define GL_GLEXT_PROTOTYPES #include "glinject.h" #include "capture.h" #include "utils.h" #include "dlsym.h" #include "plugin-macros.h" #include "vklayer.h" #include #include #include #include #include static bool gl_seen = false; static bool vk_seen = false; static struct gl_funcs gl_f; static struct egl_funcs egl_f; static struct glx_funcs glx_f; static struct x11_funcs x11_f; static struct vk_funcs vk_f; static bool vkcapture_glvulkan = false; struct gl_data { void *display; void *surface; int width; int height; GLuint fbo; GLuint texture; void *image; int buf_fourcc; int buf_strides[4]; int buf_offsets[4]; uint64_t buf_modifier; uint32_t winid; int nfd; int buf_fds[4]; bool glx; unsigned long xpixmap; void *glxpixmap; VkInstance vkinst; VkPhysicalDevice vkphys_dev; VkDevice vkdev; VkImage vkimage; VkDeviceMemory vkmemory; uint8_t device_uuid[16]; bool valid; }; static struct gl_data data; #define GETADDR(s, p, func) \ p.func = (typeof(p.func))real_dlsym(RTLD_NEXT, #s #func); \ if (!p.func && handle) { \ p.func = (typeof(p.func))real_dlsym(handle, #s #func); \ } \ if (!p.func) { \ hlog("Failed to resolve " #s #func); \ return false; \ } \ #define GETVKADDR(func) GETADDR(vk, vk_f, func) #define GETEGLADDR(func) GETADDR(egl, egl_f, func) #define GETGLXADDR(func) GETADDR(glX, glx_f, func) #define GETPROCADDR(s, p, func) \ p.func = (typeof(p.func))p.GetProcAddress(#s #func); \ if (!p.func) { \ hlog("Failed to resolve " #s #func); \ return false; \ } \ #define GETGLPROCADDR(func) GETPROCADDR(gl, gl_f, func) #define GETEGLPROCADDR(func) GETPROCADDR(egl, egl_f, func) #define GETGLXPROCADDR(func) GETPROCADDR(glX, glx_f, func) #define GETXADDR(func) \ x11_f.func = (typeof(x11_f.func))real_dlsym(handle, #func); \ if (!x11_f.func) { \ hlog("Failed to resolve " #func); \ return false; \ } \ static bool gl_init_funcs(bool glx) { if (gl_seen) { return glx ? glx_f.valid && x11_f.valid : egl_f.valid; } hlog("Init %s %s (%s)", glx ? "GLX" : "EGL", PLUGIN_VERSION, #ifdef __x86_64__ "64bit"); #else "32bit"); #endif gl_seen = true; egl_f.valid = false; glx_f.valid = false; x11_f.valid = false; vkcapture_glvulkan = getenv("OBS_VKCAPTURE_GLVULKAN"); capture_init(); memset(&data, 0, sizeof(struct gl_data)); memset(data.buf_fds, -1, sizeof(data.buf_fds)); data.glx = glx; if (glx) { void *handle = dlopen("libGLX.so.0", RTLD_LAZY); if (!handle) { hlog("Failed to open libGLX.so.0"); return false; } GETGLXADDR(GetProcAddress); GETGLXADDR(GetProcAddressARB); GETGLXPROCADDR(DestroyContext); GETGLXPROCADDR(CreateWindow); GETGLXPROCADDR(SwapBuffers); GETGLXPROCADDR(SwapBuffersMscOML); GETGLXPROCADDR(CreatePixmap); GETGLXPROCADDR(DestroyPixmap); GETGLXPROCADDR(ChooseFBConfig); GETGLXPROCADDR(BindTexImageEXT); GETGLXPROCADDR(QueryDrawable); GETGLXPROCADDR(ChooseVisual); gl_f.GetProcAddress = glx_f.GetProcAddress; glx_f.valid = true; handle = dlopen("libX11.so.6", RTLD_LAZY); if (!handle) { hlog("Failed to open libX11.so.6"); return false; } GETXADDR(XCreatePixmap); GETXADDR(XFreePixmap); GETXADDR(XFree); handle = dlopen("libX11-xcb.so.1", RTLD_LAZY); if (!handle) { hlog("Failed to open libX11-xcb.so.1"); return false; } GETXADDR(XGetXCBConnection); handle = dlopen("libxcb-dri3.so.0", RTLD_LAZY); if (!handle) { hlog("Failed to open libxcb-dri3.so.0"); return false; } GETXADDR(xcb_dri3_buffers_from_pixmap); GETXADDR(xcb_dri3_buffers_from_pixmap_reply); GETXADDR(xcb_dri3_buffers_from_pixmap_reply_fds); GETXADDR(xcb_dri3_buffers_from_pixmap_strides); GETXADDR(xcb_dri3_buffers_from_pixmap_offsets); x11_f.valid = true; } else { void *handle = dlopen("libEGL.so.1", RTLD_LAZY); if (!handle) { hlog("Failed to open libEGL.so.1"); return false; } GETEGLADDR(GetProcAddress); GETEGLPROCADDR(DestroyContext); GETEGLPROCADDR(GetCurrentContext); GETEGLPROCADDR(CreateWindowSurface); GETEGLPROCADDR(CreateImage); GETEGLPROCADDR(DestroyImage); GETEGLPROCADDR(QuerySurface); GETEGLPROCADDR(SwapBuffers); GETEGLPROCADDR(ExportDMABUFImageQueryMESA); GETEGLPROCADDR(ExportDMABUFImageMESA); gl_f.GetProcAddress = egl_f.GetProcAddress; egl_f.valid = true; } GETGLPROCADDR(GenFramebuffers); GETGLPROCADDR(GenTextures); GETGLPROCADDR(TexImage2D); GETGLPROCADDR(TexParameteri); GETGLPROCADDR(GetIntegerv); GETGLPROCADDR(BindTexture); GETGLPROCADDR(DeleteFramebuffers); GETGLPROCADDR(DeleteTextures); GETGLPROCADDR(Enable); GETGLPROCADDR(Disable); GETGLPROCADDR(IsEnabled); GETGLPROCADDR(BindFramebuffer); GETGLPROCADDR(FramebufferTexture2D); GETGLPROCADDR(ReadBuffer); GETGLPROCADDR(DrawBuffer); GETGLPROCADDR(BlitFramebuffer); GETGLPROCADDR(GetError); GETGLPROCADDR(GetString); GETGLPROCADDR(GetUnsignedBytei_vEXT); GETGLPROCADDR(CreateMemoryObjectsEXT); GETGLPROCADDR(MemoryObjectParameterivEXT); GETGLPROCADDR(ImportMemoryFdEXT); GETGLPROCADDR(TexStorageMem2DEXT); GETGLPROCADDR(IsMemoryObjectEXT); data.valid = true; return true; } static bool vulkan_init_funcs() { if (vk_seen) { return vk_f.valid; } vk_seen = true; vk_f.valid = false; void *handle = dlopen("libvulkan.so.1", RTLD_LAZY); if (!handle) { hlog("Failed to open libvulkan.so.1"); return false; } GETVKADDR(GetInstanceProcAddr); GETVKADDR(GetDeviceProcAddr); GETVKADDR(CreateInstance); GETVKADDR(DestroyInstance); GETVKADDR(CreateDevice); GETVKADDR(DestroyDevice); vk_f.valid = true; return true; } #undef GETADDR #undef GETVKADDR #undef GETEGLADDR #undef GETPROCADDR #undef GETEGLPROCADDR #define GETVKPROC(p, d, func) \ vk_f.func = (typeof(vk_f.func))vk_f.p(data.d, "vk" #func); \ if (!vk_f.func) { \ hlog("Failed to resolve vk" #func); \ goto fail; \ } \ #define GETINSTPROC(func) GETVKPROC(GetInstanceProcAddr, vkinst, func) #define GETDEVPROC(func) GETVKPROC(GetDeviceProcAddr, vkdev, func) static bool vulkan_init() { if (data.vkdev) { return true; } if (!vulkan_init_funcs()) { return false; } gl_f.GetUnsignedBytei_vEXT(0x9597, 0, data.device_uuid); const char *instance_extensions[] = { VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, }; const char *device_extensions[] = { VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME, VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_MAINTENANCE1_EXTENSION_NAME, VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME, }; VkApplicationInfo appInfo = {}; appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; appInfo.pApplicationName = "OBS vkcapture"; appInfo.apiVersion = VK_API_VERSION_1_0; VkInstanceCreateInfo instanceInfo = {}; instanceInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; instanceInfo.pApplicationInfo = &appInfo; instanceInfo.enabledExtensionCount = sizeof(instance_extensions) / sizeof(*instance_extensions); instanceInfo.ppEnabledExtensionNames = instance_extensions; char *disable_vkcapture = getenv("DISABLE_OBS_VKCAPTURE"); setenv("DISABLE_OBS_VKCAPTURE", "1", 1); VkResult res = vk_f.CreateInstance(&instanceInfo, NULL, &data.vkinst); if (disable_vkcapture) { setenv("DISABLE_OBS_VKCAPTURE", disable_vkcapture, 1); } else { unsetenv("DISABLE_OBS_VKCAPTURE"); } if (res != VK_SUCCESS) { hlog("Vulkan: Failed to create instance %s", result_to_str(res)); return false; } GETINSTPROC(EnumeratePhysicalDevices); GETINSTPROC(GetPhysicalDeviceProperties2); GETINSTPROC(GetPhysicalDeviceMemoryProperties); GETINSTPROC(GetPhysicalDeviceFormatProperties2KHR); GETINSTPROC(GetPhysicalDeviceImageFormatProperties2KHR); uint32_t deviceCount = 16; VkPhysicalDevice physicalDevices[16]; res = vk_f.EnumeratePhysicalDevices(data.vkinst, &deviceCount, physicalDevices); if (res != VK_SUCCESS) { hlog("Vulkan: Failed to enumerate physical devices %s", result_to_str(res)); goto fail; } for (uint32_t i = 0; i < deviceCount; ++i) { VkPhysicalDeviceIDProperties propsID = {}; propsID.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; VkPhysicalDeviceProperties2 props = {}; props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; props.pNext = &propsID; vk_f.GetPhysicalDeviceProperties2(physicalDevices[i], &props); if (memcmp(data.device_uuid, propsID.deviceUUID, sizeof(data.device_uuid)) == 0) { data.vkphys_dev = physicalDevices[i]; break; } } if (!data.vkphys_dev) { hlog("Vulkan: Failed to find matching device"); goto fail; } float queuePriority = 1.0; VkDeviceQueueCreateInfo queueInfo = {}; queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; queueInfo.queueFamilyIndex = 0; queueInfo.queueCount = 1; queueInfo.pQueuePriorities = &queuePriority; VkDeviceCreateInfo deviceInfo = {}; deviceInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; deviceInfo.queueCreateInfoCount = 1; deviceInfo.pQueueCreateInfos = &queueInfo; deviceInfo.enabledExtensionCount = sizeof(device_extensions) / sizeof(*device_extensions); deviceInfo.ppEnabledExtensionNames = device_extensions; res = vk_f.CreateDevice(data.vkphys_dev, &deviceInfo, NULL, &data.vkdev); if (res != VK_SUCCESS) { /* Try without VK_EXT_image_drm_format_modifier */ deviceInfo.enabledExtensionCount--; res = vk_f.CreateDevice(data.vkphys_dev, &deviceInfo, NULL, &data.vkdev); } if (res != VK_SUCCESS) { hlog("Vulkan: Failed to create device %s", result_to_str(res)); goto fail; } GETDEVPROC(CreateImage); GETDEVPROC(DestroyImage); GETDEVPROC(AllocateMemory); GETDEVPROC(FreeMemory); GETDEVPROC(GetImageSubresourceLayout); GETDEVPROC(GetImageMemoryRequirements2KHR); GETDEVPROC(BindImageMemory2KHR); GETDEVPROC(GetMemoryFdKHR); vk_f.GetImageDrmFormatModifierPropertiesEXT = (PFN_vkGetImageDrmFormatModifierPropertiesEXT) vk_f.GetDeviceProcAddr(data.vkdev, "vkGetImageDrmFormatModifierPropertiesEXT"); if (!vk_f.GetImageDrmFormatModifierPropertiesEXT) { hlog("DRM format modifier support not available"); } return true; fail: if (data.vkdev) { vk_f.DestroyDevice(data.vkdev, NULL); data.vkdev = VK_NULL_HANDLE; } if (data.vkinst) { vk_f.DestroyInstance(data.vkinst, NULL); data.vkinst = VK_NULL_HANDLE; } return false; } #undef GETVKPROC #undef GETINSTPROC #undef GETDEVPROC static bool vulkan_shtex_init() { if (!vulkan_init()) { return false; } gl_f.GenFramebuffers(1, &data.fbo); if (data.fbo == 0) { hlog("Failed to initialize FBO"); return false; } const bool no_modifiers = capture_allocate_no_modifiers(); const bool linear = capture_allocate_linear(); const bool map_host = capture_allocate_map_host(); const bool same_device = capture_compare_device_uuid(data.device_uuid); hlog("Texture %s %ux%u", "GL_RGBA (Vulkan)", data.width, data.height); VkExternalMemoryImageCreateInfo ext_mem_image_info = {}; ext_mem_image_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; ext_mem_image_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT | VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; VkImageCreateInfo img_info = {}; img_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; img_info.pNext = &ext_mem_image_info; img_info.imageType = VK_IMAGE_TYPE_2D; img_info.format = VK_FORMAT_B8G8R8A8_UNORM; img_info.mipLevels = 1; img_info.arrayLayers = 1; img_info.samples = VK_SAMPLE_COUNT_1_BIT; img_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; img_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; img_info.extent.width = data.width; img_info.extent.height = data.height; img_info.extent.depth = 1; img_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; img_info.tiling = VK_IMAGE_TILING_LINEAR; int num_planes = 1; uint64_t *image_modifiers = NULL; VkImageDrmFormatModifierListCreateInfoEXT image_modifier_list = {}; struct VkDrmFormatModifierPropertiesEXT *modifier_props = NULL; uint32_t modifier_prop_count = 0; if (!no_modifiers && vk_f.GetImageDrmFormatModifierPropertiesEXT) { VkDrmFormatModifierPropertiesListEXT modifier_props_list = {}; modifier_props_list.sType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; VkFormatProperties2KHR format_props = {}; format_props.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; format_props.pNext = &modifier_props_list; vk_f.GetPhysicalDeviceFormatProperties2KHR(data.vkphys_dev, img_info.format, &format_props); modifier_props = malloc(modifier_props_list.drmFormatModifierCount * sizeof(struct VkDrmFormatModifierPropertiesEXT)); modifier_props_list.pDrmFormatModifierProperties = modifier_props; vk_f.GetPhysicalDeviceFormatProperties2KHR(data.vkphys_dev, img_info.format, &format_props); #ifndef NDEBUG hlog("Available modifiers:"); #endif for (uint32_t i = 0; i < modifier_props_list.drmFormatModifierCount; i++) { if (linear && modifier_props[i].drmFormatModifier != DRM_FORMAT_MOD_LINEAR) { continue; } VkPhysicalDeviceImageDrmFormatModifierInfoEXT mod_info = {}; mod_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; mod_info.drmFormatModifier = modifier_props[i].drmFormatModifier; mod_info.sharingMode = img_info.sharingMode; VkPhysicalDeviceImageFormatInfo2 format_info = {}; format_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; format_info.pNext = &mod_info; format_info.format = img_info.format; format_info.type = VK_IMAGE_TYPE_2D; format_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; format_info.usage = img_info.usage; format_info.flags = img_info.flags; VkImageFormatProperties2KHR format_props = {}; format_props.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; VkResult result = vk_f.GetPhysicalDeviceImageFormatProperties2KHR(data.vkphys_dev, &format_info, &format_props); if (result == VK_SUCCESS) { #ifndef NDEBUG hlog(" %d: modifier:%"PRIu64" planes:%d", i, modifier_props[i].drmFormatModifier, modifier_props[i].drmFormatModifierPlaneCount); #endif modifier_props[modifier_prop_count++] = modifier_props[i]; } } if (modifier_prop_count > 0) { image_modifiers = malloc(sizeof(uint64_t) * modifier_prop_count); for (uint32_t i = 0; i < modifier_prop_count; ++i) { image_modifiers[i] = modifier_props[i].drmFormatModifier; } image_modifier_list.sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; image_modifier_list.drmFormatModifierCount = modifier_prop_count; image_modifier_list.pDrmFormatModifiers = image_modifiers; img_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; ext_mem_image_info.pNext = &image_modifier_list; } else { hlog("No suitable DRM modifier found!"); } } VkResult res = vk_f.CreateImage(data.vkdev, &img_info, NULL, &data.vkimage); free(image_modifiers); if (res != VK_SUCCESS) { hlog("Vulkan: Failed to create image %s", result_to_str(res)); return false; } VkImageMemoryRequirementsInfo2 memri = {}; memri.image = data.vkimage; memri.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2; VkMemoryDedicatedRequirements mdr = {}; mdr.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS; VkMemoryRequirements2 memr = {}; memr.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; memr.pNext = &mdr; vk_f.GetImageMemoryRequirements2KHR(data.vkdev, &memri, &memr); /* -------------------------------------------------------- */ /* get memory type index */ VkPhysicalDeviceMemoryProperties pdmp; vk_f.GetPhysicalDeviceMemoryProperties(data.vkphys_dev, &pdmp); VkExportMemoryAllocateInfo memory_export_info = {}; memory_export_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; memory_export_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT | VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; VkMemoryDedicatedAllocateInfo memory_dedicated_info = {}; memory_dedicated_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; memory_dedicated_info.pNext = &memory_export_info; memory_dedicated_info.image = data.vkimage; VkMemoryAllocateInfo memi = {}; memi.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; memi.pNext = &memory_dedicated_info; memi.allocationSize = memr.memoryRequirements.size; bool allocated = false; uint32_t mem_req_bits = same_device ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; if (map_host) { mem_req_bits = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; } for (uint32_t i = 0; i < pdmp.memoryTypeCount; ++i) { if ((memr.memoryRequirements.memoryTypeBits & (1 << i)) && (pdmp.memoryTypes[i].propertyFlags & mem_req_bits) == mem_req_bits) { memi.memoryTypeIndex = i; res = vk_f.AllocateMemory(data.vkdev, &memi, NULL, &data.vkmemory); allocated = res == VK_SUCCESS; if (allocated) break; hlog("Vulkan: AllocateMemory failed (DEVICE_LOCAL): %s", result_to_str(res)); } } if (!allocated && !map_host) { /* Try again without DEVICE_LOCAL */ for (uint32_t i = 0; i < pdmp.memoryTypeCount; ++i) { if ((memr.memoryRequirements.memoryTypeBits & (1 << i)) && (pdmp.memoryTypes[i].propertyFlags & mem_req_bits) != mem_req_bits) { memi.memoryTypeIndex = i; res = vk_f.AllocateMemory(data.vkdev, &memi, NULL, &data.vkmemory); allocated = res == VK_SUCCESS; if (allocated) break; hlog("Vulkan: AllocateMemory failed (not DEVICE_LOCAL) %s", result_to_str(res)); } } } if (!allocated) { hlog("Failed to allocate memory of any type"); return false; } VkBindImageMemoryInfo bimi = {}; bimi.sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO; bimi.image = data.vkimage; bimi.memory = data.vkmemory; bimi.memoryOffset = 0; res = vk_f.BindImageMemory2KHR(data.vkdev, 1, &bimi); if (res != VK_SUCCESS) { hlog("Vulkan: BindImageMemory2KHR failed %s", result_to_str(res)); return false; } VkMemoryGetFdInfoKHR memFdInfo = {}; memFdInfo.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; memFdInfo.memory = data.vkmemory; memFdInfo.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR; int fd = -1; res = vk_f.GetMemoryFdKHR(data.vkdev, &memFdInfo, &fd); if (res != VK_SUCCESS) { hlog("Vulkan: GetMemoryFdKHR opaque_fd failed %s", result_to_str(res)); return false; } // Reset error while (gl_f.GetError() != GL_NO_ERROR) { } GLuint glmem; gl_f.CreateMemoryObjectsEXT(1, &glmem); GLint dedicated = GL_TRUE; gl_f.MemoryObjectParameterivEXT(glmem, GL_DEDICATED_MEMORY_OBJECT_EXT, &dedicated); gl_f.ImportMemoryFdEXT(glmem, memi.allocationSize, GL_HANDLE_TYPE_OPAQUE_FD_EXT, fd); gl_f.GenTextures(1, &data.texture); gl_f.BindTexture(GL_TEXTURE_2D, data.texture); gl_f.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_TILING_EXT, img_info.tiling == VK_IMAGE_TILING_LINEAR || linear ? GL_LINEAR_TILING_EXT : GL_OPTIMAL_TILING_EXT); gl_f.TexStorageMem2DEXT(GL_TEXTURE_2D, 1, GL_RGBA8, data.width, data.height, glmem, 0); gl_f.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); gl_f.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); if (!gl_f.IsMemoryObjectEXT(glmem) || gl_f.GetError() != GL_NO_ERROR) { hlog("Vulkan: OpenGL import failed"); return false; } memFdInfo.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; int dmabuf_fd = -1; res = vk_f.GetMemoryFdKHR(data.vkdev, &memFdInfo, &dmabuf_fd); if (res != VK_SUCCESS) { hlog("Vulkan: GetMemoryFdKHR dma_buf failed %s", result_to_str(res)); return false; } if (!no_modifiers && vk_f.GetImageDrmFormatModifierPropertiesEXT) { VkImageDrmFormatModifierPropertiesEXT image_mod_props = {}; image_mod_props.sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; res = vk_f.GetImageDrmFormatModifierPropertiesEXT(data.vkdev, data.vkimage, &image_mod_props); if (VK_SUCCESS != res) { hlog("GetImageDrmFormatModifierPropertiesEXT failed %s", result_to_str(res)); data.buf_modifier = DRM_FORMAT_MOD_INVALID; } else { data.buf_modifier = image_mod_props.drmFormatModifier; for (uint32_t i = 0; i < modifier_prop_count; ++i) { if (modifier_props[i].drmFormatModifier == data.buf_modifier) { num_planes = modifier_props[i].drmFormatModifierPlaneCount; break; } } } free(modifier_props); } else { data.buf_modifier = DRM_FORMAT_MOD_INVALID; } for (int i = 0; i < num_planes; i++) { VkImageSubresource sbr = {}; if (!no_modifiers && vk_f.GetImageDrmFormatModifierPropertiesEXT) { sbr.aspectMask = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT << i; } else { sbr.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; } sbr.mipLevel = 0; sbr.arrayLayer = 0; VkSubresourceLayout layout; vk_f.GetImageSubresourceLayout(data.vkdev, data.vkimage, &sbr, &layout); data.buf_fds[i] = i == 0 ? dmabuf_fd : os_dupfd_cloexec(dmabuf_fd); data.buf_strides[i] = layout.rowPitch; data.buf_offsets[i] = layout.offset; } data.nfd = num_planes; data.buf_fourcc = DRM_FORMAT_ABGR8888; #ifndef NDEBUG hlog("Got planes %d fd %d", data.nfd, data.buf_fds[0]); if (data.buf_modifier != DRM_FORMAT_MOD_INVALID) { hlog("Got modifier %"PRIu64, data.buf_modifier); } #endif return true; } static void querySurface(int *width, int *height) { if (data.glx) { unsigned w, h; glx_f.QueryDrawable(data.display, data.surface, P_GLX_WIDTH, &w); glx_f.QueryDrawable(data.display, data.surface, P_GLX_HEIGHT, &h); *width = w; *height = h; } else { egl_f.QuerySurface(data.display, data.surface, P_EGL_WIDTH, width); egl_f.QuerySurface(data.display, data.surface, P_EGL_HEIGHT, height); } } static void gl_free() { const bool was_capturing = data.nfd; if (data.nfd) { for (int i = 0; i < data.nfd; ++i) { close(data.buf_fds[i]); data.buf_fds[i] = -1; } data.nfd = 0; } if (data.image) { egl_f.DestroyImage(data.display, data.image); data.image = NULL; } if (data.xpixmap) { x11_f.XFreePixmap(data.display, data.xpixmap); data.xpixmap = 0; } if (data.glxpixmap) { glx_f.DestroyPixmap(data.display, data.glxpixmap); data.glxpixmap = NULL; } if (data.fbo) { gl_f.DeleteFramebuffers(1, &data.fbo); data.fbo = 0; } if (data.texture) { gl_f.DeleteTextures(1, &data.texture); data.texture = 0; } if (data.vkimage) { vk_f.DestroyImage(data.vkdev, data.vkimage, NULL); data.vkimage = VK_NULL_HANDLE; } if (data.vkmemory) { vk_f.FreeMemory(data.vkdev, data.vkmemory, NULL); data.vkmemory = VK_NULL_HANDLE; } capture_stop(); if (was_capturing) { hlog("------------------- opengl capture freed -------------------"); } } static void gl_copy_backbuffer(GLuint dst) { gl_f.Disable(GL_FRAMEBUFFER_SRGB); gl_f.BindFramebuffer(GL_READ_FRAMEBUFFER, 0); gl_f.BindFramebuffer(GL_DRAW_FRAMEBUFFER, data.fbo); gl_f.BindTexture(GL_TEXTURE_2D, dst); gl_f.FramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, dst, 0); gl_f.ReadBuffer(GL_BACK); gl_f.DrawBuffer(GL_COLOR_ATTACHMENT0); gl_f.BlitFramebuffer(0, 0, data.width, data.height, 0, 0, data.width, data.height, GL_COLOR_BUFFER_BIT, GL_LINEAR); } static void gl_shtex_capture() { bool scissorEnabled = gl_f.IsEnabled(GL_SCISSOR_TEST); if (scissorEnabled) { gl_f.Disable(GL_SCISSOR_TEST); } GLboolean last_srgb; GLint last_read_fbo; GLint last_draw_fbo; GLint last_tex; last_srgb = gl_f.IsEnabled(GL_FRAMEBUFFER_SRGB); gl_f.GetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &last_read_fbo); gl_f.GetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &last_draw_fbo); gl_f.GetIntegerv(GL_TEXTURE_BINDING_2D, &last_tex); gl_copy_backbuffer(data.texture); gl_f.BindTexture(GL_TEXTURE_2D, last_tex); gl_f.BindFramebuffer(GL_DRAW_FRAMEBUFFER, last_draw_fbo); gl_f.BindFramebuffer(GL_READ_FRAMEBUFFER, last_read_fbo); if (last_srgb) { gl_f.Enable(GL_FRAMEBUFFER_SRGB); } else { gl_f.Disable(GL_FRAMEBUFFER_SRGB); } if (scissorEnabled) { gl_f.Enable(GL_SCISSOR_TEST); } } static bool gl_shtex_init() { if (vkcapture_glvulkan) { return false; } if (data.glx) { // GLX on NVIDIA is all kinds of broken... const char *vendor = (const char*)gl_f.GetString(GL_VENDOR); if (strcmp(vendor, "NVIDIA Corporation") == 0) { return false; } } gl_f.GenFramebuffers(1, &data.fbo); if (data.fbo == 0) { hlog("Failed to initialize FBO"); return false; } hlog("Texture %s %ux%u", "GL_RGBA", data.width, data.height); gl_f.GenTextures(1, &data.texture); gl_f.BindTexture(GL_TEXTURE_2D, data.texture); gl_f.TexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, data.width, data.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL); gl_f.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); gl_f.TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); if (data.glx) { unsigned long root = P_DefaultRootWindow(data.display); data.xpixmap = x11_f.XCreatePixmap(data.display, root, data.width, data.height, 24); const int pixmap_config[] = { P_GLX_BIND_TO_TEXTURE_RGBA_EXT, true, P_GLX_DRAWABLE_TYPE, P_GLX_PIXMAP_BIT, P_GLX_BIND_TO_TEXTURE_TARGETS_EXT, P_GLX_TEXTURE_2D_BIT_EXT, P_GLX_DOUBLEBUFFER, false, P_GLX_RED_SIZE, 8, P_GLX_GREEN_SIZE, 8, P_GLX_BLUE_SIZE, 8, P_GLX_ALPHA_SIZE, 8, 0 }; int nelements; void **fbc = glx_f.ChooseFBConfig(data.display, P_DefaultScreen(data.display), pixmap_config, &nelements); if (nelements <= 0) { hlog("Failed to choose FBConfig"); goto fail; } const int pixmapAttribs[] = { P_GLX_TEXTURE_TARGET_EXT, P_GLX_TEXTURE_2D_EXT, P_GLX_TEXTURE_FORMAT_EXT, P_GLX_TEXTURE_FORMAT_RGBA_EXT, P_GLX_MIPMAP_TEXTURE_EXT, false, 0 }; data.glxpixmap = glx_f.CreatePixmap(data.display, fbc[0], data.xpixmap, pixmapAttribs); x11_f.XFree(fbc); glx_f.BindTexImageEXT(data.display, data.glxpixmap, P_GLX_FRONT_LEFT_EXT, NULL); void *xcb_con = x11_f.XGetXCBConnection(data.display); P_xcb_dri3_buffers_from_pixmap_cookie_t cookie = x11_f.xcb_dri3_buffers_from_pixmap(xcb_con, data.xpixmap); P_xcb_dri3_buffers_from_pixmap_reply_t *reply = x11_f.xcb_dri3_buffers_from_pixmap_reply(xcb_con, cookie, NULL); if (!reply) { hlog("Failed to get buffer from pixmap"); goto fail; } data.nfd = reply->nfd; for (uint8_t i = 0; i < reply->nfd; ++i) { data.buf_fds[i] = x11_f.xcb_dri3_buffers_from_pixmap_reply_fds(xcb_con, reply)[i]; data.buf_strides[i] = x11_f.xcb_dri3_buffers_from_pixmap_strides(reply)[i]; data.buf_offsets[i] = x11_f.xcb_dri3_buffers_from_pixmap_offsets(reply)[i]; } data.buf_fourcc = DRM_FORMAT_ARGB8888; data.buf_modifier = reply->modifier; free(reply); } else { data.image = egl_f.CreateImage(data.display, egl_f.GetCurrentContext(), P_EGL_GL_TEXTURE_2D, data.texture, NULL); if (!data.image) { hlog("Failed to create EGL image"); goto fail; } uint64_t modifiers[4]; const int queried = egl_f.ExportDMABUFImageQueryMESA(data.display, data.image, &data.buf_fourcc, &data.nfd, modifiers); if (!queried) { hlog("Failed to query dmabuf export"); goto fail; } data.buf_modifier = modifiers[0]; const int exported = egl_f.ExportDMABUFImageMESA(data.display, data.image, data.buf_fds, data.buf_strides, data.buf_offsets); if (!exported) { hlog("Failed dmabuf export"); goto fail; } } return true; fail: data.nfd = 0; if (data.fbo) { gl_f.DeleteFramebuffers(1, &data.fbo); data.fbo = 0; } if (data.xpixmap) { x11_f.XFreePixmap(data.display, data.xpixmap); data.xpixmap = 0; } if (data.glxpixmap) { glx_f.DestroyPixmap(data.display, data.glxpixmap); data.glxpixmap = NULL; } if (data.image) { egl_f.DestroyImage(data.display, data.image); data.image = NULL; } return false; } static bool gl_init(void *display, void *surface) { data.display = display; data.surface = surface; querySurface(&data.width, &data.height); if (data.glx) { data.winid = (uintptr_t)surface; } GLint last_tex; gl_f.GetIntegerv(GL_TEXTURE_BINDING_2D, &last_tex); bool init = gl_shtex_init(); if (!init) { init = vulkan_shtex_init(); } gl_f.BindTexture(GL_TEXTURE_2D, last_tex); if (!init) { hlog("shtex init failed"); return false; } capture_init_shtex(data.width, data.height, data.buf_fourcc, data.buf_strides, data.buf_offsets, data.buf_modifier, data.winid, /*flip*/true, 0, data.nfd, data.buf_fds); hlog("------------------ opengl capture started ------------------"); return true; } static void gl_capture(void *display, void *surface) { capture_update_socket(); if (capture_should_stop()) { gl_free(); } if (capture_should_init()) { if (!gl_init(display, surface)) { gl_free(); data.valid = false; hlog("gl_init failed"); } } if (capture_ready() && data.surface == surface) { int width, height; querySurface(&width, &height); if (data.height != height || data.width != width) { if (width != 0 && height != 0) { gl_free(); } return; } gl_shtex_capture(); } } /* ======================================================================== */ void *eglGetProcAddress(const char *procName); unsigned eglDestroyContext(void *display, void *context); unsigned eglSwapBuffers(void *display, void *surface); void *eglCreateWindowSurface(void *display, void *config, void *win, const intptr_t *attrib_list); static struct { void *func; const char *name; } egl_hooks_map[] = { #define ADD_HOOK(fn) { (void*)fn, #fn } ADD_HOOK(eglGetProcAddress), ADD_HOOK(eglSwapBuffers), ADD_HOOK(eglDestroyContext), ADD_HOOK(eglCreateWindowSurface) #undef ADD_HOOK }; void *obs_vkcapture_eglGetProcAddress(const char *name) { for (int i = 0; i < sizeof(egl_hooks_map) / sizeof(egl_hooks_map[0]); ++i) { if (strcmp(name, egl_hooks_map[i].name) == 0) { return egl_hooks_map[i].func; } } return NULL; } void *eglGetProcAddress(const char *procName) { if (!gl_init_funcs(/*glx*/false)) { return NULL; } void *func = obs_vkcapture_eglGetProcAddress(procName); return func ? func : egl_f.GetProcAddress(procName); } unsigned eglDestroyContext(void *display, void *context) { if (!gl_init_funcs(/*glx*/false)) { return 0; } gl_free(); return egl_f.DestroyContext(display, context); } unsigned eglSwapBuffers(void *display, void *surface) { if (!gl_init_funcs(/*glx*/false)) { return 0; } if (data.valid) { gl_capture(display, surface); } return egl_f.SwapBuffers(display, surface); } void *eglCreateWindowSurface(void *display, void *config, void *win, const intptr_t *attrib_list) { if (!gl_init_funcs(/*glx*/false)) { return 0; } void *res = egl_f.CreateWindowSurface(display, config, win, attrib_list); if (res) { data.winid = (uintptr_t)win; } return res; } /* ======================================================================== */ void *glXGetProcAddress(const char *procName); void *glXGetProcAddressARB(const char *procName); void glXDestroyContext(void *display, void *context); bool glXCreateWindow(void *display, void *config, unsigned long win, const int *attribList); void glXSwapBuffers(void *display, void *surface); int64_t glXSwapBuffersMscOML(void *display, void *drawable, int64_t target_msc, int64_t divisor, int64_t remainder); static struct { void *func; const char *name; } glx_hooks_map[] = { #define ADD_HOOK(fn) { (void*)fn, #fn } ADD_HOOK(glXGetProcAddress), ADD_HOOK(glXGetProcAddressARB), ADD_HOOK(glXSwapBuffers), ADD_HOOK(glXSwapBuffersMscOML), ADD_HOOK(glXDestroyContext), ADD_HOOK(glXCreateWindow) #undef ADD_HOOK }; void *obs_vkcapture_glXGetProcAddress(const char *name) { for (int i = 0; i < sizeof(glx_hooks_map) / sizeof(glx_hooks_map[0]); ++i) { if (strcmp(name, glx_hooks_map[i].name) == 0) { return glx_hooks_map[i].func; } } return NULL; } void *glXGetProcAddress(const char *procName) { if (!gl_init_funcs(/*glx*/true)) { return NULL; } void *func = obs_vkcapture_glXGetProcAddress(procName); return func ? func : glx_f.GetProcAddress(procName); } void *glXGetProcAddressARB(const char *procName) { if (!gl_init_funcs(/*glx*/true)) { return NULL; } void *func = obs_vkcapture_glXGetProcAddress(procName); return func ? func : glx_f.GetProcAddressARB(procName); } void glXDestroyContext(void *display, void *context) { if (!gl_init_funcs(/*glx*/true)) { return; } gl_free(); glx_f.DestroyContext(display, context); } bool glXCreateWindow(void *display, void *config, unsigned long win, const int *attribList) { if (!gl_init_funcs(/*glx*/true)) { return false; } gl_free(); return glx_f.CreateWindow(display, config, win, attribList); } void glXSwapBuffers(void *display, void *drawable) { if (!gl_init_funcs(/*glx*/true)) { return; } if (data.valid) { gl_capture(display, drawable); } glx_f.SwapBuffers(display, drawable); } int64_t glXSwapBuffersMscOML(void *display, void *drawable, int64_t target_msc, int64_t divisor, int64_t remainder) { if (!gl_init_funcs(/*glx*/true)) { return 0; } if (data.valid) { gl_capture(display, drawable); } return glx_f.SwapBuffersMscOML(display, drawable, target_msc, divisor, remainder); } obs-vkcapture-1.5.2/src/glinject.h000066400000000000000000000176651501231770600170640ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #pragma once #include #include #include #include #include struct gl_funcs { void *(*GetProcAddress)(const char*); PFNGLGENFRAMEBUFFERSPROC GenFramebuffers; PFNGLGENTEXTURESEXTPROC GenTextures; PFNGLTEXIMAGE2DPROC TexImage2D; PFNGLTEXPARAMETERIPROC TexParameteri; PFNGLGETINTEGERVPROC GetIntegerv; PFNGLBINDTEXTUREPROC BindTexture; PFNGLDELETEFRAMEBUFFERSPROC DeleteFramebuffers; PFNGLDELETETEXTURESPROC DeleteTextures; PFNGLENABLEPROC Enable; PFNGLDISABLEPROC Disable; PFNGLISENABLEDPROC IsEnabled; PFNGLBINDFRAMEBUFFERPROC BindFramebuffer; PFNGLFRAMEBUFFERTEXTURE2DPROC FramebufferTexture2D; PFNGLREADBUFFERPROC ReadBuffer; PFNGLDRAWBUFFERPROC DrawBuffer; PFNGLBLITFRAMEBUFFERPROC BlitFramebuffer; PFNGLGETERRORPROC GetError; PFNGLGETSTRINGPROC GetString; PFNGLGETUNSIGNEDBYTEI_VEXTPROC GetUnsignedBytei_vEXT; PFNGLCREATEMEMORYOBJECTSEXTPROC CreateMemoryObjectsEXT; PFNGLMEMORYOBJECTPARAMETERIVEXTPROC MemoryObjectParameterivEXT; PFNGLIMPORTMEMORYFDEXTPROC ImportMemoryFdEXT; PFNGLTEXSTORAGEMEM2DEXTPROC TexStorageMem2DEXT; PFNGLISMEMORYOBJECTEXTPROC IsMemoryObjectEXT; }; #define P_EGL_HEIGHT 0x3056 #define P_EGL_WIDTH 0x3057 #define P_EGL_GL_TEXTURE_2D 0x30B1 struct egl_funcs { void *(*GetProcAddress)(const char*); unsigned (*DestroyContext)(void *display, void *context); void *(*GetCurrentContext)(); void *(*CreateWindowSurface)(void *display, void *config, void *win, const intptr_t *attrib_list); void *(*CreateImage)(void *display, void *context, unsigned target, intptr_t buffer, const intptr_t *attrib_list); unsigned (*DestroyImage)(void *display, void *image); unsigned (*QuerySurface)(void *display, void *surface, int attribute, int *value); unsigned (*SwapBuffers)(void *display, void *surface); unsigned (*ExportDMABUFImageQueryMESA)(void *dpy, void *image, int *fourcc, int *num_planes, uint64_t *modifiers); unsigned (*ExportDMABUFImageMESA)(void *dpy, void *image, int *fds, int *strides, int *offsets); bool valid; }; #define P_GLX_WIDTH 0x801D #define P_GLX_HEIGHT 0x801E #define P_GLX_BIND_TO_TEXTURE_RGBA_EXT 0x20D1 #define P_GLX_DRAWABLE_TYPE 0x8010 #define P_GLX_PIXMAP_BIT 0x00000002 #define P_GLX_BIND_TO_TEXTURE_TARGETS_EXT 0x20D3 #define P_GLX_TEXTURE_2D_BIT_EXT 0x00000002 #define P_GLX_DOUBLEBUFFER 5 #define P_GLX_TEXTURE_TARGET_EXT 0x20D6 #define P_GLX_TEXTURE_2D_EXT 0x20DC #define P_GLX_TEXTURE_FORMAT_EXT 0x20D5 #define P_GLX_TEXTURE_FORMAT_RGBA_EXT 0x20DA #define P_GLX_FRONT_LEFT_EXT 0x20DE #define P_GLX_RED_SIZE 8 #define P_GLX_GREEN_SIZE 9 #define P_GLX_BLUE_SIZE 10 #define P_GLX_ALPHA_SIZE 11 #define P_GLX_MIPMAP_TEXTURE_EXT 0x20D7 struct glx_funcs { void *(*GetProcAddress)(const char*); void *(*GetProcAddressARB)(const char*); void (*DestroyContext)(void *display, void *context); bool (*CreateWindow)(void *display, void *config, unsigned long win, const int *attribList); void (*SwapBuffers)(void *display, void *drawable); int64_t (*SwapBuffersMscOML)(void *display, void *drawable, int64_t target_msc, int64_t divisor, int64_t remainder); void *(*CreatePixmap)(void *display, void *config, unsigned long pixmap, const int *attribList); void (*DestroyPixmap)(void *display, void *pixmap); void *(*ChooseFBConfig)(void *display, int screen, const int *attribList, int *nitems); void (*BindTexImageEXT)(void *display, void *drawable, int buffer, const int *attribList); void (*QueryDrawable)(void *display, void *drawable, int attribute, unsigned *value); void *(*ChooseVisual)(void *display, int screen, int *attribList); bool valid; }; #define P_DefaultRootWindow(dpy) (P_ScreenOfDisplay(dpy,P_DefaultScreen(dpy))->root) #define P_ScreenOfDisplay(dpy, scr) (&((P_XPrivDisplay)(dpy))->screens[scr]) #define P_DefaultScreen(dpy) (((P_XPrivDisplay)(dpy))->default_screen) typedef struct { void *ext_data; void *display; unsigned long root; } P_Screen; typedef struct { void *ext_data; void *private1; int fd; int private2; int proto_major_version; int proto_minor_version; char *vendor; unsigned long private3; unsigned long private4; unsigned long private5; int private6; void *resource_alloc; int byte_order; int bitmap_unit; int bitmap_pad; int bitmap_bit_order; int nformats; void *pixmap_format; int private8; int release; void *private9, *private10; int qlen; unsigned long last_request_read; unsigned long request; char *private11; char *private12; char *private13; char *private14; unsigned max_request_size; void *db; void *private15; char *display_name; int default_screen; int nscreens; P_Screen *screens; } *P_XPrivDisplay; typedef struct P_xcb_dri3_buffers_from_pixmap_reply_t { uint8_t response_type; uint8_t nfd; uint16_t sequence; uint32_t length; uint16_t width; uint16_t height; uint8_t pad0[4]; uint64_t modifier; uint8_t depth; uint8_t bpp; uint8_t pad1[6]; } P_xcb_dri3_buffers_from_pixmap_reply_t; typedef struct P_xcb_dri3_buffers_from_pixmap_cookie_t { unsigned int sequence; } P_xcb_dri3_buffers_from_pixmap_cookie_t; struct x11_funcs { unsigned long (*XCreatePixmap)(void *display, unsigned long drawable, unsigned width, unsigned height, unsigned depth); int (*XFreePixmap)(void *display, unsigned long pixmap); int (*XFree)(void *data); void *(*XGetXCBConnection)(void *display); P_xcb_dri3_buffers_from_pixmap_cookie_t (*xcb_dri3_buffers_from_pixmap)(void *c, unsigned long pixmap); P_xcb_dri3_buffers_from_pixmap_reply_t *(*xcb_dri3_buffers_from_pixmap_reply)(void *c, P_xcb_dri3_buffers_from_pixmap_cookie_t cookie, void *error); int *(*xcb_dri3_buffers_from_pixmap_reply_fds)(void *c, P_xcb_dri3_buffers_from_pixmap_reply_t *reply); uint32_t *(*xcb_dri3_buffers_from_pixmap_strides)(P_xcb_dri3_buffers_from_pixmap_reply_t *reply); uint32_t *(*xcb_dri3_buffers_from_pixmap_offsets)(P_xcb_dri3_buffers_from_pixmap_reply_t *reply); bool valid; }; struct vk_funcs { PFN_vkGetInstanceProcAddr GetInstanceProcAddr; PFN_vkGetDeviceProcAddr GetDeviceProcAddr; PFN_vkCreateInstance CreateInstance; PFN_vkDestroyInstance DestroyInstance; PFN_vkCreateDevice CreateDevice; PFN_vkDestroyDevice DestroyDevice; PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices; PFN_vkGetPhysicalDeviceProperties2 GetPhysicalDeviceProperties2; PFN_vkGetPhysicalDeviceMemoryProperties GetPhysicalDeviceMemoryProperties; PFN_vkGetPhysicalDeviceFormatProperties2KHR GetPhysicalDeviceFormatProperties2KHR; PFN_vkGetPhysicalDeviceImageFormatProperties2KHR GetPhysicalDeviceImageFormatProperties2KHR; PFN_vkCreateImage CreateImage; PFN_vkDestroyImage DestroyImage; PFN_vkAllocateMemory AllocateMemory; PFN_vkFreeMemory FreeMemory; PFN_vkGetImageSubresourceLayout GetImageSubresourceLayout; PFN_vkGetImageMemoryRequirements2KHR GetImageMemoryRequirements2KHR; PFN_vkGetImageDrmFormatModifierPropertiesEXT GetImageDrmFormatModifierPropertiesEXT; PFN_vkBindImageMemory2KHR BindImageMemory2KHR; PFN_vkGetMemoryFdKHR GetMemoryFdKHR; bool valid; }; obs-vkcapture-1.5.2/src/glinject.version000066400000000000000000000001321501231770600202770ustar00rootroot00000000000000{ global: dlsym; dlvsym; glX*; egl*; local: *; }; obs-vkcapture-1.5.2/src/obs-gamecapture.in000077500000000000000000000005471501231770600205140ustar00rootroot00000000000000#!/bin/sh if [ "$#" -eq 0 ]; then programname=`basename "$0"` echo "ERROR: No program supplied" echo echo "Usage: $programname " exit 1 fi OBS_GLCAPTURE_LIB="@CMAKE_INSTALL_PREFIX@/\$LIB/obs_glcapture/libobs_glcapture.so" exec env LD_PRELOAD="${LD_PRELOAD}${LD_PRELOAD:+:}${OBS_GLCAPTURE_LIB}" \ OBS_VKCAPTURE=1 \ "$@" obs-vkcapture-1.5.2/src/obs-glcapture000077500000000000000000000001301501231770600175640ustar00rootroot00000000000000#!/bin/sh echo "WARNING: Please use obs-gamecapture instead." exec obs-gamecapture "$@" obs-vkcapture-1.5.2/src/obs-vkcapture000077500000000000000000000001301501231770600176020ustar00rootroot00000000000000#!/bin/sh echo "WARNING: Please use obs-gamecapture instead." exec obs-gamecapture "$@" obs-vkcapture-1.5.2/src/obs_vkcapture.json.in000066400000000000000000000011551501231770600212460ustar00rootroot00000000000000{ "file_format_version": "1.1.2", "layer": { "name": "VK_LAYER_OBS_vkcapture@LAYER_SUFFIX@", "type": "GLOBAL", "library_path": "@CMAKE_INSTALL_FULL_LIBDIR@/libVkLayer_obs_vkcapture.so", "api_version": "@Vulkan_VERSION@", "implementation_version": "1", "description": "OBS Linux game capture", "functions": { "vkNegotiateLoaderLayerInterfaceVersion": "OBS_Negotiate" }, "enable_environment": { "OBS_VKCAPTURE": "1" }, "disable_environment": { "DISABLE_OBS_VKCAPTURE": "1" } } } obs-vkcapture-1.5.2/src/utils.h000066400000000000000000000030251501231770600164060ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #pragma once #include #include #include #include #include #include static inline int os_dupfd_cloexec(int fd) { return fcntl(fd, F_DUPFD_CLOEXEC, 3); } static inline int64_t os_time_get_nano(void) { struct timespec tv; clock_gettime( #if defined(CLOCK_MONOTONIC_RAW) CLOCK_MONOTONIC_RAW #elif defined(CLOCK_MONOTONIC_FAST) CLOCK_MONOTONIC_FAST #else CLOCK_MONOTONIC #endif , &tv); return tv.tv_nsec + tv.tv_sec * INT64_C(1000000000); } static bool hlog_quiet(void) { static int quiet = -1; if (quiet == -1) { const char *q = getenv("OBS_VKCAPTURE_QUIET"); quiet = q && atoi(q) == 1; } return quiet; } #define hlog(msg, ...) if (!hlog_quiet()) fprintf(stderr, "[obs-vkcapture] " msg "\n", ##__VA_ARGS__) obs-vkcapture-1.5.2/src/vkcapture.c000066400000000000000000000743701501231770600172600ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #define _GNU_SOURCE #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "utils.h" #include "capture.h" #include "plugin-macros.h" #if HAVE_X11_XCB #include "xcursor-xcb.h" static xcb_connection_t *xcb = NULL; #endif #if HAVE_WAYLAND #include "wlcursor.h" static struct wl_display *wl_display = NULL; static wl_cursor_t *wlcursor = NULL; #endif #include static uint8_t gl_device_uuid[16]; void (*p_glGetUnsignedBytei_vEXT)(unsigned int target, unsigned int index, unsigned char *data) = NULL; enum vkcapture_import_attempt { IMPORT_DEFAULT = 0, IMPORT_NO_MODIFIERS = 1, IMPORT_LINEAR = 2, IMPORT_LINEAR_HOST_MAPPED = 3, IMPORT_FAILURES_MAX = IMPORT_LINEAR_HOST_MAPPED, }; typedef struct { int id; int sockfd; int activated; int buf_id; int buf_fds[4]; int import_failures; size_t map_size; void *map_memory; uint64_t timeout; bool unresponsive; struct capture_client_data cdata; struct capture_texture_data tdata; } vkcapture_client_t; static struct { bool quit; int eventfd; pthread_t thread; pthread_mutex_t mutex; DARRAY(struct pollfd) fds; DARRAY(vkcapture_client_t) clients; } server; static int source_instances = 0; typedef struct { obs_source_t *source; gs_texture_t *texture; #if HAVE_X11_XCB xcb_xcursor_t *xcursor; uint32_t root_winid; #endif bool show_cursor; bool allow_transparency; bool force_hdr; bool window_match; bool window_exclude; const char *window; int buf_id; int client_id; struct capture_texture_data tdata; } vkcapture_source_t; static bool server_wakeup(); static const char *import_attempt_str(enum vkcapture_import_attempt attempt) { switch (attempt) { case IMPORT_DEFAULT: return "default"; case IMPORT_NO_MODIFIERS: return "no modifiers"; case IMPORT_LINEAR: return "linear"; case IMPORT_LINEAR_HOST_MAPPED: return "linear host mapped"; default: return "invalid"; } } static int64_t clock_ns() { struct timespec t; clock_gettime(CLOCK_MONOTONIC, &t); return t.tv_sec * 1000000000 + t.tv_nsec; } static const struct { int32_t drm; enum gs_color_format gs; } gs_format_table[] = { { DRM_FORMAT_ARGB8888, GS_BGRA }, { DRM_FORMAT_XRGB8888, GS_BGRX }, { DRM_FORMAT_ABGR8888, GS_RGBA }, { DRM_FORMAT_XBGR8888, GS_RGBA }, { DRM_FORMAT_ARGB2101010, GS_R10G10B10A2 }, { DRM_FORMAT_XRGB2101010, GS_R10G10B10A2 }, { DRM_FORMAT_ABGR2101010, GS_R10G10B10A2 }, { DRM_FORMAT_XBGR2101010, GS_R10G10B10A2 }, { DRM_FORMAT_ABGR16161616, GS_RGBA16 }, { DRM_FORMAT_XBGR16161616, GS_RGBA16 }, { DRM_FORMAT_ABGR16161616F, GS_RGBA16F }, { DRM_FORMAT_XBGR16161616F, GS_RGBA16F }, }; static enum gs_color_format drm_format_to_gs(int32_t drm) { for (size_t i = 0; i < sizeof(gs_format_table) / sizeof(gs_format_table[0]); ++i) { if (gs_format_table[i].drm == drm) { return gs_format_table[i].gs; } } return GS_UNKNOWN; } static void cursor_create(vkcapture_source_t *ctx) { bool try_xcb = false; #if HAVE_WAYLAND if (obs_get_nix_platform() == OBS_NIX_PLATFORM_WAYLAND) { if (!wl_display) { wl_display = wl_display_connect(NULL); if (!wl_display) { blog(LOG_ERROR, "Unable to open Wayland display!"); } } if (wl_display && !wlcursor) { wlcursor = wl_cursor_init(wl_display); if (!wlcursor) { try_xcb = true; } } } #endif #if HAVE_X11_XCB if (try_xcb || obs_get_nix_platform() == OBS_NIX_PLATFORM_X11_EGL) { if (!xcb) { xcb = xcb_connect(NULL, NULL); if (!xcb || xcb_connection_has_error(xcb)) { blog(LOG_ERROR, "Unable to open X display!"); } } if (xcb) { ctx->xcursor = xcb_xcursor_init(xcb); } } #endif } static void cursor_destroy(vkcapture_source_t *ctx) { #if HAVE_X11_XCB if (ctx->xcursor) { obs_enter_graphics(); xcb_xcursor_destroy(ctx->xcursor); obs_leave_graphics(); } if (!source_instances) { if (xcb) { xcb_disconnect(xcb); xcb = NULL; } } #endif #if HAVE_WAYLAND if (!source_instances) { blog(LOG_INFO, "destroy"); if (wlcursor) { wl_cursor_destroy(wlcursor); wlcursor = NULL; } if (wl_display) { wl_display_disconnect(wl_display); wl_display = NULL; } } #endif } static bool cursor_enabled(vkcapture_source_t *ctx) { #if HAVE_X11_XCB if (ctx->xcursor) { return true; } #endif #if HAVE_WAYLAND if (wlcursor) { return true; } #endif return false; } static void cursor_update(vkcapture_source_t *ctx) { #if HAVE_X11_XCB if (ctx->xcursor) { if (!ctx->root_winid && ctx->tdata.winid) { xcb_query_tree_cookie_t tre_c = xcb_query_tree_unchecked(xcb, ctx->tdata.winid); xcb_query_tree_reply_t *tre_r = xcb_query_tree_reply(xcb, tre_c, NULL); if (tre_r) { ctx->root_winid = tre_r->root; free(tre_r); } } xcb_translate_coordinates_cookie_t tr_c; if (ctx->root_winid && ctx->tdata.winid) { tr_c = xcb_translate_coordinates_unchecked(xcb, ctx->tdata.winid, ctx->root_winid, 0, 0); } xcb_xfixes_get_cursor_image_cookie_t cur_c = xcb_xfixes_get_cursor_image_unchecked(xcb); xcb_xfixes_get_cursor_image_reply_t *cur_r = xcb_xfixes_get_cursor_image_reply(xcb, cur_c, NULL); if (ctx->root_winid && ctx->tdata.winid) { xcb_translate_coordinates_reply_t *tr_r = xcb_translate_coordinates_reply(xcb, tr_c, NULL); if (tr_r) { xcb_xcursor_offset(ctx->xcursor, tr_r->dst_x, tr_r->dst_y); free(tr_r); } } xcb_xcursor_update(ctx->xcursor, cur_r); free(cur_r); } #endif #if HAVE_WAYLAND if (wlcursor) { struct pollfd fd; fd.fd = wl_display_get_fd(wl_display); fd.events = POLLIN; if (poll(&fd, 1, 0) > 0) { wl_display_dispatch(wl_display); } wl_display_flush(wl_display); } #endif } static void cursor_render(vkcapture_source_t *ctx) { #if HAVE_X11_XCB if (ctx->xcursor) { xcb_xcursor_render(ctx->xcursor); } #endif #if HAVE_WAYLAND if (wlcursor) { wl_cursor_render(wlcursor); } #endif } static void destroy_texture(vkcapture_source_t *ctx) { if (!ctx->texture) { return; } obs_enter_graphics(); gs_texture_destroy(ctx->texture); obs_leave_graphics(); ctx->texture = NULL; ctx->buf_id = 0; memset(&ctx->tdata, 0, sizeof(ctx->tdata)); } static void vkcapture_source_destroy(void *data) { --source_instances; vkcapture_source_t *ctx = data; destroy_texture(ctx); cursor_destroy(ctx); bfree(ctx); } static void vkcapture_source_update(void *data, obs_data_t *settings) { vkcapture_source_t *ctx = data; ctx->show_cursor = obs_data_get_bool(settings, "show_cursor"); ctx->allow_transparency = obs_data_get_bool(settings, "allow_transparency"); ctx->force_hdr = obs_data_get_bool(settings, "force_hdr"); ctx->window_match = false; ctx->window_exclude = false; ctx->window = obs_data_get_string(settings, "window"); if (!strncmp(ctx->window, "exclude=", 8)) { ctx->window_exclude = true; ctx->window = ctx->window + 8; } else { ctx->window_match = true; } if (!strlen(ctx->window)) { ctx->window = NULL; } } static void *vkcapture_source_create(obs_data_t *settings, obs_source_t *source) { ++source_instances; vkcapture_source_t *ctx = bzalloc(sizeof(vkcapture_source_t)); ctx->source = source; vkcapture_source_update(ctx, settings); cursor_create(ctx); UNUSED_PARAMETER(settings); return ctx; } static vkcapture_client_t *find_matching_client(vkcapture_source_t *ctx) { vkcapture_client_t *client = NULL; if (ctx->window) { for (size_t i = 0; i < server.clients.num; i++) { vkcapture_client_t *c = server.clients.array + i; bool match = !strcmp(c->cdata.exe, ctx->window); if ((ctx->window_match && match) || (ctx->window_exclude && !match)) { client = c; break; } } } else if (server.clients.num) { client = server.clients.array; } return client; } static vkcapture_client_t *find_client_by_id(int id) { vkcapture_client_t *client = NULL; for (size_t i = 0; i < server.clients.num; i++) { vkcapture_client_t *c = server.clients.array + i; if (c->id == id) { client = c; break; } } return client; } static void fill_capture_control_data(struct capture_control_data *msg, vkcapture_client_t *client) { if (!p_glGetUnsignedBytei_vEXT) { obs_enter_graphics(); p_glGetUnsignedBytei_vEXT = (typeof(p_glGetUnsignedBytei_vEXT)) eglGetProcAddress("glGetUnsignedBytei_vEXT"); if (p_glGetUnsignedBytei_vEXT) { p_glGetUnsignedBytei_vEXT(0x9597, 0, gl_device_uuid); } obs_leave_graphics(); } msg->no_modifiers = !!(client->import_failures == IMPORT_NO_MODIFIERS); msg->linear = !!(client->import_failures == IMPORT_LINEAR || client->import_failures == IMPORT_LINEAR_HOST_MAPPED); msg->map_host = !!(client->import_failures == IMPORT_LINEAR_HOST_MAPPED); memcpy(msg->device_uuid, gl_device_uuid, 16); } static void activate_client(vkcapture_source_t *ctx, vkcapture_client_t *client, bool activate) { struct capture_control_data msg = {0}; if (activate && !client->activated++) { msg.capturing = 1; } else if (!activate && !--client->activated) { msg.capturing = 0; } else { return; } fill_capture_control_data(&msg, client); client->buf_id = 0; for (int i = 0; i < 4; ++i) { if (client->buf_fds[i] >= 0) { close(client->buf_fds[i]); client->buf_fds[i] = -1; } } memset(&client->tdata, 0, sizeof(client->tdata)); ssize_t ret = write(client->sockfd, &msg, sizeof(msg)); if (ret != sizeof(msg)) { blog(LOG_WARNING, "Socket write error: %s", strerror(errno)); } client->timeout = clock_ns() + 5000000000; // 5s timeout } static void vkcapture_source_video_tick(void *data, float seconds) { vkcapture_source_t *ctx = data; if (!obs_source_showing(ctx->source)) { return; } pthread_mutex_lock(&server.mutex); if (ctx->client_id) { vkcapture_client_t *client = find_client_by_id(ctx->client_id); if (!client) { ctx->client_id = 0; destroy_texture(ctx); } else if (ctx->buf_id != client->buf_id) { destroy_texture(ctx); memcpy(&ctx->tdata, &client->tdata, sizeof(client->tdata)); blog(LOG_INFO, "Creating texture from dmabuf %dx%d modifier:%" PRIu64, ctx->tdata.width, ctx->tdata.height, ctx->tdata.modifier); uint32_t strides[4]; uint32_t offsets[4]; uint64_t modifiers[4]; for (uint8_t i = 0; i < ctx->tdata.nfd; ++i) { strides[i] = ctx->tdata.strides[i]; offsets[i] = ctx->tdata.offsets[i]; modifiers[i] = ctx->tdata.modifier; blog(LOG_INFO, " [%d] fd:%d stride:%d offset:%d", i, client->buf_fds[i], strides[i], offsets[i]); } if (client->import_failures == IMPORT_LINEAR_HOST_MAPPED) { lseek(client->buf_fds[0], 0, SEEK_SET); client->map_size = lseek(client->buf_fds[0], 0, SEEK_END); client->map_memory = mmap(NULL, client->map_size, PROT_READ, MAP_SHARED, client->buf_fds[0], 0); if (client->map_memory == MAP_FAILED) { client->map_memory = NULL; blog(LOG_ERROR, "Failed to map dmabuf '%s'", strerror(errno)); } else { obs_enter_graphics(); ctx->texture = gs_texture_create(ctx->tdata.width, ctx->tdata.height, drm_format_to_gs(ctx->tdata.format), 1, NULL, GS_DYNAMIC); obs_leave_graphics(); } } else { obs_enter_graphics(); ctx->texture = gs_texture_create_from_dmabuf(ctx->tdata.width, ctx->tdata.height, ctx->tdata.format, drm_format_to_gs(ctx->tdata.format), ctx->tdata.nfd, client->buf_fds, strides, offsets, ctx->tdata.modifier != DRM_FORMAT_MOD_INVALID ? modifiers : NULL); obs_leave_graphics(); } if (!ctx->texture) { if (client->import_failures < IMPORT_FAILURES_MAX) { client->import_failures++; blog(LOG_WARNING, "Asking client to create texture %s", import_attempt_str(client->import_failures)); struct capture_control_data msg = {0}; msg.capturing = client->activated ? 1 : 0; fill_capture_control_data(&msg, client); ssize_t ret = write(client->sockfd, &msg, sizeof(msg)); if (ret != sizeof(msg)) { blog(LOG_WARNING, "Socket write error: %s", strerror(errno)); } } else { blog(LOG_ERROR, "Could not create texture from dmabuf source"); } } ctx->buf_id = client->buf_id; client->timeout = 0; } else if (client != find_matching_client(ctx)) { activate_client(ctx, client, false); ctx->client_id = 0; destroy_texture(ctx); } else if (client->timeout && clock_ns() > client->timeout) { blog(LOG_INFO, "Client %d not responding, disconnecting...", client->id); client->unresponsive = true; server_wakeup(); ctx->client_id = 0; destroy_texture(ctx); } } else { vkcapture_client_t *client = find_matching_client(ctx); if (client) { activate_client(ctx, client, true); ctx->client_id = client->id; } } pthread_mutex_unlock(&server.mutex); UNUSED_PARAMETER(seconds); } static void vkcapture_source_render(void *data, gs_effect_t *effect) { vkcapture_source_t *ctx = data; if (!ctx->texture) { return; } if (ctx->show_cursor) { cursor_update(ctx); } pthread_mutex_lock(&server.mutex); vkcapture_client_t *client = find_client_by_id(ctx->client_id); if (!client) { pthread_mutex_unlock(&server.mutex); return; } void *memory = client->map_memory; int stride = client->tdata.strides[0]; int fd = client->buf_fds[0]; pthread_mutex_unlock(&server.mutex); if (memory) { struct dma_buf_sync sync; sync.flags = DMA_BUF_SYNC_START | DMA_BUF_SYNC_READ; ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync); obs_enter_graphics(); gs_texture_set_image(ctx->texture, memory, stride, false); obs_leave_graphics(); sync.flags = DMA_BUF_SYNC_END | DMA_BUF_SYNC_READ; ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync); } const enum gs_color_space color_space = gs_get_color_space(); const char *tech_name = "DrawSrgbDecompress"; float multiplier = 1.f; if (color_space == GS_CS_709_EXTENDED) { tech_name = "DrawPQ"; multiplier = 10000.f / obs_get_video_sdr_white_level(); } effect = obs_get_base_effect(ctx->allow_transparency ? OBS_EFFECT_DEFAULT : OBS_EFFECT_OPAQUE); const bool linear_srgb = gs_get_linear_srgb(); const bool previous = gs_framebuffer_srgb_enabled(); gs_enable_framebuffer_srgb(linear_srgb); gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image"); if (linear_srgb) gs_effect_set_texture_srgb(image, ctx->texture); else gs_effect_set_texture(image, ctx->texture); while (gs_effect_loop(effect, tech_name)) { gs_effect_set_float(gs_effect_get_param_by_name(effect, "multiplier"), multiplier); gs_draw_sprite(ctx->texture, ctx->tdata.flip ? GS_FLIP_V : 0, 0, 0); if (ctx->allow_transparency && ctx->show_cursor) { cursor_render(ctx); } } if (!ctx->allow_transparency && ctx->show_cursor) { effect = obs_get_base_effect(OBS_EFFECT_DEFAULT); tech_name = "Draw"; multiplier = 1.f; if (color_space == GS_CS_709_SCRGB) { tech_name = "DrawMultiply"; multiplier = obs_get_video_sdr_white_level() / 80.f; } while (gs_effect_loop(effect, tech_name)) { gs_effect_set_float(gs_effect_get_param_by_name(effect, "multiplier"), multiplier); cursor_render(ctx); } } gs_enable_framebuffer_srgb(previous); } static const char *vkcapture_source_get_name(void *data) { return obs_module_text("GameCapture"); } static uint32_t vkcapture_source_get_width(void *data) { const vkcapture_source_t *ctx = data; return ctx->tdata.width; } static uint32_t vkcapture_source_get_height(void *data) { const vkcapture_source_t *ctx = data; return ctx->tdata.height; } static void vkcapture_source_get_defaults(obs_data_t *defaults) { obs_data_set_default_bool(defaults, "show_cursor", true); obs_data_set_default_bool(defaults, "allow_transparency", false); obs_data_set_default_bool(defaults, "force_hdr", false); } static obs_properties_t *vkcapture_source_get_properties(void *data) { vkcapture_source_t *ctx = data; obs_properties_t *props = obs_properties_create(); obs_property_t *p = obs_properties_add_list(props, "window", obs_module_text("CaptureWindow"), OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING); obs_property_list_add_string(p, obs_module_text("CaptureAnyWindow"), ""); if (ctx) { bool window_found = false; pthread_mutex_lock(&server.mutex); for (size_t i = 0; i < server.clients.num; i++) { vkcapture_client_t *client = server.clients.array + i; obs_property_list_add_string(p, client->cdata.exe, client->cdata.exe); if (ctx->window && !strcmp(client->cdata.exe, ctx->window)) { window_found = true; } } pthread_mutex_unlock(&server.mutex); if (ctx->window && !window_found) { obs_property_list_add_string(p, ctx->window, ctx->window); } } size_t count = obs_property_list_item_count(p); for (size_t i = 1; i < count; ++i) { char name[128]; char value[128]; const char *item = obs_property_list_item_string(p, i); snprintf(name, sizeof(name), "%s %s", obs_module_text("CaptureAnyWindowExcept"), item); snprintf(value, sizeof(value), "exclude=%s", obs_property_list_item_string(p, i)); obs_property_list_add_string(p, name, value); } if (!ctx || cursor_enabled(ctx)) { obs_properties_add_bool(props, "show_cursor", obs_module_text("CaptureCursor")); } obs_properties_add_bool(props, "allow_transparency", obs_module_text("AllowTransparency")); obs_properties_add_bool(props, "force_hdr", obs_module_text("ForceHDR")); return props; } enum gs_color_space vkcapture_get_color_space(void *data, size_t count, const enum gs_color_space *preferred_spaces) { vkcapture_source_t *ctx = data; enum gs_color_space color_space = ctx->tdata.color_space; if (ctx->force_hdr) { color_space = GS_CS_709_EXTENDED; } UNUSED_PARAMETER(count); UNUSED_PARAMETER(preferred_spaces); return color_space; } static struct obs_source_info vkcapture_input = { .id = "vkcapture-source", .type = OBS_SOURCE_TYPE_INPUT, .get_name = vkcapture_source_get_name, .output_flags = OBS_SOURCE_VIDEO | OBS_SOURCE_CUSTOM_DRAW | OBS_SOURCE_DO_NOT_DUPLICATE | OBS_SOURCE_SRGB, .create = vkcapture_source_create, .destroy = vkcapture_source_destroy, .update = vkcapture_source_update, .video_tick = vkcapture_source_video_tick, .video_render = vkcapture_source_render, .get_width = vkcapture_source_get_width, .get_height = vkcapture_source_get_height, .get_defaults = vkcapture_source_get_defaults, .get_properties = vkcapture_source_get_properties, .icon_type = OBS_ICON_TYPE_GAME_CAPTURE, .video_get_color_space = vkcapture_get_color_space, }; static bool server_wakeup() { uint64_t q = 1; return write(server.eventfd, &q, sizeof(q)) == sizeof(q); } static void server_add_fd(int fd, int events) { struct pollfd p; p.fd = fd; p.events = events; da_push_back(server.fds, &p); } static void server_remove_fd(int fd) { for (size_t i = 0; i < server.fds.num; ++i) { struct pollfd *p = server.fds.array + i; if (p->fd == fd) { da_erase(server.fds, i); break; } } } static bool server_has_event_on_fd(int fd) { for (size_t i = 0; i < server.fds.num; ++i) { struct pollfd *p = server.fds.array + i; if (p->fd == fd && p->revents) { return true; } } return false; } static void server_cleanup_client(vkcapture_client_t *client) { pthread_mutex_lock(&server.mutex); blog(LOG_INFO, "Client %d disconnected", client->id); close(client->sockfd); server_remove_fd(client->sockfd); if (client->map_memory) { munmap(client->map_memory, client->map_size); client->map_memory = NULL; } for (int i = 0; i < 4; ++i) { if (client->buf_fds[i] >= 0) { close(client->buf_fds[i]); client->buf_fds[i] = -1; } } da_erase_item(server.clients, client); pthread_mutex_unlock(&server.mutex); } static void *server_thread_run(void *data) { const char sockname[] = "/com/obsproject/vkcapture"; int bufid = 0; int clientid = 0; da_init(server.fds); da_init(server.clients); struct sockaddr_un addr; addr.sun_family = PF_LOCAL; addr.sun_path[0] = '\0'; // Abstract socket memcpy(&addr.sun_path[1], sockname, sizeof(sockname) - 1); int sockfd = socket(PF_LOCAL, SOCK_STREAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0); int ret = bind(sockfd, (const struct sockaddr *)&addr, sizeof(addr.sun_family) + sizeof(sockname)); if (ret < 0) { blog(LOG_ERROR, "Cannot bind unix socket to %s: %d", addr.sun_path, errno); return NULL; } ret = listen(sockfd, 1); if (ret < 0) { blog(LOG_ERROR, "Cannot listen on unix socket bound to %s: %d", addr.sun_path, errno); return NULL; } server_add_fd(sockfd, POLLIN); server_add_fd(server.eventfd, POLLIN); while (true) { int ret = poll(server.fds.array, server.fds.num, -1); if (ret <= 0) { continue; } if (server_has_event_on_fd(server.eventfd)) { uint64_t q; if (read(server.eventfd, &q, sizeof(q)) != sizeof(q)) { blog(LOG_ERROR, "Failed to read from eventfd %s", strerror(errno)); } if (server.quit) { break; } } if (server_has_event_on_fd(sockfd)) { int clientfd = accept4(sockfd, NULL, NULL, SOCK_CLOEXEC | SOCK_NONBLOCK); if (clientfd >= 0) { vkcapture_client_t client = {0}; memset(&client.buf_fds, -1, sizeof(client.buf_fds)); client.id = ++clientid; client.sockfd = clientfd; pthread_mutex_lock(&server.mutex); da_push_back(server.clients, &client); pthread_mutex_unlock(&server.mutex); server_add_fd(client.sockfd, POLLIN); struct ucred cred = {0}; socklen_t cred_len = sizeof(cred); if (getsockopt(client.sockfd, SOL_SOCKET, SO_PEERCRED, &cred, &cred_len) != 0) { blog(LOG_WARNING, "Failed to get socket credentials: %s", strerror(errno)); } blog(LOG_INFO, "Client %d connected (pid=%d)", client.id, cred.pid); } else { if (errno != EAGAIN && errno != EWOULDBLOCK && errno != ECONNABORTED) { blog(LOG_ERROR, "Cannot accept unix socket: %s", strerror(errno)); } } } for (size_t i = 0; i < server.clients.num; i++) { vkcapture_client_t *client = server.clients.array + i; if (client->unresponsive) { server_cleanup_client(client); continue; } if (!server_has_event_on_fd(client->sockfd)) { continue; } uint8_t buf[CAPTURE_TEXTURE_DATA_SIZE]; struct msghdr msg = {0}; struct iovec io = { .iov_base = buf, .iov_len = CAPTURE_TEXTURE_DATA_SIZE, }; msg.msg_iov = &io; msg.msg_iovlen = 1; char cmsg_buf[CMSG_SPACE(sizeof(int)) * 4]; msg.msg_control = cmsg_buf; msg.msg_controllen = sizeof(cmsg_buf); while (true) { const ssize_t n = recvmsg(client->sockfd, &msg, MSG_NOSIGNAL); if (n == -1) { if (errno == EAGAIN || errno == EWOULDBLOCK) { break; } if (errno != ECONNRESET) { blog(LOG_ERROR, "Socket recv error: %s", strerror(errno)); } } if (n <= 0) { server_cleanup_client(client); break; } if (buf[0] == CAPTURE_CLIENT_DATA_TYPE) { if (io.iov_len != CAPTURE_CLIENT_DATA_SIZE) { server_cleanup_client(client); break; } pthread_mutex_lock(&server.mutex); memcpy(&client->cdata, buf, CAPTURE_CLIENT_DATA_SIZE); pthread_mutex_unlock(&server.mutex); break; } else if (buf[0] == CAPTURE_TEXTURE_DATA_TYPE) { pthread_mutex_lock(&server.mutex); memcpy(&client->tdata, buf, CAPTURE_TEXTURE_DATA_SIZE); pthread_mutex_unlock(&server.mutex); struct cmsghdr *cmsgh = CMSG_FIRSTHDR(&msg); if (!cmsgh || cmsgh->cmsg_level != SOL_SOCKET || cmsgh->cmsg_type != SCM_RIGHTS) { server_cleanup_client(client); break; } const size_t nfd = (cmsgh->cmsg_len - sizeof(struct cmsghdr)) / sizeof(int); int buf_fds[4] = {-1, -1, -1, -1}; for (size_t i = 0; i < nfd; ++i) { buf_fds[i] = ((int*)CMSG_DATA(cmsgh))[i]; } if (io.iov_len != CAPTURE_TEXTURE_DATA_SIZE || client->tdata.nfd != nfd) { for (size_t i = 0; i < nfd; ++i) { close(buf_fds[i]); } server_cleanup_client(client); break; } pthread_mutex_lock(&server.mutex); for (int i = 0; i < 4; ++i) { if (client->buf_fds[i] >= 0) { close(client->buf_fds[i]); } client->buf_fds[i] = buf_fds[i]; } client->buf_id = ++bufid; pthread_mutex_unlock(&server.mutex); } } } } while (server.clients.num) { server_cleanup_client(server.clients.array); } close(sockfd); da_free(server.clients); da_free(server.fds); return NULL; } bool obs_module_load(void) { enum obs_nix_platform_type platform = obs_get_nix_platform(); #if HAVE_WAYLAND || LIBOBS_API_MAJOR_VER >= 30 if (platform != OBS_NIX_PLATFORM_X11_EGL && platform != OBS_NIX_PLATFORM_WAYLAND) { #else if (platform != OBS_NIX_PLATFORM_X11_EGL) { #endif blog(LOG_ERROR, "linux-vkcapture cannot run on non-EGL platforms"); return false; } server.eventfd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK); if (server.eventfd < 0) { blog(LOG_ERROR, "Failed to create eventfd: %s", strerror(errno)); return false; } pthread_mutex_init(&server.mutex, NULL); if (pthread_create(&server.thread, NULL, server_thread_run, NULL) != 0) { blog(LOG_ERROR, "Failed to create thread"); return false; } pthread_setname_np(server.thread, PLUGIN_NAME); obs_register_source(&vkcapture_input); blog(LOG_INFO, "plugin loaded successfully (version %s)", PLUGIN_VERSION); return true; } void obs_module_unload() { server.quit = true; if (server_wakeup()) { pthread_join(server.thread, NULL); } blog(LOG_INFO, "plugin unloaded"); } OBS_DECLARE_MODULE() OBS_MODULE_AUTHOR("David Rosca ") OBS_MODULE_USE_DEFAULT_LOCALE(PLUGIN_NAME, "en-US") MODULE_EXPORT const char *obs_module_name(void) { return PLUGIN_NAME; } MODULE_EXPORT const char *obs_module_description(void) { return obs_module_text("Description"); } obs-vkcapture-1.5.2/src/vklayer.c000066400000000000000000002003271501231770600167220ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #include "vklayer.h" #include "capture.h" #include "utils.h" #include #include #include #include #include #include #include // Based on obs-studio/plugins/win-capture/graphics-hook/vulkan-capture.c /* ======================================================================== */ /* defs/statics */ /* use the loader's dispatch table pointer as a key for internal data maps */ #define GET_LDT(x) (*(void **)x) /* #define DEBUG_EXTRA 1 */ #define MAX_PRESENT_SWAP_SEMAPHORE_COUNT 32 static VkPipelineStageFlagBits semaphore_dst_stage_masks[MAX_PRESENT_SWAP_SEMAPHORE_COUNT]; static bool vulkan_seen = false; static bool vkcapture_linear = false; /* ======================================================================== */ /* hook data */ struct vk_obj_node { uint64_t obj; struct vk_obj_node *next; }; struct vk_obj_list { struct vk_obj_node *root; pthread_mutex_t mutex; }; struct vk_swap_data { struct vk_obj_node node; VkExtent2D image_extent; VkFormat format; VkColorSpaceKHR color_space; uint64_t winid; VkImage export_image; VkFormat export_format; VkDeviceMemory export_mem; VkImage *swap_images; uint32_t image_count; int dmabuf_nfd; int dmabuf_fds[4]; int dmabuf_strides[4]; int dmabuf_offsets[4]; uint64_t dmabuf_modifier; bool captured; }; struct vk_queue_data { struct vk_obj_node node; uint32_t fam_idx; bool supports_transfer; struct vk_frame_data *frames; uint32_t frame_index; uint32_t frame_count; }; struct vk_frame_data { VkCommandPool cmd_pool; VkCommandBuffer cmd_buffer; VkFence fence; VkSemaphore semaphore; bool cmd_buffer_busy; }; struct vk_surf_data { struct vk_obj_node node; uint64_t winid; }; struct vk_inst_data { struct vk_obj_node node; VkInstance instance; bool valid; struct vk_inst_funcs funcs; struct vk_obj_list surfaces; }; struct vk_data { struct vk_obj_node node; VkDevice device; VkDriverId driver_id; uint8_t device_uuid[16]; bool valid; struct vk_device_funcs funcs; VkPhysicalDevice phy_device; struct vk_obj_list swaps; struct vk_swap_data *cur_swap; struct vk_obj_list queues; VkQueue graphics_queue; VkExternalMemoryProperties external_mem_props; struct vk_inst_data *inst_data; VkAllocationCallbacks ac_storage; const VkAllocationCallbacks *ac; }; /* ------------------------------------------------------------------------- */ static void *vk_alloc(const VkAllocationCallbacks *ac, size_t size, size_t alignment, enum VkSystemAllocationScope scope) { return ac ? ac->pfnAllocation(ac->pUserData, size, alignment, scope) : malloc(size); } static void vk_free(const VkAllocationCallbacks *ac, void *memory) { if (ac) ac->pfnFree(ac->pUserData, memory); else free(memory); } static void add_obj_data(struct vk_obj_list *list, uint64_t obj, void *data) { pthread_mutex_lock(&list->mutex); struct vk_obj_node *const node = (struct vk_obj_node*)data; node->obj = obj; node->next = list->root; list->root = node; pthread_mutex_unlock(&list->mutex); } static struct vk_obj_node *get_obj_data(struct vk_obj_list *list, uint64_t obj) { struct vk_obj_node *data = NULL; pthread_mutex_lock(&list->mutex); struct vk_obj_node *node = list->root; while (node) { if (node->obj == obj) { data = node; break; } node = node->next; } pthread_mutex_unlock(&list->mutex); return data; } static struct vk_obj_node *remove_obj_data(struct vk_obj_list *list, uint64_t obj) { struct vk_obj_node *data = NULL; pthread_mutex_lock(&list->mutex); struct vk_obj_node *prev = NULL; struct vk_obj_node *node = list->root; while (node) { if (node->obj == obj) { data = node; if (prev) prev->next = node->next; else list->root = node->next; break; } prev = node; node = node->next; } pthread_mutex_unlock(&list->mutex); return data; } static void init_obj_list(struct vk_obj_list *list) { list->root = NULL; pthread_mutex_init(&list->mutex, NULL); } static struct vk_obj_node *obj_walk_begin(struct vk_obj_list *list) { pthread_mutex_lock(&list->mutex); return list->root; } static struct vk_obj_node *obj_walk_next(struct vk_obj_node *node) { return node->next; } static void obj_walk_end(struct vk_obj_list *list) { pthread_mutex_unlock(&list->mutex); } /* ------------------------------------------------------------------------- */ static struct vk_obj_list devices; static struct vk_data *alloc_device_data(const VkAllocationCallbacks *ac) { struct vk_data *data = vk_alloc(ac, sizeof(struct vk_data), _Alignof(struct vk_data), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); return data; } static void init_device_data(struct vk_data *data, VkDevice device) { add_obj_data(&devices, (uintptr_t)GET_LDT(device), data); data->device = device; } static struct vk_data *get_device_data(VkDevice device) { return (struct vk_data *)get_obj_data(&devices, (uintptr_t)GET_LDT(device)); } static struct vk_data *get_device_data_by_queue(VkQueue queue) { return (struct vk_data *)get_obj_data(&devices, (uintptr_t)GET_LDT(queue)); } static struct vk_data *remove_device_data(VkDevice device) { return (struct vk_data *)remove_obj_data(&devices, (uintptr_t)GET_LDT(device)); } /* ------------------------------------------------------------------------- */ static struct vk_queue_data *add_queue_data(struct vk_data *data, VkQueue queue, uint32_t fam_idx, bool supports_transfer, bool supports_graphics, const VkAllocationCallbacks *ac) { struct vk_queue_data *const queue_data = vk_alloc(ac, sizeof(struct vk_queue_data), _Alignof(struct vk_queue_data), VK_SYSTEM_ALLOCATION_SCOPE_DEVICE); add_obj_data(&data->queues, (uintptr_t)queue, queue_data); queue_data->fam_idx = fam_idx; queue_data->supports_transfer = supports_transfer; queue_data->frames = NULL; queue_data->frame_index = 0; queue_data->frame_count = 0; if (supports_graphics) data->graphics_queue = queue; return queue_data; } static struct vk_queue_data *get_queue_data(struct vk_data *data, VkQueue queue) { return (struct vk_queue_data *)get_obj_data(&data->queues, (uintptr_t)queue); } static void remove_free_queue_all(struct vk_data *data, const VkAllocationCallbacks *ac) { struct vk_queue_data *queue_data = (struct vk_queue_data *)data->queues.root; while (data->queues.root) { remove_obj_data(&data->queues, queue_data->node.obj); vk_free(ac, queue_data); queue_data = (struct vk_queue_data *)data->queues.root; } } static struct vk_queue_data *queue_walk_begin(struct vk_data *data) { return (struct vk_queue_data *)obj_walk_begin(&data->queues); } static struct vk_queue_data *queue_walk_next(struct vk_queue_data *queue_data) { return (struct vk_queue_data *)obj_walk_next( (struct vk_obj_node *)queue_data); } static void queue_walk_end(struct vk_data *data) { obj_walk_end(&data->queues); } /* ------------------------------------------------------------------------- */ static struct vk_swap_data *alloc_swap_data(const VkAllocationCallbacks *ac) { struct vk_swap_data *const swap_data = vk_alloc( ac, sizeof(struct vk_swap_data), _Alignof(struct vk_swap_data), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); return swap_data; } static void init_swap_data(struct vk_swap_data *swap_data, struct vk_data *data, VkSwapchainKHR sc) { add_obj_data(&data->swaps, (uint64_t)sc, swap_data); } static struct vk_swap_data *get_swap_data(struct vk_data *data, VkSwapchainKHR sc) { return (struct vk_swap_data *)get_obj_data(&data->swaps, (uint64_t)sc); } static void remove_free_swap_data(struct vk_data *data, VkSwapchainKHR sc, const VkAllocationCallbacks *ac) { struct vk_swap_data *const swap_data = (struct vk_swap_data *)remove_obj_data(&data->swaps, (uint64_t)sc); vk_free(ac, swap_data); } static struct vk_swap_data *swap_walk_begin(struct vk_data *data) { return (struct vk_swap_data *)obj_walk_begin(&data->swaps); } static struct vk_swap_data *swap_walk_next(struct vk_swap_data *swap_data) { return (struct vk_swap_data *)obj_walk_next( (struct vk_obj_node *)swap_data); } static void swap_walk_end(struct vk_data *data) { obj_walk_end(&data->swaps); } /* ------------------------------------------------------------------------- */ static void vk_shtex_clear_fence(const struct vk_data *data, struct vk_frame_data *frame_data) { const VkFence fence = frame_data->fence; if (frame_data->cmd_buffer_busy) { VkDevice device = data->device; const struct vk_device_funcs *funcs = &data->funcs; funcs->WaitForFences(device, 1, &fence, VK_TRUE, ~0ull); funcs->ResetFences(device, 1, &fence); frame_data->cmd_buffer_busy = false; } } static void vk_shtex_wait_until_pool_idle(struct vk_data *data, struct vk_queue_data *queue_data) { for (uint32_t frame_idx = 0; frame_idx < queue_data->frame_count; frame_idx++) { struct vk_frame_data *frame_data = &queue_data->frames[frame_idx]; if (frame_data->cmd_pool != VK_NULL_HANDLE) vk_shtex_clear_fence(data, frame_data); } } static void vk_shtex_wait_until_idle(struct vk_data *data) { struct vk_queue_data *queue_data = queue_walk_begin(data); while (queue_data) { vk_shtex_wait_until_pool_idle(data, queue_data); queue_data = queue_walk_next(queue_data); } queue_walk_end(data); } static void vk_shtex_free(struct vk_data *data) { vk_shtex_wait_until_idle(data); struct vk_swap_data *swap = swap_walk_begin(data); while (swap) { VkDevice device = data->device; if (swap->export_image) data->funcs.DestroyImage(device, swap->export_image, data->ac); swap->dmabuf_nfd = 0; for (int i = 0; i < 4; ++i) { if (swap->dmabuf_fds[i] >= 0) { close(swap->dmabuf_fds[i]); swap->dmabuf_fds[i] = -1; } } if (swap->export_mem) data->funcs.FreeMemory(device, swap->export_mem, NULL); swap->export_mem = VK_NULL_HANDLE; swap->export_image = VK_NULL_HANDLE; swap->captured = false; swap = swap_walk_next(swap); } swap_walk_end(data); data->cur_swap = NULL; capture_stop(); hlog("------------------- vulkan capture freed -------------------"); } /* ------------------------------------------------------------------------- */ static void add_surf_data(struct vk_inst_data *idata, VkSurfaceKHR surf, uint64_t winid, const VkAllocationCallbacks *ac) { struct vk_surf_data *surf_data = vk_alloc( ac, sizeof(struct vk_surf_data), _Alignof(struct vk_surf_data), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); if (surf_data) { surf_data->winid = winid; add_obj_data(&idata->surfaces, (uint64_t)surf, surf_data); } } static uint64_t find_surf_winid(struct vk_inst_data *idata, VkSurfaceKHR surf) { struct vk_surf_data *surf_data = (struct vk_surf_data *)get_obj_data( &idata->surfaces, (uint64_t)surf); return surf_data ? surf_data->winid : 0; } static void remove_free_surf_data(struct vk_inst_data *idata, VkSurfaceKHR surf, const VkAllocationCallbacks *ac) { struct vk_surf_data *surf_data = (struct vk_surf_data *)remove_obj_data( &idata->surfaces, (uint64_t)surf); vk_free(ac, surf_data); } /* ------------------------------------------------------------------------- */ static struct vk_obj_list instances; static struct vk_inst_data *alloc_inst_data(const VkAllocationCallbacks *ac) { struct vk_inst_data *idata = vk_alloc( ac, sizeof(struct vk_inst_data), _Alignof(struct vk_inst_data), VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); return idata; } static void init_inst_data(struct vk_inst_data *idata, VkInstance instance) { add_obj_data(&instances, (uintptr_t)GET_LDT(instance), idata); idata->instance = instance; } static struct vk_inst_data *get_inst_data(VkInstance instance) { return (struct vk_inst_data *)get_obj_data(&instances, (uintptr_t)GET_LDT(instance)); } static struct vk_inst_funcs *get_inst_funcs(VkInstance instance) { struct vk_inst_data *idata = (struct vk_inst_data *)get_inst_data(instance); return &idata->funcs; } static struct vk_inst_data * get_inst_data_by_physical_device(VkPhysicalDevice physicalDevice) { return (struct vk_inst_data *)get_obj_data( &instances, (uintptr_t)GET_LDT(physicalDevice)); } static struct vk_inst_funcs * get_inst_funcs_by_physical_device(VkPhysicalDevice physicalDevice) { struct vk_inst_data *idata = (struct vk_inst_data *)get_inst_data_by_physical_device( physicalDevice); return &idata->funcs; } static void remove_free_inst_data(VkInstance inst, const VkAllocationCallbacks *ac) { struct vk_inst_data *idata = (struct vk_inst_data *)remove_obj_data( &instances, (uintptr_t)GET_LDT(inst)); vk_free(ac, idata); } /* ======================================================================== */ /* capture */ static bool allow_modifier(struct vk_data *data, uint64_t modifier) { /* DCC modifiers doesn't work when importing on radeonsi with amdvlk/amdpro drivers */ if (data->driver_id == VK_DRIVER_ID_AMD_OPEN_SOURCE || data->driver_id == VK_DRIVER_ID_AMD_PROPRIETARY) { return !IS_AMD_FMT_MOD(modifier) || !AMD_FMT_MOD_GET(DCC, modifier); } return true; } static const struct { int32_t drm; VkFormat vk; } vk_format_table[] = { { DRM_FORMAT_ARGB8888, VK_FORMAT_B8G8R8A8_UNORM }, { DRM_FORMAT_ARGB8888, VK_FORMAT_B8G8R8A8_SRGB }, { DRM_FORMAT_XRGB8888, VK_FORMAT_B8G8R8A8_UNORM }, { DRM_FORMAT_XRGB8888, VK_FORMAT_B8G8R8A8_SRGB }, { DRM_FORMAT_ABGR8888, VK_FORMAT_R8G8B8A8_UNORM }, { DRM_FORMAT_ABGR8888, VK_FORMAT_R8G8B8A8_SRGB }, { DRM_FORMAT_XBGR8888, VK_FORMAT_R8G8B8A8_UNORM }, { DRM_FORMAT_XBGR8888, VK_FORMAT_R8G8B8A8_SRGB }, { DRM_FORMAT_ARGB2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 }, { DRM_FORMAT_XRGB2101010, VK_FORMAT_A2R10G10B10_UNORM_PACK32 }, { DRM_FORMAT_ABGR2101010, VK_FORMAT_A2B10G10R10_UNORM_PACK32 }, { DRM_FORMAT_XBGR2101010, VK_FORMAT_A2B10G10R10_UNORM_PACK32 }, { DRM_FORMAT_ABGR16161616, VK_FORMAT_R16G16B16A16_UNORM }, { DRM_FORMAT_XBGR16161616, VK_FORMAT_R16G16B16A16_UNORM }, { DRM_FORMAT_ABGR16161616F, VK_FORMAT_R16G16B16A16_SFLOAT }, { DRM_FORMAT_XBGR16161616F, VK_FORMAT_R16G16B16A16_SFLOAT }, }; static int32_t vk_format_to_drm(VkFormat vk) { for (size_t i = 0; i < sizeof(vk_format_table) / sizeof(vk_format_table[0]); ++i) { if (vk_format_table[i].vk == vk) { return vk_format_table[i].drm; } } return -1; } static uint32_t vk_color_space_to_obs(VkColorSpaceKHR vk) { const char *force = getenv("OBS_VKCAPTURE_COLOR_SPACE"); if (force) { int value = atoi(force); if (value >= 0 && value < 3) { return value; } } switch (vk) { case VK_COLOR_SPACE_HDR10_ST2084_EXT: return 2; // GS_CS_709_EXTENDED case VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: default: return 0; // GS_CS_SRGB } } static inline bool vk_shtex_init_vulkan_tex(struct vk_data *data, struct vk_swap_data *swap) { struct vk_device_funcs *funcs = &data->funcs; struct vk_inst_funcs *ifuncs = get_inst_funcs_by_physical_device(data->phy_device); const bool no_modifiers = capture_allocate_no_modifiers(); const bool linear = vkcapture_linear || capture_allocate_linear(); const bool map_host = capture_allocate_map_host(); const bool same_device = capture_compare_device_uuid(data->device_uuid); hlog("Texture %s %ux%u", vk_format_to_str(swap->format), swap->image_extent.width, swap->image_extent.height); if (vk_format_to_drm(swap->format) != -1) { swap->export_format = swap->format; } else { swap->export_format = VK_FORMAT_B8G8R8A8_UNORM; hlog("Converting to %s", vk_format_to_str(swap->export_format)); } if (!same_device) { hlog("OBS is running on different GPU"); } VkExternalMemoryImageCreateInfo ext_mem_image_info = {}; ext_mem_image_info.sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO; ext_mem_image_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; VkImageCreateInfo img_info = {}; img_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; img_info.pNext = &ext_mem_image_info; img_info.imageType = VK_IMAGE_TYPE_2D; img_info.format = swap->export_format; img_info.mipLevels = 1; img_info.arrayLayers = 1; img_info.samples = VK_SAMPLE_COUNT_1_BIT; img_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; img_info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; img_info.extent.width = swap->image_extent.width; img_info.extent.height = swap->image_extent.height; img_info.extent.depth = 1; img_info.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT; img_info.tiling = VK_IMAGE_TILING_LINEAR; int num_planes = 1; uint64_t *image_modifiers = NULL; VkImageDrmFormatModifierListCreateInfoEXT image_modifier_list = {}; struct VkDrmFormatModifierPropertiesEXT *modifier_props = NULL; uint32_t modifier_prop_count = 0; if (!no_modifiers && funcs->GetImageDrmFormatModifierPropertiesEXT) { VkDrmFormatModifierPropertiesListEXT modifier_props_list = {}; modifier_props_list.sType = VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT; VkFormatProperties2KHR format_props = {}; format_props.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2; format_props.pNext = &modifier_props_list; ifuncs->GetPhysicalDeviceFormatProperties2KHR(data->phy_device, img_info.format, &format_props); modifier_props = vk_alloc(data->ac, modifier_props_list.drmFormatModifierCount * sizeof(struct VkDrmFormatModifierPropertiesEXT), _Alignof(struct VkDrmFormatModifierPropertiesEXT), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); modifier_props_list.pDrmFormatModifierProperties = modifier_props; ifuncs->GetPhysicalDeviceFormatProperties2KHR(data->phy_device, img_info.format, &format_props); #ifndef NDEBUG hlog("Available modifiers:"); #endif for (uint32_t i = 0; i < modifier_props_list.drmFormatModifierCount; i++) { if (linear && modifier_props[i].drmFormatModifier != DRM_FORMAT_MOD_LINEAR) { continue; } if (!allow_modifier(data, modifier_props[i].drmFormatModifier)) { continue; } VkPhysicalDeviceImageDrmFormatModifierInfoEXT mod_info = {}; mod_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT; mod_info.drmFormatModifier = modifier_props[i].drmFormatModifier; mod_info.sharingMode = img_info.sharingMode; VkPhysicalDeviceImageFormatInfo2 format_info = {}; format_info.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2; format_info.pNext = &mod_info; format_info.format = img_info.format; format_info.type = VK_IMAGE_TYPE_2D; format_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; format_info.usage = img_info.usage; format_info.flags = img_info.flags; VkImageFormatProperties2KHR format_props = {}; format_props.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2; format_props.pNext = NULL; VkResult result = ifuncs->GetPhysicalDeviceImageFormatProperties2KHR(data->phy_device, &format_info, &format_props); if (result == VK_SUCCESS) { #ifndef NDEBUG hlog(" %d: modifier:%"PRIu64" planes:%d", i, modifier_props[i].drmFormatModifier, modifier_props[i].drmFormatModifierPlaneCount); #endif modifier_props[modifier_prop_count++] = modifier_props[i]; } } if (modifier_prop_count > 0) { image_modifiers = vk_alloc(data->ac, sizeof(uint64_t) * modifier_prop_count, _Alignof(uint64_t), VK_SYSTEM_ALLOCATION_SCOPE_COMMAND); for (uint32_t i = 0; i < modifier_prop_count; ++i) { image_modifiers[i] = modifier_props[i].drmFormatModifier; } image_modifier_list.sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT; image_modifier_list.drmFormatModifierCount = modifier_prop_count; image_modifier_list.pDrmFormatModifiers = image_modifiers; img_info.tiling = VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT; ext_mem_image_info.pNext = &image_modifier_list; } else { hlog("No suitable DRM modifier found!"); } } VkDevice device = data->device; VkResult res; res = funcs->CreateImage(device, &img_info, data->ac, &swap->export_image); vk_free(data->ac, image_modifiers); if (VK_SUCCESS != res) { hlog("Failed to CreateImage %s", result_to_str(res)); swap->export_image = VK_NULL_HANDLE; return false; } VkImageMemoryRequirementsInfo2 memri = {}; memri.image = swap->export_image; memri.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2; VkMemoryDedicatedRequirements mdr = {}; mdr.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS; VkMemoryRequirements2 memr = {}; memr.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2; memr.pNext = &mdr; funcs->GetImageMemoryRequirements2KHR(device, &memri, &memr); /* -------------------------------------------------------- */ /* get memory type index */ VkPhysicalDeviceMemoryProperties pdmp; ifuncs->GetPhysicalDeviceMemoryProperties(data->phy_device, &pdmp); VkExportMemoryAllocateInfo memory_export_info = {}; memory_export_info.sType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO; memory_export_info.handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; VkMemoryDedicatedAllocateInfo memory_dedicated_info = {}; memory_dedicated_info.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO; memory_dedicated_info.pNext = &memory_export_info; memory_dedicated_info.image = swap->export_image; VkMemoryAllocateInfo memi = {}; memi.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; memi.pNext = &memory_dedicated_info; memi.allocationSize = memr.memoryRequirements.size; bool allocated = false; uint32_t mem_req_bits = same_device ? VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT : VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT; if (map_host) { mem_req_bits = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; } for (uint32_t i = 0; i < pdmp.memoryTypeCount; ++i) { if ((memr.memoryRequirements.memoryTypeBits & (1 << i)) && (pdmp.memoryTypes[i].propertyFlags & mem_req_bits) == mem_req_bits) { memi.memoryTypeIndex = i; res = funcs->AllocateMemory(device, &memi, NULL, &swap->export_mem); allocated = res == VK_SUCCESS; if (allocated) break; hlog("AllocateMemory failed (DEVICE_LOCAL): %s", result_to_str(res)); } } if (!allocated && !map_host) { /* Try again without DEVICE_LOCAL */ for (uint32_t i = 0; i < pdmp.memoryTypeCount; ++i) { if ((memr.memoryRequirements.memoryTypeBits & (1 << i)) && (pdmp.memoryTypes[i].propertyFlags & mem_req_bits) != mem_req_bits) { memi.memoryTypeIndex = i; res = funcs->AllocateMemory(device, &memi, NULL, &swap->export_mem); allocated = res == VK_SUCCESS; if (allocated) break; hlog("AllocateMemory failed (not DEVICE_LOCAL) %s", result_to_str(res)); } } } if (!allocated) { hlog("Failed to allocate memory of any type"); funcs->DestroyImage(device, swap->export_image, data->ac); swap->export_image = VK_NULL_HANDLE; return false; } VkBindImageMemoryInfo bimi = {}; bimi.sType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO; bimi.image = swap->export_image; bimi.memory = swap->export_mem; bimi.memoryOffset = 0; res = funcs->BindImageMemory2KHR(device, 1, &bimi); if (VK_SUCCESS != res) { hlog("BindImageMemory2KHR failed %s", result_to_str(res)); funcs->DestroyImage(device, swap->export_image, data->ac); swap->export_image = VK_NULL_HANDLE; return false; } int fd = -1; VkMemoryGetFdInfoKHR gfdi = {}; gfdi.sType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR; gfdi.memory = swap->export_mem; gfdi.handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT; res = funcs->GetMemoryFdKHR(device, &gfdi, &fd); if (VK_SUCCESS != res) { hlog("GetMemoryFdKHR failed %s", result_to_str(res)); funcs->DestroyImage(device, swap->export_image, data->ac); swap->export_image = VK_NULL_HANDLE; return false; } if (!no_modifiers && funcs->GetImageDrmFormatModifierPropertiesEXT) { VkImageDrmFormatModifierPropertiesEXT image_mod_props = {}; image_mod_props.sType = VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT; res = funcs->GetImageDrmFormatModifierPropertiesEXT(device, swap->export_image, &image_mod_props); if (VK_SUCCESS != res) { hlog("GetImageDrmFormatModifierPropertiesEXT failed %s", result_to_str(res)); swap->dmabuf_modifier = DRM_FORMAT_MOD_INVALID; } else { swap->dmabuf_modifier = image_mod_props.drmFormatModifier; for (uint32_t i = 0; i < modifier_prop_count; ++i) { if (modifier_props[i].drmFormatModifier == swap->dmabuf_modifier) { num_planes = modifier_props[i].drmFormatModifierPlaneCount; break; } } } vk_free(data->ac, modifier_props); } else { swap->dmabuf_modifier = DRM_FORMAT_MOD_INVALID; } for (int i = 0; i < num_planes; i++) { VkImageSubresource sbr = {}; if (!no_modifiers && funcs->GetImageDrmFormatModifierPropertiesEXT) { sbr.aspectMask = VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT << i; } else { sbr.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; } sbr.mipLevel = 0; sbr.arrayLayer = 0; VkSubresourceLayout layout; funcs->GetImageSubresourceLayout(device, swap->export_image, &sbr, &layout); swap->dmabuf_fds[i] = i == 0 ? fd : os_dupfd_cloexec(fd); swap->dmabuf_strides[i] = layout.rowPitch; swap->dmabuf_offsets[i] = layout.offset; } swap->dmabuf_nfd = num_planes; #ifndef NDEBUG hlog("Got planes %d fd %d", swap->dmabuf_nfd, swap->dmabuf_fds[0]); if (swap->dmabuf_modifier != DRM_FORMAT_MOD_INVALID) { hlog("Got modifier %"PRIu64, swap->dmabuf_modifier); } #endif return true; } static bool vk_shtex_init(struct vk_data *data, struct vk_swap_data *swap) { if (!vk_shtex_init_vulkan_tex(data, swap)) { return false; } data->cur_swap = swap; capture_init_shtex(swap->image_extent.width, swap->image_extent.height, vk_format_to_drm(swap->export_format), swap->dmabuf_strides, swap->dmabuf_offsets, swap->dmabuf_modifier, swap->winid, /*flip*/false, vk_color_space_to_obs(swap->color_space), swap->dmabuf_nfd, swap->dmabuf_fds); hlog("------------------ vulkan capture started ------------------"); return true; } static void vk_shtex_create_frame_objects(struct vk_data *data, struct vk_queue_data *queue_data, uint32_t image_count) { queue_data->frames = vk_alloc(data->ac, image_count * sizeof(struct vk_frame_data), _Alignof(struct vk_frame_data), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); memset(queue_data->frames, 0, image_count * sizeof(struct vk_frame_data)); queue_data->frame_index = 0; queue_data->frame_count = image_count; VkDevice device = data->device; for (uint32_t image_index = 0; image_index < image_count; image_index++) { struct vk_frame_data *frame_data = &queue_data->frames[image_index]; VkCommandPoolCreateInfo cpci; cpci.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; cpci.pNext = NULL; cpci.flags = 0; cpci.queueFamilyIndex = queue_data->fam_idx; VkResult res = data->funcs.CreateCommandPool( device, &cpci, data->ac, &frame_data->cmd_pool); #ifdef DEBUG_EXTRA hlog("CreateCommandPool %s", result_to_str(res)); #endif VkCommandBufferAllocateInfo cbai; cbai.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; cbai.pNext = NULL; cbai.commandPool = frame_data->cmd_pool; cbai.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; cbai.commandBufferCount = 1; res = data->funcs.AllocateCommandBuffers( device, &cbai, &frame_data->cmd_buffer); #ifdef DEBUG_EXTRA hlog("AllocateCommandBuffers %s", result_to_str(res)); #endif GET_LDT(frame_data->cmd_buffer) = GET_LDT(device); VkFenceCreateInfo fci = {}; fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; fci.pNext = NULL; fci.flags = 0; res = data->funcs.CreateFence(device, &fci, data->ac, &frame_data->fence); #ifdef DEBUG_EXTRA hlog("CreateFence %s", result_to_str(res)); #endif VkSemaphoreCreateInfo sci = {}; sci.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; sci.pNext = NULL; sci.flags = 0; res = data->funcs.CreateSemaphore(device, &sci, data->ac, &frame_data->semaphore); #ifdef DEBUG_EXTRA hlog("CreateSemaphore %s", result_to_str(res)); #endif } } static void vk_shtex_destroy_fence(struct vk_data *data, bool *cmd_buffer_busy, VkFence *fence) { VkDevice device = data->device; if (*cmd_buffer_busy) { data->funcs.WaitForFences(device, 1, fence, VK_TRUE, ~0ull); *cmd_buffer_busy = false; } data->funcs.DestroyFence(device, *fence, data->ac); *fence = VK_NULL_HANDLE; } static void vk_shtex_destroy_frame_objects(struct vk_data *data, struct vk_queue_data *queue_data) { VkDevice device = data->device; for (uint32_t frame_idx = 0; frame_idx < queue_data->frame_count; frame_idx++) { struct vk_frame_data *frame_data = &queue_data->frames[frame_idx]; bool *cmd_buffer_busy = &frame_data->cmd_buffer_busy; VkFence *fence = &frame_data->fence; vk_shtex_destroy_fence(data, cmd_buffer_busy, fence); data->funcs.DestroySemaphore(device, frame_data->semaphore, data->ac); data->funcs.DestroyCommandPool(device, frame_data->cmd_pool, data->ac); frame_data->cmd_pool = VK_NULL_HANDLE; } vk_free(data->ac, queue_data->frames); queue_data->frames = NULL; queue_data->frame_count = 0; } static void vk_shtex_capture(struct vk_data *data, struct vk_device_funcs *funcs, struct vk_swap_data *swap, uint32_t idx, VkQueue queue, VkPresentInfoKHR *info) { VkResult res = VK_SUCCESS; VkCommandBufferBeginInfo begin_info; begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; begin_info.pNext = NULL; begin_info.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; begin_info.pInheritanceInfo = NULL; VkImageMemoryBarrier mb[2]; VkImageMemoryBarrier *src_mb = &mb[0]; VkImageMemoryBarrier *dst_mb = &mb[1]; /* ------------------------------------------------------ */ /* do image copy */ const uint32_t image_index = info->pImageIndices[idx]; VkImage cur_backbuffer = swap->swap_images[image_index]; struct vk_queue_data *queue_data = get_queue_data(data, queue); uint32_t fam_idx = queue_data->fam_idx; const uint32_t image_count = swap->image_count; if (queue_data->frame_count < image_count) { if (queue_data->frame_count > 0) vk_shtex_destroy_frame_objects(data, queue_data); vk_shtex_create_frame_objects(data, queue_data, image_count); } const uint32_t frame_index = queue_data->frame_index; struct vk_frame_data *frame_data = &queue_data->frames[frame_index]; queue_data->frame_index = (frame_index + 1) % queue_data->frame_count; vk_shtex_clear_fence(data, frame_data); VkDevice device = data->device; res = funcs->ResetCommandPool(device, frame_data->cmd_pool, 0); #ifdef DEBUG_EXTRA hlog("ResetCommandPool %s", result_to_str(res)); #endif const VkCommandBuffer cmd_buffer = frame_data->cmd_buffer; res = funcs->BeginCommandBuffer(cmd_buffer, &begin_info); #ifdef DEBUG_EXTRA hlog("BeginCommandBuffer %s", result_to_str(res)); #endif /* ------------------------------------------------------ */ /* transition cur_backbuffer to transfer source state */ src_mb->sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; src_mb->pNext = NULL; src_mb->srcAccessMask = VK_ACCESS_MEMORY_READ_BIT; src_mb->dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT; src_mb->oldLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; src_mb->newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; src_mb->srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; src_mb->dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; src_mb->image = cur_backbuffer; src_mb->subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; src_mb->subresourceRange.baseMipLevel = 0; src_mb->subresourceRange.levelCount = 1; src_mb->subresourceRange.baseArrayLayer = 0; src_mb->subresourceRange.layerCount = 1; /* ------------------------------------------------------ */ /* transition exportedTexture to transfer dest state */ dst_mb->sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; dst_mb->pNext = NULL; dst_mb->srcAccessMask = 0; dst_mb->dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; dst_mb->oldLayout = VK_IMAGE_LAYOUT_GENERAL; dst_mb->newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; dst_mb->srcQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL; dst_mb->dstQueueFamilyIndex = fam_idx; dst_mb->image = swap->export_image; dst_mb->subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; dst_mb->subresourceRange.baseMipLevel = 0; dst_mb->subresourceRange.levelCount = 1; dst_mb->subresourceRange.baseArrayLayer = 0; dst_mb->subresourceRange.layerCount = 1; funcs->CmdPipelineBarrier(cmd_buffer, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0, 0, NULL, 0, NULL, 2, mb); /* ------------------------------------------------------ */ /* copy cur_backbuffer's content to our interop image */ if (swap->format != swap->export_format) { VkImageBlit blt; blt.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blt.srcSubresource.mipLevel = 0; blt.srcSubresource.baseArrayLayer = 0; blt.srcSubresource.layerCount = 1; blt.srcOffsets[0].x = 0; blt.srcOffsets[0].y = 0; blt.srcOffsets[0].z = 0; blt.srcOffsets[1].x = swap->image_extent.width; blt.srcOffsets[1].y = swap->image_extent.height; blt.srcOffsets[1].z = 1; blt.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; blt.dstSubresource.mipLevel = 0; blt.dstSubresource.baseArrayLayer = 0; blt.dstSubresource.layerCount = 1; blt.dstOffsets[0].x = 0; blt.dstOffsets[0].y = 0; blt.dstOffsets[0].z = 0; blt.dstOffsets[1].x = swap->image_extent.width; blt.dstOffsets[1].y = swap->image_extent.height; blt.dstOffsets[1].z = 1; funcs->CmdBlitImage(cmd_buffer, cur_backbuffer, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, swap->export_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blt, VK_FILTER_NEAREST); } else { VkImageCopy cpy; cpy.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; cpy.srcSubresource.mipLevel = 0; cpy.srcSubresource.baseArrayLayer = 0; cpy.srcSubresource.layerCount = 1; cpy.srcOffset.x = 0; cpy.srcOffset.y = 0; cpy.srcOffset.z = 0; cpy.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; cpy.dstSubresource.mipLevel = 0; cpy.dstSubresource.baseArrayLayer = 0; cpy.dstSubresource.layerCount = 1; cpy.dstOffset.x = 0; cpy.dstOffset.y = 0; cpy.dstOffset.z = 0; cpy.extent.width = swap->image_extent.width; cpy.extent.height = swap->image_extent.height; cpy.extent.depth = 1; funcs->CmdCopyImage(cmd_buffer, cur_backbuffer, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, swap->export_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &cpy); } /* ------------------------------------------------------ */ /* Restore the swap chain image layout to what it was * before. This may not be strictly needed, but it is * generally good to restore things to their original * state. */ src_mb->srcAccessMask = VK_ACCESS_TRANSFER_READ_BIT; src_mb->dstAccessMask = VK_ACCESS_MEMORY_READ_BIT; src_mb->oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL; src_mb->newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; dst_mb->srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; dst_mb->dstAccessMask = 0; dst_mb->oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL; dst_mb->newLayout = VK_IMAGE_LAYOUT_GENERAL; dst_mb->srcQueueFamilyIndex = fam_idx; dst_mb->dstQueueFamilyIndex = VK_QUEUE_FAMILY_EXTERNAL; funcs->CmdPipelineBarrier(cmd_buffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT | VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, 0, NULL, 0, NULL, 2, mb); funcs->EndCommandBuffer(cmd_buffer); /* ------------------------------------------------------ */ VkSubmitInfo submit_info; submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; submit_info.pNext = NULL; submit_info.waitSemaphoreCount = 0; submit_info.pWaitSemaphores = NULL; submit_info.pWaitDstStageMask = NULL; submit_info.commandBufferCount = 1; submit_info.pCommandBuffers = &cmd_buffer; submit_info.signalSemaphoreCount = 0; submit_info.pSignalSemaphores = NULL; if (info->waitSemaphoreCount <= MAX_PRESENT_SWAP_SEMAPHORE_COUNT) { submit_info.waitSemaphoreCount = info->waitSemaphoreCount; submit_info.pWaitSemaphores = info->pWaitSemaphores; submit_info.pWaitDstStageMask = semaphore_dst_stage_masks; submit_info.signalSemaphoreCount = 1; submit_info.pSignalSemaphores = &frame_data->semaphore; info->waitSemaphoreCount = 1; info->pWaitSemaphores = &frame_data->semaphore; } const VkFence fence = frame_data->fence; res = funcs->QueueSubmit(queue, 1, &submit_info, fence); #ifdef DEBUG_EXTRA hlog("QueueSubmit %s", result_to_str(res)); #endif if (res == VK_SUCCESS) frame_data->cmd_buffer_busy = true; } static inline bool valid_rect(struct vk_swap_data *swap) { return !!swap->image_extent.width && !!swap->image_extent.height && (swap->image_extent.width > 1 || swap->image_extent.height > 1); } static void vk_capture(struct vk_data *data, VkQueue queue, VkPresentInfoKHR *info) { // Use first swapchain ?? struct vk_swap_data *swap = get_swap_data(data, info->pSwapchains[0]); capture_update_socket(); if (capture_should_stop()) { vk_shtex_free(data); } if (capture_should_init()) { if (valid_rect(swap) && !vk_shtex_init(data, swap)) { vk_shtex_free(data); data->valid = false; hlog("vk_shtex_init failed"); } } if (capture_ready()) { if (swap != data->cur_swap) { vk_shtex_free(data); return; } vk_shtex_capture(data, &data->funcs, swap, 0, queue, info); } } static VkResult VKAPI_CALL OBS_QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *info) { VkPresentInfoKHR api = *info; struct vk_data *const data = get_device_data_by_queue(queue); struct vk_device_funcs *const funcs = &data->funcs; if (data->valid) { vk_capture(data, data->graphics_queue ? data->graphics_queue : queue, &api); } return funcs->QueuePresentKHR(queue, &api); } /* ======================================================================== */ /* setup hooks */ static inline bool is_inst_link_info(VkLayerInstanceCreateInfo *lici) { return lici->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO && lici->function == VK_LAYER_LINK_INFO; } static VkResult VKAPI_CALL OBS_CreateInstance(const VkInstanceCreateInfo *info, const VkAllocationCallbacks *ac, VkInstance *p_inst) { #ifndef NDEBUG hlog("CreateInstance"); #endif const char *req_extensions[] = { VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME, }; static uint32_t req_extensions_count = 1; int new_count = info->enabledExtensionCount + req_extensions_count; const char **exts = (const char**)malloc(sizeof(char*) * new_count); memcpy(exts, info->ppEnabledExtensionNames, sizeof(char*) * info->enabledExtensionCount); for (uint32_t i = 0; i < req_extensions_count; ++i) { exts[info->enabledExtensionCount + i] = req_extensions[i]; } VkInstanceCreateInfo *i = (VkInstanceCreateInfo*)info; i->enabledExtensionCount = new_count; i->ppEnabledExtensionNames = exts; /* -------------------------------------------------------- */ /* step through chain until we get to the link info */ VkLayerInstanceCreateInfo *lici = (VkLayerInstanceCreateInfo *)info->pNext; while (lici && !is_inst_link_info(lici)) { lici = (VkLayerInstanceCreateInfo *)lici->pNext; } if (lici == NULL) { return VK_ERROR_INITIALIZATION_FAILED; } PFN_vkGetInstanceProcAddr gpa = lici->u.pLayerInfo->pfnNextGetInstanceProcAddr; /* -------------------------------------------------------- */ /* move chain on for next layer */ lici->u.pLayerInfo = lici->u.pLayerInfo->pNext; /* -------------------------------------------------------- */ /* allocate data node */ struct vk_inst_data *idata = alloc_inst_data(ac); if (!idata) return VK_ERROR_OUT_OF_HOST_MEMORY; /* -------------------------------------------------------- */ /* create instance */ PFN_vkCreateInstance create = (PFN_vkCreateInstance)gpa(NULL, "vkCreateInstance"); VkResult res = create(info, ac, p_inst); #ifndef NDEBUG hlog("CreateInstance %s", result_to_str(res)); #endif bool valid = res == VK_SUCCESS; if (!valid) { /* try again with original arguments */ res = create(info, ac, p_inst); if (res != VK_SUCCESS) { vk_free(ac, idata); return res; } } VkInstance inst = *p_inst; init_inst_data(idata, inst); /* -------------------------------------------------------- */ /* fetch the functions we need */ struct vk_inst_funcs *ifuncs = &idata->funcs; #define GETADDR(x) \ do { \ ifuncs->x = (PFN_vk##x)gpa(inst, "vk" #x); \ if (!ifuncs->x) { \ hlog("could not get instance " \ "address for vk" #x); \ funcs_found = false; \ } \ } while (false) #define GETADDR_IF_SUPPORTED(x) \ do { \ ifuncs->x = (PFN_vk##x)gpa(inst, "vk" #x); \ } while (false) bool funcs_found = true; GETADDR(GetInstanceProcAddr); GETADDR(DestroyInstance); GETADDR(GetPhysicalDeviceQueueFamilyProperties); GETADDR(GetPhysicalDeviceMemoryProperties); GETADDR(GetPhysicalDeviceFormatProperties2KHR); GETADDR(GetPhysicalDeviceImageFormatProperties2KHR); GETADDR(GetPhysicalDeviceProperties2KHR); GETADDR(EnumerateDeviceExtensionProperties); #if HAVE_X11_XCB GETADDR_IF_SUPPORTED(CreateXcbSurfaceKHR); #endif #if HAVE_X11_XLIB GETADDR_IF_SUPPORTED(CreateXlibSurfaceKHR); #endif #if HAVE_WAYLAND GETADDR_IF_SUPPORTED(CreateWaylandSurfaceKHR); #endif GETADDR_IF_SUPPORTED(DestroySurfaceKHR); #undef GETADDR valid = valid && funcs_found; idata->valid = valid; if (valid) init_obj_list(&idata->surfaces); return res; } static void VKAPI_CALL OBS_DestroyInstance(VkInstance instance, const VkAllocationCallbacks *ac) { #ifndef NDEBUG hlog("DestroyInstance"); #endif struct vk_inst_funcs *ifuncs = get_inst_funcs(instance); PFN_vkDestroyInstance destroy_instance = ifuncs->DestroyInstance; remove_free_inst_data(instance, ac); destroy_instance(instance, ac); } static inline bool is_device_link_info(VkLayerDeviceCreateInfo *lici) { return lici->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO && lici->function == VK_LAYER_LINK_INFO; } static VkResult VKAPI_CALL OBS_CreateDevice(VkPhysicalDevice phy_device, const VkDeviceCreateInfo *info, const VkAllocationCallbacks *ac, VkDevice *p_device) { #ifndef NDEBUG hlog("CreateDevice"); #endif struct vk_inst_data *idata = get_inst_data_by_physical_device(phy_device); struct vk_inst_funcs *ifuncs = &idata->funcs; struct vk_data *data = NULL; const char *req_extensions[] = { VK_KHR_BIND_MEMORY_2_EXTENSION_NAME, VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME, VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME, VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME, VK_KHR_MAINTENANCE1_EXTENSION_NAME, VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME, VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME, VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME, }; static uint32_t req_extensions_count = 11; int new_count = info->enabledExtensionCount + req_extensions_count; const char **exts = (const char**)malloc(sizeof(char*) * new_count); memcpy(exts, info->ppEnabledExtensionNames, sizeof(char*) * info->enabledExtensionCount); for (uint32_t i = 0; i < req_extensions_count; ++i) { exts[info->enabledExtensionCount + i] = req_extensions[i]; } VkDeviceCreateInfo *i = (VkDeviceCreateInfo*)info; i->enabledExtensionCount = new_count; i->ppEnabledExtensionNames = exts; VkResult ret = VK_ERROR_INITIALIZATION_FAILED; VkLayerDeviceCreateInfo *ldci = (VkLayerDeviceCreateInfo*)info->pNext; /* -------------------------------------------------------- */ /* step through chain until we get to the link info */ while (ldci && !is_device_link_info(ldci)) { ldci = (VkLayerDeviceCreateInfo *)ldci->pNext; } if (!ldci) { return ret; } PFN_vkGetInstanceProcAddr gipa; PFN_vkGetDeviceProcAddr gdpa; gipa = ldci->u.pLayerInfo->pfnNextGetInstanceProcAddr; gdpa = ldci->u.pLayerInfo->pfnNextGetDeviceProcAddr; /* -------------------------------------------------------- */ /* move chain on for next layer */ ldci->u.pLayerInfo = ldci->u.pLayerInfo->pNext; /* -------------------------------------------------------- */ /* allocate data node */ data = alloc_device_data(ac); if (!data) return VK_ERROR_OUT_OF_HOST_MEMORY; init_obj_list(&data->queues); data->graphics_queue = VK_NULL_HANDLE; /* -------------------------------------------------------- */ /* create device and initialize hook data */ PFN_vkCreateDevice createFunc = (PFN_vkCreateDevice)gipa(idata->instance, "vkCreateDevice"); ret = createFunc(phy_device, info, ac, p_device); #ifndef NDEBUG hlog("CreateDevice %s", result_to_str(ret)); #endif if (ret != VK_SUCCESS) { vk_free(ac, data); return ret; } VkDevice device = *p_device; init_device_data(data, device); data->valid = false; /* set true below if it doesn't go to fail */ data->phy_device = phy_device; /* -------------------------------------------------------- */ /* fetch the functions we need */ struct vk_device_funcs *dfuncs = &data->funcs; bool funcs_found = true; #define GETADDR(x) \ do { \ dfuncs->x = (PFN_vk##x)gdpa(device, "vk" #x); \ if (!dfuncs->x) { \ hlog("could not get device " \ "address for vk" #x); \ funcs_found = false; \ } \ } while (false) GETADDR(GetDeviceProcAddr); GETADDR(DestroyDevice); GETADDR(CreateSwapchainKHR); GETADDR(DestroySwapchainKHR); GETADDR(QueuePresentKHR); GETADDR(AllocateMemory); GETADDR(FreeMemory); GETADDR(BindImageMemory2KHR); GETADDR(GetSwapchainImagesKHR); GETADDR(CreateImage); GETADDR(DestroyImage); GETADDR(GetImageMemoryRequirements2KHR); GETADDR(ResetCommandPool); GETADDR(BeginCommandBuffer); GETADDR(EndCommandBuffer); GETADDR(CmdCopyImage); GETADDR(CmdBlitImage); GETADDR(CmdPipelineBarrier); GETADDR(GetDeviceQueue); GETADDR(QueueSubmit); GETADDR(CreateCommandPool); GETADDR(DestroyCommandPool); GETADDR(AllocateCommandBuffers); GETADDR(CreateFence); GETADDR(DestroyFence); GETADDR(WaitForFences); GETADDR(ResetFences); GETADDR(GetImageSubresourceLayout); GETADDR(GetMemoryFdKHR); GETADDR(CreateSemaphore); GETADDR(DestroySemaphore); dfuncs->GetImageDrmFormatModifierPropertiesEXT = (PFN_vkGetImageDrmFormatModifierPropertiesEXT) gdpa(device, "vkGetImageDrmFormatModifierPropertiesEXT"); if (!dfuncs->GetImageDrmFormatModifierPropertiesEXT) { hlog("DRM format modifier support not available"); } #undef GETADDR if (!funcs_found) { return ret; } if (!idata->valid) { hlog("instance not valid"); return ret; } uint32_t device_extension_count = 0; ret = ifuncs->EnumerateDeviceExtensionProperties( phy_device, NULL, &device_extension_count, NULL); if (ret != VK_SUCCESS) { return ret; } VkExtensionProperties *device_extensions = malloc( sizeof(VkExtensionProperties) * device_extension_count); ret = ifuncs->EnumerateDeviceExtensionProperties( phy_device, NULL, &device_extension_count, device_extensions); if (ret != VK_SUCCESS) { free(device_extensions); return ret; } const char *required_device_extensions[] = { VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME }; bool extensions_found = true; for (int i = 0; i < sizeof(required_device_extensions) / sizeof(required_device_extensions[0]); i++) { const char *const ext = required_device_extensions[i]; bool found = false; for (uint32_t j = 0; j < device_extension_count; j++) { if (!strcmp(ext, device_extensions[j].extensionName)) { found = true; break; } } if (!found) { hlog("missing device extension: %s", ext); extensions_found = false; } } free(device_extensions); if (!extensions_found) { return ret; } data->inst_data = idata; data->ac = NULL; if (ac) { data->ac_storage = *ac; data->ac = &data->ac_storage; } uint32_t queue_family_property_count = 0; ifuncs->GetPhysicalDeviceQueueFamilyProperties( phy_device, &queue_family_property_count, NULL); VkQueueFamilyProperties *queue_family_properties = (VkQueueFamilyProperties*)malloc( sizeof(VkQueueFamilyProperties) * queue_family_property_count); ifuncs->GetPhysicalDeviceQueueFamilyProperties( phy_device, &queue_family_property_count, queue_family_properties); for (uint32_t info_index = 0, info_count = info->queueCreateInfoCount; info_index < info_count; ++info_index) { const VkDeviceQueueCreateInfo *queue_info = &info->pQueueCreateInfos[info_index]; for (uint32_t queue_index = 0, queue_count = queue_info->queueCount; queue_index < queue_count; ++queue_index) { const uint32_t family_index = queue_info->queueFamilyIndex; VkQueue queue; data->funcs.GetDeviceQueue(device, family_index, queue_index, &queue); const bool supports_transfer = (queue_family_properties[family_index] .queueFlags & (VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT)) != 0; const bool supports_graphics = (queue_family_properties[family_index] .queueFlags & (VK_QUEUE_GRAPHICS_BIT)) != 0; add_queue_data(data, queue, family_index, supports_transfer, supports_graphics, ac); } } free(queue_family_properties); init_obj_list(&data->swaps); data->cur_swap = NULL; VkPhysicalDeviceDriverProperties propsDriver = {}; propsDriver.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES; VkPhysicalDeviceIDProperties propsID = {}; propsID.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES; propsID.pNext = &propsDriver; VkPhysicalDeviceProperties2 props = {}; props.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2; props.pNext = &propsID; ifuncs->GetPhysicalDeviceProperties2KHR(phy_device, &props); data->driver_id = propsDriver.driverID; memcpy(data->device_uuid, propsID.deviceUUID, 16); data->valid = true; return ret; } static void VKAPI_CALL OBS_DestroyDevice(VkDevice device, const VkAllocationCallbacks *ac) { #ifndef NDEBUG hlog("DestroyDevice"); #endif struct vk_data *data = remove_device_data(device); if (data->valid) { struct vk_queue_data *queue_data = queue_walk_begin(data); while (queue_data) { vk_shtex_destroy_frame_objects(data, queue_data); queue_data = queue_walk_next(queue_data); } queue_walk_end(data); remove_free_queue_all(data, ac); } PFN_vkDestroyDevice destroy_device = data->funcs.DestroyDevice; vk_free(ac, data); destroy_device(device, ac); } static VkResult VKAPI_CALL OBS_CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR *cinfo, const VkAllocationCallbacks *ac, VkSwapchainKHR *p_sc) { struct vk_data *data = get_device_data(device); struct vk_device_funcs *funcs = &data->funcs; if (!data->valid) return funcs->CreateSwapchainKHR(device, cinfo, ac, p_sc); VkSwapchainCreateInfoKHR info = *cinfo; info.imageUsage |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT; VkResult res = funcs->CreateSwapchainKHR(device, &info, ac, p_sc); #ifndef NDEBUG hlog("CreateSwapchainKHR %s", result_to_str(res)); #endif if (res != VK_SUCCESS) { /* try again with original imageUsage flags */ return funcs->CreateSwapchainKHR(device, cinfo, ac, p_sc); } VkSwapchainKHR sc = *p_sc; uint32_t count = 0; res = funcs->GetSwapchainImagesKHR(device, sc, &count, NULL); #ifndef NDEBUG hlog("GetSwapchainImagesKHR %s", result_to_str(res)); #endif if ((res == VK_SUCCESS) && (count > 0)) { struct vk_swap_data *swap_data = alloc_swap_data(ac); if (swap_data) { init_swap_data(swap_data, data, sc); swap_data->swap_images = vk_alloc( ac, count * sizeof(VkImage), _Alignof(VkImage), VK_SYSTEM_ALLOCATION_SCOPE_OBJECT); res = funcs->GetSwapchainImagesKHR( device, sc, &count, swap_data->swap_images); #ifndef NDEBUG hlog("GetSwapchainImagesKHR %s", result_to_str(res)); #endif swap_data->image_extent = cinfo->imageExtent; swap_data->format = cinfo->imageFormat; swap_data->color_space = cinfo->imageColorSpace; swap_data->winid = find_surf_winid(data->inst_data, cinfo->surface); swap_data->export_image = VK_NULL_HANDLE; swap_data->export_mem = VK_NULL_HANDLE; swap_data->image_count = count; swap_data->dmabuf_nfd = 0; memset(swap_data->dmabuf_fds, -1, sizeof(swap_data->dmabuf_fds)); swap_data->captured = false; } } return VK_SUCCESS; } static void VKAPI_CALL OBS_DestroySwapchainKHR(VkDevice device, VkSwapchainKHR sc, const VkAllocationCallbacks *ac) { #ifndef NDEBUG hlog("DestroySwapchainKHR"); #endif struct vk_data *data = get_device_data(device); struct vk_device_funcs *funcs = &data->funcs; PFN_vkDestroySwapchainKHR destroy_swapchain = funcs->DestroySwapchainKHR; if ((sc != VK_NULL_HANDLE) && data->valid) { struct vk_swap_data *swap = get_swap_data(data, sc); if (swap) { if (data->cur_swap == swap) { vk_shtex_free(data); } vk_free(ac, swap->swap_images); remove_free_swap_data(data, sc, ac); } } destroy_swapchain(device, sc, ac); } #if HAVE_X11_XCB static VkResult VKAPI_CALL OBS_CreateXcbSurfaceKHR( VkInstance inst, const VkXcbSurfaceCreateInfoKHR *info, const VkAllocationCallbacks *ac, VkSurfaceKHR *surf) { #ifndef NDEBUG hlog("CreateXcbSurfaceKHR"); #endif struct vk_inst_data *idata = get_inst_data(inst); struct vk_inst_funcs *ifuncs = &idata->funcs; VkResult res = ifuncs->CreateXcbSurfaceKHR(inst, info, ac, surf); if ((res == VK_SUCCESS) && idata->valid) add_surf_data(idata, *surf, info->window, ac); return res; } #endif #if HAVE_X11_XLIB static VkResult VKAPI_CALL OBS_CreateXlibSurfaceKHR( VkInstance inst, const VkXlibSurfaceCreateInfoKHR *info, const VkAllocationCallbacks *ac, VkSurfaceKHR *surf) { #ifndef NDEBUG hlog("CreateXlibSurfaceKHR"); #endif struct vk_inst_data *idata = get_inst_data(inst); struct vk_inst_funcs *ifuncs = &idata->funcs; VkResult res = ifuncs->CreateXlibSurfaceKHR(inst, info, ac, surf); if ((res == VK_SUCCESS) && idata->valid) add_surf_data(idata, *surf, info->window, ac); return res; } #endif #if HAVE_WAYLAND static VkResult VKAPI_CALL OBS_CreateWaylandSurfaceKHR( VkInstance inst, const VkWaylandSurfaceCreateInfoKHR *info, const VkAllocationCallbacks *ac, VkSurfaceKHR *surf) { #ifndef NDEBUG hlog("CreateWaylandSurfaceKHR"); #endif struct vk_inst_data *idata = get_inst_data(inst); struct vk_inst_funcs *ifuncs = &idata->funcs; VkResult res = ifuncs->CreateWaylandSurfaceKHR(inst, info, ac, surf); if ((res == VK_SUCCESS) && idata->valid) { add_surf_data(idata, *surf, (uintptr_t)info->surface, ac); } return res; } #endif static void VKAPI_CALL OBS_DestroySurfaceKHR(VkInstance inst, VkSurfaceKHR surf, const VkAllocationCallbacks *ac) { #ifndef NDEBUG hlog("DestroySurfaceKHR"); #endif struct vk_inst_data *idata = get_inst_data(inst); struct vk_inst_funcs *ifuncs = &idata->funcs; PFN_vkDestroySurfaceKHR destroy_surface = ifuncs->DestroySurfaceKHR; if ((surf != VK_NULL_HANDLE) && idata->valid) remove_free_surf_data(idata, surf, ac); destroy_surface(inst, surf, ac); } #define GETPROCADDR(func) \ if (!strcmp(pName, "vk" #func)) \ return (PFN_vkVoidFunction)&OBS_##func; #define GETPROCADDR_IF_SUPPORTED(func) \ if (!strcmp(pName, "vk" #func)) \ return funcs && funcs->func ? (PFN_vkVoidFunction)&OBS_##func : NULL; static PFN_vkVoidFunction VKAPI_CALL OBS_GetDeviceProcAddr(VkDevice device, const char *pName) { struct vk_data *data = get_device_data(device); struct vk_device_funcs *funcs = &data->funcs; GETPROCADDR(GetDeviceProcAddr); GETPROCADDR(DestroyDevice); GETPROCADDR_IF_SUPPORTED(CreateSwapchainKHR); GETPROCADDR_IF_SUPPORTED(DestroySwapchainKHR); GETPROCADDR_IF_SUPPORTED(QueuePresentKHR); if (funcs->GetDeviceProcAddr == NULL) return NULL; return funcs->GetDeviceProcAddr(device, pName); } static PFN_vkVoidFunction VKAPI_CALL OBS_GetInstanceProcAddr(VkInstance instance, const char *pName) { /* instance chain functions we intercept */ GETPROCADDR(GetInstanceProcAddr); GETPROCADDR(CreateInstance); struct vk_inst_funcs *const funcs = instance ? get_inst_funcs(instance) : NULL; /* other instance chain functions we intercept */ GETPROCADDR(DestroyInstance); #if HAVE_X11_XCB GETPROCADDR_IF_SUPPORTED(CreateXcbSurfaceKHR); #endif #if HAVE_X11_XLIB GETPROCADDR_IF_SUPPORTED(CreateXlibSurfaceKHR); #endif #if HAVE_WAYLAND GETPROCADDR_IF_SUPPORTED(CreateWaylandSurfaceKHR); #endif GETPROCADDR_IF_SUPPORTED(DestroySurfaceKHR); /* device chain functions we intercept */ GETPROCADDR(GetDeviceProcAddr); GETPROCADDR(CreateDevice); GETPROCADDR(DestroyDevice); if (!funcs) return NULL; const PFN_vkGetInstanceProcAddr gipa = funcs->GetInstanceProcAddr; return gipa ? gipa(instance, pName) : NULL; } #undef GETPROCADDR VKAPI_ATTR VkResult VKAPI_CALL OBS_Negotiate(VkNegotiateLayerInterface *nli) { if (nli->loaderLayerInterfaceVersion >= 2) { nli->sType = LAYER_NEGOTIATE_INTERFACE_STRUCT; nli->pNext = NULL; nli->pfnGetInstanceProcAddr = OBS_GetInstanceProcAddr; nli->pfnGetDeviceProcAddr = OBS_GetDeviceProcAddr; nli->pfnGetPhysicalDeviceProcAddr = NULL; } const uint32_t cur_ver = CURRENT_LOADER_LAYER_INTERFACE_VERSION; if (nli->loaderLayerInterfaceVersion > cur_ver) { nli->loaderLayerInterfaceVersion = cur_ver; } if (!vulkan_seen) { hlog("Init Vulkan %s (%s)", PLUGIN_VERSION, #ifdef __x86_64__ "64bit"); #else "32bit"); #endif init_obj_list(&instances); init_obj_list(&devices); capture_init(); vulkan_seen = true; vkcapture_linear = getenv("OBS_VKCAPTURE_LINEAR"); for (int i = 0; i < MAX_PRESENT_SWAP_SEMAPHORE_COUNT; i++) { semaphore_dst_stage_masks[i] = VK_PIPELINE_STAGE_TRANSFER_BIT; } } return VK_SUCCESS; } obs-vkcapture-1.5.2/src/vklayer.h000066400000000000000000000361371501231770600167350ustar00rootroot00000000000000/* OBS Linux Vulkan game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #pragma once #include "plugin-macros.h" #include #include #if HAVE_X11_XCB #include #include #endif #if HAVE_X11_XLIB #include #include #endif #if HAVE_WAYLAND #include #endif #ifndef VK_EXT_image_drm_format_modifier #define VK_EXT_image_drm_format_modifier 1 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION 1 #define VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME "VK_EXT_image_drm_format_modifier" #define VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT -1000158000 #define VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT 1000158000 #define VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT 1000158003 #define VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT 1000158005 #define VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT 1000158002 #define VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT 1000158000 typedef struct VkDrmFormatModifierPropertiesEXT { uint64_t drmFormatModifier; uint32_t drmFormatModifierPlaneCount; VkFormatFeatureFlags drmFormatModifierTilingFeatures; } VkDrmFormatModifierPropertiesEXT; typedef struct VkDrmFormatModifierPropertiesListEXT { VkStructureType sType; void* pNext; uint32_t drmFormatModifierCount; VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; } VkDrmFormatModifierPropertiesListEXT; typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { VkStructureType sType; const void* pNext; uint64_t drmFormatModifier; VkSharingMode sharingMode; uint32_t queueFamilyIndexCount; const uint32_t* pQueueFamilyIndices; } VkPhysicalDeviceImageDrmFormatModifierInfoEXT; typedef struct VkImageDrmFormatModifierListCreateInfoEXT { VkStructureType sType; const void* pNext; uint32_t drmFormatModifierCount; const uint64_t* pDrmFormatModifiers; } VkImageDrmFormatModifierListCreateInfoEXT; typedef struct VkImageDrmFormatModifierPropertiesEXT { VkStructureType sType; void* pNext; uint64_t drmFormatModifier; } VkImageDrmFormatModifierPropertiesEXT; typedef VkResult (VKAPI_PTR *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); #endif #define DEF_FUNC(x) PFN_vk##x x struct vk_inst_funcs { DEF_FUNC(GetInstanceProcAddr); DEF_FUNC(DestroyInstance); DEF_FUNC(GetPhysicalDeviceQueueFamilyProperties); DEF_FUNC(GetPhysicalDeviceMemoryProperties); DEF_FUNC(GetPhysicalDeviceFormatProperties2KHR); DEF_FUNC(GetPhysicalDeviceImageFormatProperties2KHR); DEF_FUNC(GetPhysicalDeviceProperties2KHR); DEF_FUNC(EnumerateDeviceExtensionProperties); #if HAVE_X11_XCB DEF_FUNC(CreateXcbSurfaceKHR); #endif #if HAVE_X11_XLIB DEF_FUNC(CreateXlibSurfaceKHR); #endif #if HAVE_WAYLAND DEF_FUNC(CreateWaylandSurfaceKHR); #endif DEF_FUNC(DestroySurfaceKHR); }; struct vk_device_funcs { DEF_FUNC(GetDeviceProcAddr); DEF_FUNC(DestroyDevice); DEF_FUNC(CreateSwapchainKHR); DEF_FUNC(DestroySwapchainKHR); DEF_FUNC(QueuePresentKHR); DEF_FUNC(AllocateMemory); DEF_FUNC(FreeMemory); DEF_FUNC(BindImageMemory2KHR); DEF_FUNC(GetSwapchainImagesKHR); DEF_FUNC(CreateImage); DEF_FUNC(DestroyImage); DEF_FUNC(GetImageMemoryRequirements2KHR); DEF_FUNC(ResetCommandPool); DEF_FUNC(BeginCommandBuffer); DEF_FUNC(EndCommandBuffer); DEF_FUNC(CmdCopyImage); DEF_FUNC(CmdBlitImage); DEF_FUNC(CmdPipelineBarrier); DEF_FUNC(GetDeviceQueue); DEF_FUNC(QueueSubmit); DEF_FUNC(CreateCommandPool); DEF_FUNC(DestroyCommandPool); DEF_FUNC(AllocateCommandBuffers); DEF_FUNC(CreateFence); DEF_FUNC(DestroyFence); DEF_FUNC(WaitForFences); DEF_FUNC(ResetFences); DEF_FUNC(GetImageSubresourceLayout); DEF_FUNC(GetMemoryFdKHR); DEF_FUNC(GetImageDrmFormatModifierPropertiesEXT); DEF_FUNC(CreateSemaphore); DEF_FUNC(DestroySemaphore); }; #undef DEF_FUNC static const char *vk_format_to_str(VkFormat format) { switch (format) { default: #define VAL(x) case x: return #x VAL(VK_FORMAT_UNDEFINED); VAL(VK_FORMAT_R4G4_UNORM_PACK8); VAL(VK_FORMAT_R4G4B4A4_UNORM_PACK16); VAL(VK_FORMAT_B4G4R4A4_UNORM_PACK16); VAL(VK_FORMAT_R5G6B5_UNORM_PACK16); VAL(VK_FORMAT_B5G6R5_UNORM_PACK16); VAL(VK_FORMAT_R5G5B5A1_UNORM_PACK16); VAL(VK_FORMAT_B5G5R5A1_UNORM_PACK16); VAL(VK_FORMAT_A1R5G5B5_UNORM_PACK16); VAL(VK_FORMAT_R8_UNORM); VAL(VK_FORMAT_R8_SNORM); VAL(VK_FORMAT_R8_USCALED); VAL(VK_FORMAT_R8_SSCALED); VAL(VK_FORMAT_R8_UINT); VAL(VK_FORMAT_R8_SINT); VAL(VK_FORMAT_R8_SRGB); VAL(VK_FORMAT_R8G8_UNORM); VAL(VK_FORMAT_R8G8_SNORM); VAL(VK_FORMAT_R8G8_USCALED); VAL(VK_FORMAT_R8G8_SSCALED); VAL(VK_FORMAT_R8G8_UINT); VAL(VK_FORMAT_R8G8_SINT); VAL(VK_FORMAT_R8G8_SRGB); VAL(VK_FORMAT_R8G8B8_UNORM); VAL(VK_FORMAT_R8G8B8_SNORM); VAL(VK_FORMAT_R8G8B8_USCALED); VAL(VK_FORMAT_R8G8B8_SSCALED); VAL(VK_FORMAT_R8G8B8_UINT); VAL(VK_FORMAT_R8G8B8_SINT); VAL(VK_FORMAT_R8G8B8_SRGB); VAL(VK_FORMAT_B8G8R8_UNORM); VAL(VK_FORMAT_B8G8R8_SNORM); VAL(VK_FORMAT_B8G8R8_USCALED); VAL(VK_FORMAT_B8G8R8_SSCALED); VAL(VK_FORMAT_B8G8R8_UINT); VAL(VK_FORMAT_B8G8R8_SINT); VAL(VK_FORMAT_B8G8R8_SRGB); VAL(VK_FORMAT_R8G8B8A8_UNORM); VAL(VK_FORMAT_R8G8B8A8_SNORM); VAL(VK_FORMAT_R8G8B8A8_USCALED); VAL(VK_FORMAT_R8G8B8A8_SSCALED); VAL(VK_FORMAT_R8G8B8A8_UINT); VAL(VK_FORMAT_R8G8B8A8_SINT); VAL(VK_FORMAT_R8G8B8A8_SRGB); /* dota 2 */ VAL(VK_FORMAT_B8G8R8A8_UNORM); VAL(VK_FORMAT_B8G8R8A8_SNORM); VAL(VK_FORMAT_B8G8R8A8_USCALED); VAL(VK_FORMAT_B8G8R8A8_SSCALED); VAL(VK_FORMAT_B8G8R8A8_UINT); VAL(VK_FORMAT_B8G8R8A8_SINT); VAL(VK_FORMAT_B8G8R8A8_SRGB); VAL(VK_FORMAT_A8B8G8R8_UNORM_PACK32); VAL(VK_FORMAT_A8B8G8R8_SNORM_PACK32); VAL(VK_FORMAT_A8B8G8R8_USCALED_PACK32); VAL(VK_FORMAT_A8B8G8R8_SSCALED_PACK32); VAL(VK_FORMAT_A8B8G8R8_UINT_PACK32); VAL(VK_FORMAT_A8B8G8R8_SINT_PACK32); VAL(VK_FORMAT_A8B8G8R8_SRGB_PACK32); VAL(VK_FORMAT_A2R10G10B10_UNORM_PACK32); VAL(VK_FORMAT_A2R10G10B10_SNORM_PACK32); VAL(VK_FORMAT_A2R10G10B10_USCALED_PACK32); VAL(VK_FORMAT_A2R10G10B10_SSCALED_PACK32); VAL(VK_FORMAT_A2R10G10B10_UINT_PACK32); VAL(VK_FORMAT_A2R10G10B10_SINT_PACK32); VAL(VK_FORMAT_A2B10G10R10_UNORM_PACK32); VAL(VK_FORMAT_A2B10G10R10_SNORM_PACK32); VAL(VK_FORMAT_A2B10G10R10_USCALED_PACK32); VAL(VK_FORMAT_A2B10G10R10_SSCALED_PACK32); VAL(VK_FORMAT_A2B10G10R10_UINT_PACK32); VAL(VK_FORMAT_A2B10G10R10_SINT_PACK32); VAL(VK_FORMAT_R16_UNORM); VAL(VK_FORMAT_R16_SNORM); VAL(VK_FORMAT_R16_USCALED); VAL(VK_FORMAT_R16_SSCALED); VAL(VK_FORMAT_R16_UINT); VAL(VK_FORMAT_R16_SINT); VAL(VK_FORMAT_R16_SFLOAT); VAL(VK_FORMAT_R16G16_UNORM); VAL(VK_FORMAT_R16G16_SNORM); VAL(VK_FORMAT_R16G16_USCALED); VAL(VK_FORMAT_R16G16_SSCALED); VAL(VK_FORMAT_R16G16_UINT); VAL(VK_FORMAT_R16G16_SINT); VAL(VK_FORMAT_R16G16_SFLOAT); VAL(VK_FORMAT_R16G16B16_UNORM); VAL(VK_FORMAT_R16G16B16_SNORM); VAL(VK_FORMAT_R16G16B16_USCALED); VAL(VK_FORMAT_R16G16B16_SSCALED); VAL(VK_FORMAT_R16G16B16_UINT); VAL(VK_FORMAT_R16G16B16_SINT); VAL(VK_FORMAT_R16G16B16_SFLOAT); VAL(VK_FORMAT_R16G16B16A16_UNORM); VAL(VK_FORMAT_R16G16B16A16_SNORM); VAL(VK_FORMAT_R16G16B16A16_USCALED); VAL(VK_FORMAT_R16G16B16A16_SSCALED); VAL(VK_FORMAT_R16G16B16A16_UINT); VAL(VK_FORMAT_R16G16B16A16_SINT); VAL(VK_FORMAT_R16G16B16A16_SFLOAT); VAL(VK_FORMAT_R32_UINT); VAL(VK_FORMAT_R32_SINT); VAL(VK_FORMAT_R32_SFLOAT); VAL(VK_FORMAT_R32G32_UINT); VAL(VK_FORMAT_R32G32_SINT); VAL(VK_FORMAT_R32G32_SFLOAT); VAL(VK_FORMAT_R32G32B32_UINT); VAL(VK_FORMAT_R32G32B32_SINT); VAL(VK_FORMAT_R32G32B32_SFLOAT); VAL(VK_FORMAT_R32G32B32A32_UINT); VAL(VK_FORMAT_R32G32B32A32_SINT); VAL(VK_FORMAT_R32G32B32A32_SFLOAT); VAL(VK_FORMAT_R64_UINT); VAL(VK_FORMAT_R64_SINT); VAL(VK_FORMAT_R64_SFLOAT); VAL(VK_FORMAT_R64G64_UINT); VAL(VK_FORMAT_R64G64_SINT); VAL(VK_FORMAT_R64G64_SFLOAT); VAL(VK_FORMAT_R64G64B64_UINT); VAL(VK_FORMAT_R64G64B64_SINT); VAL(VK_FORMAT_R64G64B64_SFLOAT); VAL(VK_FORMAT_R64G64B64A64_UINT); VAL(VK_FORMAT_R64G64B64A64_SINT); VAL(VK_FORMAT_R64G64B64A64_SFLOAT); VAL(VK_FORMAT_B10G11R11_UFLOAT_PACK32); VAL(VK_FORMAT_E5B9G9R9_UFLOAT_PACK32); VAL(VK_FORMAT_D16_UNORM); VAL(VK_FORMAT_X8_D24_UNORM_PACK32); VAL(VK_FORMAT_D32_SFLOAT); VAL(VK_FORMAT_S8_UINT); VAL(VK_FORMAT_D16_UNORM_S8_UINT); VAL(VK_FORMAT_D24_UNORM_S8_UINT); VAL(VK_FORMAT_D32_SFLOAT_S8_UINT); VAL(VK_FORMAT_BC1_RGB_UNORM_BLOCK); VAL(VK_FORMAT_BC1_RGB_SRGB_BLOCK); VAL(VK_FORMAT_BC1_RGBA_UNORM_BLOCK); VAL(VK_FORMAT_BC1_RGBA_SRGB_BLOCK); VAL(VK_FORMAT_BC2_UNORM_BLOCK); VAL(VK_FORMAT_BC2_SRGB_BLOCK); VAL(VK_FORMAT_BC3_UNORM_BLOCK); VAL(VK_FORMAT_BC3_SRGB_BLOCK); VAL(VK_FORMAT_BC4_UNORM_BLOCK); VAL(VK_FORMAT_BC4_SNORM_BLOCK); VAL(VK_FORMAT_BC5_UNORM_BLOCK); VAL(VK_FORMAT_BC5_SNORM_BLOCK); VAL(VK_FORMAT_BC6H_UFLOAT_BLOCK); VAL(VK_FORMAT_BC6H_SFLOAT_BLOCK); VAL(VK_FORMAT_BC7_UNORM_BLOCK); VAL(VK_FORMAT_BC7_SRGB_BLOCK); VAL(VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK); VAL(VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK); VAL(VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK); VAL(VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK); VAL(VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK); VAL(VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK); VAL(VK_FORMAT_EAC_R11_UNORM_BLOCK); VAL(VK_FORMAT_EAC_R11_SNORM_BLOCK); VAL(VK_FORMAT_EAC_R11G11_UNORM_BLOCK); VAL(VK_FORMAT_EAC_R11G11_SNORM_BLOCK); VAL(VK_FORMAT_ASTC_4x4_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_4x4_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_5x4_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_5x4_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_5x5_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_5x5_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_6x5_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_6x5_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_6x6_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_6x6_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_8x5_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_8x5_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_8x6_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_8x6_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_8x8_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_8x8_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_10x5_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_10x5_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_10x6_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_10x6_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_10x8_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_10x8_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_10x10_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_10x10_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_12x10_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_12x10_SRGB_BLOCK); VAL(VK_FORMAT_ASTC_12x12_UNORM_BLOCK); VAL(VK_FORMAT_ASTC_12x12_SRGB_BLOCK); VAL(VK_FORMAT_G8B8G8R8_422_UNORM); VAL(VK_FORMAT_B8G8R8G8_422_UNORM); VAL(VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM); VAL(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM); VAL(VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM); VAL(VK_FORMAT_G8_B8R8_2PLANE_422_UNORM); VAL(VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM); VAL(VK_FORMAT_R10X6_UNORM_PACK16); VAL(VK_FORMAT_R10X6G10X6_UNORM_2PACK16); VAL(VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16); VAL(VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16); VAL(VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16); VAL(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16); VAL(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16); VAL(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16); VAL(VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16); VAL(VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16); VAL(VK_FORMAT_R12X4_UNORM_PACK16); VAL(VK_FORMAT_R12X4G12X4_UNORM_2PACK16); VAL(VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16); VAL(VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16); VAL(VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16); VAL(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16); VAL(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16); VAL(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16); VAL(VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16); VAL(VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16); VAL(VK_FORMAT_G16B16G16R16_422_UNORM); VAL(VK_FORMAT_B16G16R16G16_422_UNORM); VAL(VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM); VAL(VK_FORMAT_G16_B16R16_2PLANE_420_UNORM); VAL(VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM); VAL(VK_FORMAT_G16_B16R16_2PLANE_422_UNORM); VAL(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM); VAL(VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG); VAL(VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG); VAL(VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG); VAL(VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG); VAL(VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG); VAL(VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG); VAL(VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG); VAL(VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG); } } static const char *result_to_str(VkResult result) { switch (result) { VAL(VK_SUCCESS); VAL(VK_NOT_READY); VAL(VK_TIMEOUT); VAL(VK_EVENT_SET); VAL(VK_EVENT_RESET); VAL(VK_INCOMPLETE); VAL(VK_ERROR_OUT_OF_HOST_MEMORY); VAL(VK_ERROR_OUT_OF_DEVICE_MEMORY); VAL(VK_ERROR_INITIALIZATION_FAILED); VAL(VK_ERROR_DEVICE_LOST); VAL(VK_ERROR_MEMORY_MAP_FAILED); VAL(VK_ERROR_LAYER_NOT_PRESENT); VAL(VK_ERROR_EXTENSION_NOT_PRESENT); VAL(VK_ERROR_FEATURE_NOT_PRESENT); VAL(VK_ERROR_INCOMPATIBLE_DRIVER); VAL(VK_ERROR_TOO_MANY_OBJECTS); VAL(VK_ERROR_FORMAT_NOT_SUPPORTED); VAL(VK_ERROR_FRAGMENTED_POOL); VAL(VK_ERROR_OUT_OF_POOL_MEMORY); VAL(VK_ERROR_INVALID_EXTERNAL_HANDLE); VAL(VK_ERROR_SURFACE_LOST_KHR); VAL(VK_ERROR_NATIVE_WINDOW_IN_USE_KHR); VAL(VK_SUBOPTIMAL_KHR); VAL(VK_ERROR_OUT_OF_DATE_KHR); VAL(VK_ERROR_INCOMPATIBLE_DISPLAY_KHR); VAL(VK_ERROR_VALIDATION_FAILED_EXT); VAL(VK_ERROR_INVALID_SHADER_NV); VAL(VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT); VAL(VK_ERROR_NOT_PERMITTED_EXT); //VAL(VK_ERROR_OUT_OF_POOL_MEMORY_KHR); //VAL(VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR); VAL(VK_RESULT_MAX_ENUM); #undef VAL default: return "Unknown VkResult"; } } obs-vkcapture-1.5.2/src/vklayer.version000066400000000000000000000000661501231770600201630ustar00rootroot00000000000000{ global: OBS_Negotiate; local: *; }; obs-vkcapture-1.5.2/src/wlcursor.c000066400000000000000000000273631501231770600171340ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #include "wlcursor.h" #include "capture.h" #include #include #include #include struct output_data { wl_cursor_t *ctx; uint32_t id; struct wl_output *output; struct wl_buffer *buffer; uint32_t buffer_width; uint32_t buffer_height; uint32_t buffer_stride; void *buffer_data; struct ext_screencopy_session_v1 *session; int32_t pos_x; int32_t pos_y; int32_t hotspot_x; int32_t hotspot_y; bool damaged; bool have_cursor; gs_texture_t *tex; }; static void capture_output(struct output_data *data); static void output_data_reset(struct output_data *data) { if (data->buffer) { wl_buffer_destroy(data->buffer); data->buffer = NULL; } if (data->buffer_data) { munmap(data->buffer_data, data->buffer_stride * data->buffer_height); data->buffer_data = NULL; } if (data->session) { ext_screencopy_session_v1_destroy(data->session); data->session = NULL; } if (data->tex) { gs_texture_destroy(data->tex); data->tex = NULL; } data->damaged = false; data->have_cursor = false; } static enum wl_shm_format drm_format_to_wl_shm(uint32_t in) { switch (in) { case DRM_FORMAT_ARGB8888: return WL_SHM_FORMAT_ARGB8888; case DRM_FORMAT_XRGB8888: return WL_SHM_FORMAT_XRGB8888; default: blog(LOG_ERROR, "unknown shm format %u", in); return in; } } static struct wl_buffer *create_shm_buffer(struct wl_shm *shm, enum wl_shm_format fmt, int width, int height, int stride, void **data_out) { int size = stride * height; const char shm_name[] = "/obs-vkcapture-wlshm"; int fd = shm_open(shm_name, O_RDWR | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR); if (fd < 0) { return NULL; } shm_unlink(shm_name); int ret; while ((ret = ftruncate(fd, size)) == EINTR) { } if (ret < 0) { close(fd); return NULL; } void *data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if (data == MAP_FAILED) { close(fd); return NULL; } struct wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size); close(fd); struct wl_buffer *buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, fmt); wl_shm_pool_destroy(pool); *data_out = data; return buffer; } static void session_handle_buffer_info(void *data, struct ext_screencopy_session_v1 *session, uint32_t type, uint32_t fourcc, uint32_t width, uint32_t height, uint32_t stride) { } static void session_handle_cursor_buffer_info(void *data_, struct ext_screencopy_session_v1 *session, const char *name, enum ext_screencopy_session_v1_input_type input_type, uint32_t type, uint32_t format, uint32_t width, uint32_t height, uint32_t stride) { struct output_data *data = data_; if (type != EXT_SCREENCOPY_SESSION_V1_BUFFER_TYPE_WL_SHM) { return; } if (data->buffer) { return; } data->buffer_width = width; data->buffer_height = height; data->buffer_stride = stride; data->buffer = create_shm_buffer(data->ctx->shm, drm_format_to_wl_shm(format), data->buffer_width, data->buffer_height, data->buffer_stride, &data->buffer_data); if (!data->buffer) { blog(LOG_ERROR, "failed to create shm buffer"); } else { data->tex = gs_texture_create(width, height, GS_BGRA, 1, NULL, GS_DYNAMIC); } } static void session_handle_init_done(void *data_, struct ext_screencopy_session_v1 *session) { struct output_data *data = data_; if (!data->buffer) { blog(LOG_ERROR, "no available shm buffers"); return; } ext_screencopy_session_v1_attach_cursor_buffer(session, data->buffer, NULL, EXT_SCREENCOPY_SESSION_V1_INPUT_TYPE_POINTER); ext_screencopy_session_v1_damage_cursor_buffer(session, NULL, EXT_SCREENCOPY_SESSION_V1_INPUT_TYPE_POINTER); ext_screencopy_session_v1_commit(session, EXT_SCREENCOPY_SESSION_V1_OPTIONS_ON_DAMAGE); } static void session_handle_damage(void *data, struct ext_screencopy_session_v1 *session, uint32_t x, uint32_t y, uint32_t width, uint32_t height) { } static void session_handle_cursor_info(void *data_, struct ext_screencopy_session_v1 *session, const char *name, enum ext_screencopy_session_v1_input_type input_type, int damaged, int32_t pos_x, int32_t pos_y, int32_t width, int32_t height, int32_t hotspot_x, int32_t hotspot_y) { struct output_data *data = data_; data->pos_x = pos_x; data->pos_y = pos_y; data->hotspot_x = hotspot_x; data->hotspot_y = hotspot_y; data->damaged = damaged; } static void session_handle_cursor_enter(void *data_, struct ext_screencopy_session_v1 *session, const char *seat_name, uint32_t input_type) { struct output_data *data = data_; data->have_cursor = true; } static void session_handle_cursor_leave(void *data_, struct ext_screencopy_session_v1 *session, const char *seat_name, uint32_t input_type) { struct output_data *data = data_; data->have_cursor = false; } static void session_handle_transform(void *data, struct ext_screencopy_session_v1 *session, int32_t transform) { } static void session_handle_presentation_time(void *data, struct ext_screencopy_session_v1 *session, uint32_t tv_sec_hi, uint32_t tv_sec_lo, uint32_t tv_nsec) { } static void session_handle_ready(void *data_, struct ext_screencopy_session_v1 *session) { struct output_data *data = data_; if (data->damaged) { gs_texture_set_image(data->tex, data->buffer_data, data->buffer_stride, false); } ext_screencopy_session_v1_attach_cursor_buffer(session, data->buffer, NULL, EXT_SCREENCOPY_SESSION_V1_INPUT_TYPE_POINTER); ext_screencopy_session_v1_damage_cursor_buffer(session, NULL, EXT_SCREENCOPY_SESSION_V1_INPUT_TYPE_POINTER); ext_screencopy_session_v1_commit(session, EXT_SCREENCOPY_SESSION_V1_OPTIONS_ON_DAMAGE); } static void session_handle_failed(void *data_, struct ext_screencopy_session_v1 *session, enum ext_screencopy_session_v1_failure_reason reason) { struct output_data *data = data_; output_data_reset(data); if (reason == EXT_SCREENCOPY_SESSION_V1_FAILURE_REASON_OUTPUT_DISABLED) { capture_output(data); return; } blog(LOG_ERROR, "failed to copy session %d", reason); } static const struct ext_screencopy_session_v1_listener session_listener = { .buffer_info = session_handle_buffer_info, .cursor_buffer_info = session_handle_cursor_buffer_info, .init_done = session_handle_init_done, .damage = session_handle_damage, .cursor_info = session_handle_cursor_info, .cursor_enter = session_handle_cursor_enter, .cursor_leave = session_handle_cursor_leave, .presentation_time = session_handle_presentation_time, .transform = session_handle_transform, .ready = session_handle_ready, .failed = session_handle_failed, }; static void capture_output(struct output_data *data) { if (data->session || !data->ctx->screencopy) { return; } data->session = ext_screencopy_manager_v1_capture_output(data->ctx->screencopy, data->output, 0); ext_screencopy_session_v1_add_listener(data->session, &session_listener, data); } static void handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) { wl_cursor_t *ctx = data; if (!strcmp(interface, wl_output_interface.name)) { struct output_data *output_data = bzalloc(sizeof(struct output_data)); output_data->ctx = ctx; output_data->id = name; output_data->output = wl_registry_bind(registry, name, &wl_output_interface, 1); da_push_back(ctx->outputs, &output_data); capture_output(output_data); } else if (!strcmp(interface, wl_shm_interface.name)) { ctx->shm = wl_registry_bind(registry, name, &wl_shm_interface, 1); } else if (!strcmp(interface, ext_screencopy_manager_v1_interface.name)) { ctx->screencopy = wl_registry_bind(registry, name, &ext_screencopy_manager_v1_interface, 1); } } static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) { wl_cursor_t *ctx = data; for (size_t i = 0; i < ctx->outputs.num; ++i) { struct output_data *o = *(ctx->outputs.array + i); if (o->id == name) { output_data_reset(o); bfree(o); da_erase(ctx->outputs, i); break; } } } static const struct wl_registry_listener registry_listener = { .global = handle_global, .global_remove = handle_global_remove, }; wl_cursor_t *wl_cursor_init(struct wl_display *display) { wl_cursor_t *data = bzalloc(sizeof(wl_cursor_t)); da_init(data->outputs); struct wl_registry *registry = wl_display_get_registry(display); wl_registry_add_listener(registry, ®istry_listener, data); wl_display_roundtrip(display); if (!data->shm) { blog(LOG_ERROR, "wl_shm not available"); wl_cursor_destroy(data); return NULL; } if (!data->screencopy) { blog(LOG_ERROR, "ext_screencopy_manager_v1 not available"); wl_cursor_destroy(data); return NULL; } for (size_t i = 0; i < data->outputs.num; ++i) { capture_output(*(data->outputs.array + i)); } return data; } void wl_cursor_destroy(wl_cursor_t *data) { for (size_t i = 0; i < data->outputs.num; ++i) { struct output_data *output_data = *(data->outputs.array + i); output_data_reset(output_data); bfree(output_data); } da_free(data->outputs); bfree(data); } void wl_cursor_render(wl_cursor_t *data) { struct output_data *output_data = NULL; for (size_t i = 0; i < data->outputs.num; ++i) { struct output_data *o = *(data->outputs.array + i); if (o->have_cursor && o->tex) { output_data = o; break; } } if (!output_data) { return; } const bool linear_srgb = gs_get_linear_srgb(); const bool previous = gs_framebuffer_srgb_enabled(); gs_enable_framebuffer_srgb(linear_srgb); gs_effect_t *effect = gs_get_effect(); gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image"); if (linear_srgb) gs_effect_set_texture_srgb(image, output_data->tex); else gs_effect_set_texture(image, output_data->tex); gs_blend_state_push(); gs_blend_function(GS_BLEND_SRCALPHA, GS_BLEND_INVSRCALPHA); gs_enable_color(true, true, true, false); gs_matrix_push(); gs_matrix_translate3f(output_data->pos_x - output_data->hotspot_x, output_data->pos_y - output_data->hotspot_y, 0.0f); gs_draw_sprite(output_data->tex, 0, 0, 0); gs_matrix_pop(); gs_enable_color(true, true, true, true); gs_blend_state_pop(); gs_enable_framebuffer_srgb(previous); } obs-vkcapture-1.5.2/src/wlcursor.h000066400000000000000000000021051501231770600171240ustar00rootroot00000000000000/* OBS Linux Vulkan/OpenGL game capture Copyright (C) 2021 David Rosca This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see */ #pragma once #include #include #include "screencopy_unstable_v1.h" typedef struct { struct wl_shm *shm; struct ext_screencopy_manager_v1 *screencopy; DARRAY(struct output_data*) outputs; } wl_cursor_t; wl_cursor_t *wl_cursor_init(struct wl_display *display); void wl_cursor_destroy(wl_cursor_t *data); void wl_cursor_render(wl_cursor_t *data); obs-vkcapture-1.5.2/src/xcursor-xcb.c000066400000000000000000000066451501231770600175330ustar00rootroot00000000000000/* Copyright (C) 2014 by Leonhard Oelke This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #include #include #include #include "xcursor-xcb.h" /* * Create the cursor texture, either by updating if the new cursor has the same * size or by creating a new texture if the size is different */ static void xcb_xcursor_create(xcb_xcursor_t *data, xcb_xfixes_get_cursor_image_reply_t *xc) { uint32_t *pixels = xcb_xfixes_get_cursor_image_cursor_image(xc); if (!pixels) return; if (data->tex && data->last_height == xc->width && data->last_width == xc->height) { gs_texture_set_image(data->tex, (const uint8_t *)pixels, xc->width * sizeof(uint32_t), false); } else { if (data->tex) gs_texture_destroy(data->tex); data->tex = gs_texture_create(xc->width, xc->height, GS_BGRA, 1, (const uint8_t **)&pixels, GS_DYNAMIC); } data->last_serial = xc->cursor_serial; data->last_width = xc->width; data->last_height = xc->height; } /** * We need to check for the xfixes version in order to initialize it ? */ xcb_xcursor_t *xcb_xcursor_init(xcb_connection_t *xcb) { xcb_xcursor_t *data = bzalloc(sizeof(xcb_xcursor_t)); xcb_xfixes_query_version_cookie_t xfix_c; xfix_c = xcb_xfixes_query_version_unchecked( xcb, XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION); free(xcb_xfixes_query_version_reply(xcb, xfix_c, NULL)); return data; } void xcb_xcursor_destroy(xcb_xcursor_t *data) { if (data->tex) gs_texture_destroy(data->tex); bfree(data); } void xcb_xcursor_update(xcb_xcursor_t *data, xcb_xfixes_get_cursor_image_reply_t *xc) { if (!data || !xc) return; if (!data->tex || data->last_serial != xc->cursor_serial) xcb_xcursor_create(data, xc); data->x = xc->x - data->x_org; data->y = xc->y - data->y_org; data->x_render = data->x - xc->xhot; data->y_render = data->y - xc->yhot; } void xcb_xcursor_render(xcb_xcursor_t *data) { if (!data->tex) return; gs_effect_t *effect = gs_get_effect(); gs_eparam_t *image = gs_effect_get_param_by_name(effect, "image"); if (gs_get_linear_srgb()) gs_effect_set_texture_srgb(image, data->tex); else gs_effect_set_texture(image, data->tex); gs_blend_state_push(); gs_blend_function(GS_BLEND_SRCALPHA, GS_BLEND_INVSRCALPHA); gs_enable_color(true, true, true, false); gs_matrix_push(); gs_matrix_translate3f(data->x_render, data->y_render, 0.0f); gs_draw_sprite(data->tex, 0, 0, 0); gs_matrix_pop(); gs_enable_color(true, true, true, true); gs_blend_state_pop(); } void xcb_xcursor_offset(xcb_xcursor_t *data, const int x_org, const int y_org) { data->x_org = x_org; data->y_org = y_org; } obs-vkcapture-1.5.2/src/xcursor-xcb.h000066400000000000000000000034261501231770600175320ustar00rootroot00000000000000/* Copyright (C) 2014 by Leonhard Oelke This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . */ #pragma once #include #include #ifdef __cplusplus extern "C" { #endif typedef struct { unsigned int last_serial; unsigned int last_width; unsigned int last_height; gs_texture_t *tex; int x; int y; int x_org; int y_org; float x_render; float y_render; } xcb_xcursor_t; /** * Initializes the xcursor object * * @return NULL on error */ xcb_xcursor_t *xcb_xcursor_init(xcb_connection_t *xcb); /** * Destroys the xcursor object * @param data xcursor object */ void xcb_xcursor_destroy(xcb_xcursor_t *data); /** * Update the cursor data * @param data xcursor object * @param xc xcb cursor image reply * * @note This needs to be executed within a valid render context * */ void xcb_xcursor_update(xcb_xcursor_t *data, xcb_xfixes_get_cursor_image_reply_t *xc); /** * Draw the cursor * * This needs to be executed within a valid render context */ void xcb_xcursor_render(xcb_xcursor_t *data); /** * Specify offset for the cursor */ void xcb_xcursor_offset(xcb_xcursor_t *data, const int x_org, const int y_org); #ifdef __cplusplus } #endif