From ea7e73d6a449904feabb5fccc04a941f7e5884b6 Mon Sep 17 00:00:00 2001 From: Johanness Date: Mon, 18 May 2026 00:03:06 +0300 Subject: [PATCH] initial commit --- AppConfig.cpp | 499 ++ AppConfig.hpp | 65 + CMakeLists.txt | 113 + FeedCreate.cpp | 90 + FeedCreate.hpp | 15 + FeedTexture.cpp | 234 + FeedTexture.hpp | 54 + IVideoFeed.hpp | 56 + MxlFeed.cpp | 75 + MxlFeed.hpp | 26 + MxlInstanceCache.cpp | 92 + MxlInstanceCache.hpp | 44 + MxlSdkFeed.cpp | 631 ++ MxlSdkFeed.hpp | 75 + NoSignalFeed.cpp | 220 + NoSignalFeed.hpp | 30 + PixelFormat.hpp | 190 + RenderPipeline.cpp | 424 ++ RenderPipeline.hpp | 42 + SmpteBarsFeed.cpp | 114 + SmpteBarsFeed.hpp | 21 + Swapchain.cpp | 327 + Swapchain.hpp | 67 + TileLayout.cpp | 121 + TileLayout.hpp | 29 + V210ComputeDecoder.cpp | 451 ++ V210ComputeDecoder.hpp | 78 + VideoFrame.hpp | 11 + VulkanContext.cpp | 413 ++ VulkanContext.hpp | 75 + VulkanUtils.cpp | 326 + VulkanUtils.hpp | 73 + build-sdk/CMakeCache.txt | 426 ++ .../CMakeFiles/4.2.3/CMakeCXXCompiler.cmake | 108 + .../4.2.3/CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 16040 bytes build-sdk/CMakeFiles/4.2.3/CMakeSystem.cmake | 15 + .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 949 +++ .../CMakeFiles/4.2.3/CompilerIdCXX/a.out | Bin 0 -> 16088 bytes build-sdk/CMakeFiles/CMakeConfigureLog.yaml | 1590 +++++ .../CMakeDirectoryInformation.cmake | 16 + build-sdk/CMakeFiles/InstallScripts.json | 7 + build-sdk/CMakeFiles/Makefile.cmake | 56 + build-sdk/CMakeFiles/Makefile2 | 157 + build-sdk/CMakeFiles/TargetDirectories.txt | 4 + build-sdk/CMakeFiles/cmake.check_cache | 1 + .../mxl_multiviewer.dir/AppConfig.cpp.o | Bin 0 -> 403472 bytes .../mxl_multiviewer.dir/AppConfig.cpp.o.d | 178 + .../mxl_multiviewer.dir/DependInfo.cmake | 44 + .../mxl_multiviewer.dir/FakeFeed.cpp.o | Bin 0 -> 120032 bytes .../mxl_multiviewer.dir/FakeFeed.cpp.o.d | 73 + .../mxl_multiviewer.dir/FeedCreate.cpp.o | Bin 0 -> 339560 bytes .../mxl_multiviewer.dir/FeedCreate.cpp.o.d | 229 + .../mxl_multiviewer.dir/FeedFactory.cpp.o | Bin 0 -> 368184 bytes .../mxl_multiviewer.dir/FeedFactory.cpp.o.d | 226 + .../mxl_multiviewer.dir/FeedTexture.cpp.o | Bin 0 -> 392392 bytes .../mxl_multiviewer.dir/FeedTexture.cpp.o.d | 154 + .../mxl_multiviewer.dir/MxlFeed.cpp.o | Bin 0 -> 268184 bytes .../mxl_multiviewer.dir/MxlFeed.cpp.o.d | 133 + .../MxlInstanceCache.cpp.o | Bin 0 -> 253072 bytes .../MxlInstanceCache.cpp.o.d | 193 + .../mxl_multiviewer.dir/MxlSdkFeed.cpp.o | Bin 0 -> 472680 bytes .../mxl_multiviewer.dir/MxlSdkFeed.cpp.o.d | 248 + .../mxl_multiviewer.dir/NoSignalFeed.cpp.o | Bin 0 -> 272696 bytes .../mxl_multiviewer.dir/NoSignalFeed.cpp.o.d | 133 + .../mxl_multiviewer.dir/RenderPipeline.cpp.o | Bin 0 -> 571728 bytes .../RenderPipeline.cpp.o.d | 200 + .../mxl_multiviewer.dir/SmpteBarsFeed.cpp.o | Bin 0 -> 273680 bytes .../mxl_multiviewer.dir/SmpteBarsFeed.cpp.o.d | 133 + .../mxl_multiviewer.dir/Swapchain.cpp.o | Bin 0 -> 724120 bytes .../mxl_multiviewer.dir/Swapchain.cpp.o.d | 204 + .../mxl_multiviewer.dir/TileLayout.cpp.o | Bin 0 -> 172568 bytes .../mxl_multiviewer.dir/TileLayout.cpp.o.d | 131 + .../V210ComputeDecoder.cpp.o | Bin 0 -> 758840 bytes .../V210ComputeDecoder.cpp.o.d | 198 + .../mxl_multiviewer.dir/VulkanContext.cpp.o | Bin 0 -> 905480 bytes .../mxl_multiviewer.dir/VulkanContext.cpp.o.d | 225 + .../mxl_multiviewer.dir/VulkanUtils.cpp.o | Bin 0 -> 373016 bytes .../mxl_multiviewer.dir/VulkanUtils.cpp.o.d | 149 + .../CMakeFiles/mxl_multiviewer.dir/build.make | 435 ++ .../mxl_multiviewer.dir/cmake_clean.cmake | 52 + .../compiler_depend.internal | 4843 +++++++++++++ .../mxl_multiviewer.dir/compiler_depend.make | 6223 +++++++++++++++++ .../mxl_multiviewer.dir/compiler_depend.ts | 2 + .../mxl_multiviewer.dir/depend.make | 2 + .../CMakeFiles/mxl_multiviewer.dir/flags.make | 22 + .../imgui/backends/imgui_impl_sdl3.cpp.o | Bin 0 -> 270280 bytes .../imgui/backends/imgui_impl_sdl3.cpp.o.d | 74 + .../imgui/backends/imgui_impl_vulkan.cpp.o | Bin 0 -> 767800 bytes .../imgui/backends/imgui_impl_vulkan.cpp.o.d | 55 + .../mxl_multiviewer.dir/imgui/imgui.cpp.o | Bin 0 -> 2073984 bytes .../mxl_multiviewer.dir/imgui/imgui.cpp.o.d | 265 + .../imgui/imgui_draw.cpp.o | Bin 0 -> 1406744 bytes .../imgui/imgui_draw.cpp.o.d | 237 + .../imgui/imgui_tables.cpp.o | Bin 0 -> 937288 bytes .../imgui/imgui_tables.cpp.o.d | 235 + .../imgui/imgui_widgets.cpp.o | Bin 0 -> 1590496 bytes .../imgui/imgui_widgets.cpp.o.d | 236 + .../CMakeFiles/mxl_multiviewer.dir/link.d | 295 + .../CMakeFiles/mxl_multiviewer.dir/link.txt | 1 + .../CMakeFiles/mxl_multiviewer.dir/main.cpp.o | Bin 0 -> 2405488 bytes .../mxl_multiviewer.dir/main.cpp.o.d | 331 + .../mxl_multiviewer.dir/progress.make | 23 + build-sdk/CMakeFiles/progress.marks | 1 + .../CMakeFiles/v210_test.dir/DependInfo.cmake | 24 + build-sdk/CMakeFiles/v210_test.dir/build.make | 114 + .../v210_test.dir/cmake_clean.cmake | 12 + .../v210_test.dir/compiler_depend.internal | 179 + .../v210_test.dir/compiler_depend.make | 521 ++ .../v210_test.dir/compiler_depend.ts | 2 + .../CMakeFiles/v210_test.dir/depend.make | 2 + build-sdk/CMakeFiles/v210_test.dir/flags.make | 10 + build-sdk/CMakeFiles/v210_test.dir/link.d | 94 + build-sdk/CMakeFiles/v210_test.dir/link.txt | 1 + .../CMakeFiles/v210_test.dir/progress.make | 3 + .../CMakeFiles/v210_test.dir/v210_test.cpp.o | Bin 0 -> 178680 bytes .../v210_test.dir/v210_test.cpp.o.d | 134 + build-sdk/Makefile | 762 ++ build-sdk/cmake_install.cmake | 66 + build-sdk/imgui.ini | 8 + build-sdk/mxl_multiviewer | Bin 0 -> 6654744 bytes build-sdk/run-test.sh | 2 + build-sdk/v210_test | Bin 0 -> 117432 bytes build/.ninja_deps | Bin 0 -> 179960 bytes build/.ninja_log | 80 + build/CMakeCache.txt | 438 ++ build/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake | 108 + .../4.2.3/CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 16144 bytes build/CMakeFiles/4.2.3/CMakeSystem.cmake | 15 + .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 949 +++ build/CMakeFiles/4.2.3/CompilerIdCXX/a.out | Bin 0 -> 16200 bytes build/CMakeFiles/CMakeConfigureLog.yaml | 1742 +++++ build/CMakeFiles/InstallScripts.json | 7 + build/CMakeFiles/TargetDirectories.txt | 4 + build/CMakeFiles/cmake.check_cache | 1 + .../imgui/backends/imgui_impl_sdl3.cpp.o | Bin 0 -> 36736 bytes .../imgui/backends/imgui_impl_vulkan.cpp.o | Bin 0 -> 100552 bytes .../multiview_test.dir/imgui/imgui.cpp.o | Bin 0 -> 922304 bytes .../multiview_test.dir/imgui/imgui_draw.cpp.o | Bin 0 -> 483192 bytes .../imgui/imgui_tables.cpp.o | Bin 0 -> 236088 bytes .../imgui/imgui_widgets.cpp.o | Bin 0 -> 594336 bytes .../CMakeFiles/multiview_test.dir/main.cpp.o | Bin 0 -> 38112 bytes .../mxl_multiviewer.dir/AppConfig.cpp.o | Bin 0 -> 300872 bytes .../mxl_multiviewer.dir/FakeFeed.cpp.o | Bin 0 -> 81808 bytes .../mxl_multiviewer.dir/FeedCreate.cpp.o | Bin 0 -> 215016 bytes .../mxl_multiviewer.dir/FeedFactory.cpp.o | Bin 0 -> 236632 bytes .../mxl_multiviewer.dir/FeedTexture.cpp.o | Bin 0 -> 231160 bytes .../mxl_multiviewer.dir/MxlFeed.cpp.o | Bin 0 -> 154600 bytes .../MxlInstanceCache.cpp.o | Bin 0 -> 60768 bytes .../mxl_multiviewer.dir/MxlSdkFeed.cpp.o | Bin 0 -> 187312 bytes .../mxl_multiviewer.dir/NoSignalFeed.cpp.o | Bin 0 -> 160728 bytes .../mxl_multiviewer.dir/RenderPipeline.cpp.o | Bin 0 -> 357536 bytes .../mxl_multiviewer.dir/SmpteBarsFeed.cpp.o | Bin 0 -> 158792 bytes .../mxl_multiviewer.dir/Swapchain.cpp.o | Bin 0 -> 416504 bytes .../mxl_multiviewer.dir/TileLayout.cpp.o | Bin 0 -> 126960 bytes .../V210ComputeDecoder.cpp.o | Bin 0 -> 469952 bytes .../mxl_multiviewer.dir/VulkanContext.cpp.o | Bin 0 -> 525416 bytes .../mxl_multiviewer.dir/VulkanUtils.cpp.o | Bin 0 -> 212496 bytes .../imgui/backends/imgui_impl_sdl3.cpp.o | Bin 0 -> 117976 bytes .../imgui/backends/imgui_impl_vulkan.cpp.o | Bin 0 -> 439464 bytes .../mxl_multiviewer.dir/imgui/imgui.cpp.o | Bin 0 -> 1760192 bytes .../imgui/imgui_draw.cpp.o | Bin 0 -> 907760 bytes .../imgui/imgui_tables.cpp.o | Bin 0 -> 469480 bytes .../imgui/imgui_widgets.cpp.o | Bin 0 -> 1088840 bytes .../CMakeFiles/mxl_multiviewer.dir/main.cpp.o | Bin 0 -> 1496816 bytes build/CMakeFiles/rules.ninja | 147 + .../CMakeFiles/v210_test.dir/v210_test.cpp.o | Bin 0 -> 144496 bytes build/build.ninja | 389 ++ build/cmake_install.cmake | 66 + build/mxl_multiviewer | Bin 0 -> 4898128 bytes build/v210_test | Bin 0 -> 104456 bytes conv.md | 1933 +++++ main.cpp | 1747 +++++ shaders/bin/textured.frag.spv | Bin 0 -> 560 bytes shaders/bin/textured.vert.spv | Bin 0 -> 972 bytes shaders/bin/triangle.frag.spv | Bin 0 -> 500 bytes shaders/bin/triangle.vert.spv | Bin 0 -> 1432 bytes shaders/bin/v210_decode.comp.spv | Bin 0 -> 6872 bytes shaders/textured.frag | 11 + shaders/textured.vert | 12 + shaders/triangle.frag | 10 + shaders/triangle.vert | 26 + shaders/v210_decode.comp | 82 + v210_test.cpp | 185 + 183 files changed, 34479 insertions(+) create mode 100644 AppConfig.cpp create mode 100644 AppConfig.hpp create mode 100644 CMakeLists.txt create mode 100644 FeedCreate.cpp create mode 100644 FeedCreate.hpp create mode 100644 FeedTexture.cpp create mode 100644 FeedTexture.hpp create mode 100644 IVideoFeed.hpp create mode 100644 MxlFeed.cpp create mode 100644 MxlFeed.hpp create mode 100644 MxlInstanceCache.cpp create mode 100644 MxlInstanceCache.hpp create mode 100644 MxlSdkFeed.cpp create mode 100644 MxlSdkFeed.hpp create mode 100644 NoSignalFeed.cpp create mode 100644 NoSignalFeed.hpp create mode 100644 PixelFormat.hpp create mode 100644 RenderPipeline.cpp create mode 100644 RenderPipeline.hpp create mode 100644 SmpteBarsFeed.cpp create mode 100644 SmpteBarsFeed.hpp create mode 100644 Swapchain.cpp create mode 100644 Swapchain.hpp create mode 100644 TileLayout.cpp create mode 100644 TileLayout.hpp create mode 100644 V210ComputeDecoder.cpp create mode 100644 V210ComputeDecoder.hpp create mode 100644 VideoFrame.hpp create mode 100644 VulkanContext.cpp create mode 100644 VulkanContext.hpp create mode 100644 VulkanUtils.cpp create mode 100644 VulkanUtils.hpp create mode 100644 build-sdk/CMakeCache.txt create mode 100644 build-sdk/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake create mode 100755 build-sdk/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CXX.bin create mode 100644 build-sdk/CMakeFiles/4.2.3/CMakeSystem.cmake create mode 100644 build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100755 build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/a.out create mode 100644 build-sdk/CMakeFiles/CMakeConfigureLog.yaml create mode 100644 build-sdk/CMakeFiles/CMakeDirectoryInformation.cmake create mode 100644 build-sdk/CMakeFiles/InstallScripts.json create mode 100644 build-sdk/CMakeFiles/Makefile.cmake create mode 100644 build-sdk/CMakeFiles/Makefile2 create mode 100644 build-sdk/CMakeFiles/TargetDirectories.txt create mode 100644 build-sdk/CMakeFiles/cmake.check_cache create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/DependInfo.cmake create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FakeFeed.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FakeFeed.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedFactory.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedFactory.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/build.make create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/cmake_clean.cmake create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.internal create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.make create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/depend.make create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/flags.make create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/link.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/link.txt create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/main.cpp.o create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/main.cpp.o.d create mode 100644 build-sdk/CMakeFiles/mxl_multiviewer.dir/progress.make create mode 100644 build-sdk/CMakeFiles/progress.marks create mode 100644 build-sdk/CMakeFiles/v210_test.dir/DependInfo.cmake create mode 100644 build-sdk/CMakeFiles/v210_test.dir/build.make create mode 100644 build-sdk/CMakeFiles/v210_test.dir/cmake_clean.cmake create mode 100644 build-sdk/CMakeFiles/v210_test.dir/compiler_depend.internal create mode 100644 build-sdk/CMakeFiles/v210_test.dir/compiler_depend.make create mode 100644 build-sdk/CMakeFiles/v210_test.dir/compiler_depend.ts create mode 100644 build-sdk/CMakeFiles/v210_test.dir/depend.make create mode 100644 build-sdk/CMakeFiles/v210_test.dir/flags.make create mode 100644 build-sdk/CMakeFiles/v210_test.dir/link.d create mode 100644 build-sdk/CMakeFiles/v210_test.dir/link.txt create mode 100644 build-sdk/CMakeFiles/v210_test.dir/progress.make create mode 100644 build-sdk/CMakeFiles/v210_test.dir/v210_test.cpp.o create mode 100644 build-sdk/CMakeFiles/v210_test.dir/v210_test.cpp.o.d create mode 100644 build-sdk/Makefile create mode 100644 build-sdk/cmake_install.cmake create mode 100644 build-sdk/imgui.ini create mode 100755 build-sdk/mxl_multiviewer create mode 100755 build-sdk/run-test.sh create mode 100755 build-sdk/v210_test create mode 100644 build/.ninja_deps create mode 100644 build/.ninja_log create mode 100644 build/CMakeCache.txt create mode 100644 build/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake create mode 100755 build/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CXX.bin create mode 100644 build/CMakeFiles/4.2.3/CMakeSystem.cmake create mode 100644 build/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100755 build/CMakeFiles/4.2.3/CompilerIdCXX/a.out create mode 100644 build/CMakeFiles/CMakeConfigureLog.yaml create mode 100644 build/CMakeFiles/InstallScripts.json create mode 100644 build/CMakeFiles/TargetDirectories.txt create mode 100644 build/CMakeFiles/cmake.check_cache create mode 100644 build/CMakeFiles/multiview_test.dir/imgui/backends/imgui_impl_sdl3.cpp.o create mode 100644 build/CMakeFiles/multiview_test.dir/imgui/backends/imgui_impl_vulkan.cpp.o create mode 100644 build/CMakeFiles/multiview_test.dir/imgui/imgui.cpp.o create mode 100644 build/CMakeFiles/multiview_test.dir/imgui/imgui_draw.cpp.o create mode 100644 build/CMakeFiles/multiview_test.dir/imgui/imgui_tables.cpp.o create mode 100644 build/CMakeFiles/multiview_test.dir/imgui/imgui_widgets.cpp.o create mode 100644 build/CMakeFiles/multiview_test.dir/main.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/FakeFeed.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/FeedFactory.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o create mode 100644 build/CMakeFiles/mxl_multiviewer.dir/main.cpp.o create mode 100644 build/CMakeFiles/rules.ninja create mode 100644 build/CMakeFiles/v210_test.dir/v210_test.cpp.o create mode 100644 build/build.ninja create mode 100644 build/cmake_install.cmake create mode 100755 build/mxl_multiviewer create mode 100755 build/v210_test create mode 100644 conv.md create mode 100644 main.cpp create mode 100644 shaders/bin/textured.frag.spv create mode 100644 shaders/bin/textured.vert.spv create mode 100644 shaders/bin/triangle.frag.spv create mode 100644 shaders/bin/triangle.vert.spv create mode 100644 shaders/bin/v210_decode.comp.spv create mode 100644 shaders/textured.frag create mode 100644 shaders/textured.vert create mode 100644 shaders/triangle.frag create mode 100644 shaders/triangle.vert create mode 100644 shaders/v210_decode.comp create mode 100644 v210_test.cpp diff --git a/AppConfig.cpp b/AppConfig.cpp new file mode 100644 index 0000000..46b0ada --- /dev/null +++ b/AppConfig.cpp @@ -0,0 +1,499 @@ +#include "AppConfig.hpp" + +#include +#include +#include +#include +#include +#include + +namespace +{ +bool parseUint32( + const char* text, + uint32_t& value) +{ + uint32_t parsed = 0; + bool hasDigit = false; + + for (int i = 0; text[i] != '\0'; ++i) + { + if (text[i] < '0' || text[i] > '9') + { + return false; + } + + hasDigit = true; + parsed = parsed * 10u + + static_cast(text[i] - '0'); + } + + if (!hasDigit) + { + return false; + } + + value = parsed; + return true; +} + +bool parseFeedIndex( + const char* text, + uint32_t maxFeeds, + uint32_t& index) +{ + uint32_t parsed = 0; + + if (!parseUint32(text, parsed) || + parsed >= maxFeeds) + { + return false; + } + + index = parsed; + return true; +} + +bool parseGrid( + std::string_view text, + uint32_t& cols, + uint32_t& rows) +{ + const size_t xPos = text.find('x'); + if (xPos == std::string_view::npos) + { + return false; + } + + const std::string colText(text.substr(0, xPos)); + const std::string rowText(text.substr(xPos + 1)); + + uint32_t parsedCols = 0; + uint32_t parsedRows = 0; + + if (!parseUint32(colText.c_str(), parsedCols) || + !parseUint32(rowText.c_str(), parsedRows) || + parsedCols == 0 || + parsedRows == 0 || + parsedCols > MaxFeedCount / parsedRows) + { + return false; + } + + cols = parsedCols; + rows = parsedRows; + return true; +} + +uint32_t feedCount(const AppConfig& config) +{ + return config.gridCols * config.gridRows; +} + +void applyDefaultFeeds(AppConfig& config) +{ + config.feeds.assign(feedCount(config), FeedConfig{}); +} +} + +std::optional parseFeedKind(std::string_view text) +{ + if (text == "nosignal" || + text == "none" || + text == "fake") + { + return FeedKind::NoSignal; + } + + if (text == "mxl") + { + return FeedKind::MxlPlaceholder; + } + + if (text == "smpte") + { + return FeedKind::SmpteBars; + } + + if (text == "mxlsdk") + { + return FeedKind::MxlSdk; + } + + return std::nullopt; +} + +std::optional parsePresentMode(std::string_view text) +{ + if (text == "fifo") + { + return PresentModeConfig::Fifo; + } + + if (text == "mailbox") + { + return PresentModeConfig::Mailbox; + } + + if (text == "immediate") + { + return PresentModeConfig::Immediate; + } + + return std::nullopt; +} + +std::string_view feedKindName(FeedKind kind) +{ + switch (kind) + { + case FeedKind::MxlPlaceholder: + return "mxl"; + + case FeedKind::SmpteBars: + return "smpte"; + + case FeedKind::MxlSdk: + return "mxlsdk"; + + case FeedKind::NoSignal: + default: + return "nosignal"; + } +} + +void printUsage(const char* executableName) +{ + std::cout + << "Usage: " + << executableName + << " [options] [feed...]\n" + << "Options:\n" + << " --no-fps Disable FPS logging\n" + << " --perf Log per-frame CPU timing breakdown\n" + << " --verbose Enable detailed startup and SDK logs\n" + << " --grid x Set multiview grid (default 2x2, max 16 feeds)\n" + << " --fps-cap Limit render loop FPS (default 60)\n" + << " --present Present mode: fifo, mailbox, immediate (default mailbox)\n" + << " --feed Set feed slot kind explicitly\n" + << " --domain Set MXL domain for feed slot\n" + << " --flow Set MXL flow UUID for feed slot\n" + << " --version Print version\n" + << " --help Print this help\n" + << "Feed kinds: nosignal, none, fake, mxl, smpte, mxlsdk\n" + << "Default: 2x2 grid, all slots nosignal" + << std::endl; +} + +ConfigParseResult parseAppConfig( + int argc, + char* argv[]) +{ + ConfigParseResult result; + + for (int i = 1; i < argc; ++i) + { + if (std::string_view(argv[i]) != "--grid") + { + continue; + } + + if (i + 1 >= argc || + !parseGrid( + argv[i + 1], + result.config.gridCols, + result.config.gridRows)) + { + std::cerr << "--grid must be x with 1-" + << MaxFeedCount << " total feeds" + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + ++i; + } + + applyDefaultFeeds(result.config); + + for (int i = 1; i < argc; ++i) + { + const std::string_view arg(argv[i]); + + if (arg == "--help" || arg == "-h") + { + printUsage(argv[0]); + result.shouldExit = true; + result.exitCode = 0; + return result; + } + } + + for (int i = 1; i < argc; ++i) + { + const std::string_view arg(argv[i]); + + if (arg == "--version" || arg == "-v") + { + std::cout + << AppName + << " " + << AppVersionMajor + << "." + << AppVersionMinor + << "." + << AppVersionPatch + << std::endl; + + result.shouldExit = true; + result.exitCode = 0; + return result; + } + } + + std::vector feedArgs; + + for (int i = 1; i < argc; ++i) + { + const std::string_view arg(argv[i]); + + if (arg == "--no-fps") + { + result.config.logFps = false; + continue; + } + + if (arg == "--perf") + { + result.config.logPerf = true; + continue; + } + + if (arg == "--verbose") + { + result.config.verbose = true; + continue; + } + + if (arg == "--grid") + { + ++i; + continue; + } + + if (arg == "--fps-cap") + { + if (i + 1 >= argc) + { + std::cerr << "--fps-cap requires " + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + uint32_t fpsCap = 0; + + if (!parseUint32(argv[i + 1], fpsCap) || + fpsCap == 0 || fpsCap > 240) + { + std::cerr << "--fps-cap must be 1-240" + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + result.config.fpsCap = fpsCap; + ++i; + continue; + } + + if (arg == "--present") + { + if (i + 1 >= argc) + { + std::cerr << "--present requires " + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + const std::optional mode = + parsePresentMode(argv[i + 1]); + + if (!mode.has_value()) + { + std::cerr + << "--present must be fifo, mailbox, or immediate" + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + result.config.presentMode = mode.value(); + ++i; + continue; + } + + if (arg == "--feed") + { + if (i + 2 >= argc) + { + std::cerr << "--feed requires " + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + uint32_t index = 0; + if (!parseFeedIndex( + argv[i + 1], + feedCount(result.config), + index)) + { + std::cerr << "--feed index must be 0-" + << (feedCount(result.config) - 1) << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + const std::optional kind = + parseFeedKind(argv[i + 2]); + + if (!kind.has_value()) + { + std::cerr << "Unknown feed kind: " + << argv[i + 2] << std::endl; + printUsage(argv[0]); + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + result.config.feeds[index].kind = kind.value(); + i += 2; + continue; + } + + if (arg == "--domain") + { + if (i + 2 >= argc) + { + std::cerr << "--domain requires " + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + uint32_t index = 0; + if (!parseFeedIndex( + argv[i + 1], + feedCount(result.config), + index)) + { + std::cerr << "--domain index must be 0-" + << (feedCount(result.config) - 1) << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + result.config.feeds[index].mxlDomain = + std::string(argv[i + 2]); + + i += 2; + continue; + } + + if (arg == "--flow") + { + if (i + 2 >= argc) + { + std::cerr << "--flow requires " + << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + uint32_t index = 0; + if (!parseFeedIndex( + argv[i + 1], + feedCount(result.config), + index)) + { + std::cerr << "--flow index must be 0-" + << (feedCount(result.config) - 1) << std::endl; + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + result.config.feeds[index].mxlFlowId = + std::string(argv[i + 2]); + result.config.feeds[index].kind = + FeedKind::MxlSdk; + + i += 2; + continue; + } + + feedArgs.push_back(arg); + } + + if (feedArgs.size() > result.config.feeds.size()) + { + std::cerr << "Too many feed arguments" << std::endl; + printUsage(argv[0]); + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + size_t feedArgIndex = 0; + + for (uint32_t slot = 0; + slot < result.config.feeds.size() && feedArgIndex < feedArgs.size(); + ++slot) + { + if (result.config.feeds[slot].kind == FeedKind::MxlSdk) + { + continue; + } + + const std::optional parsed = + parseFeedKind(feedArgs[feedArgIndex]); + + if (!parsed.has_value()) + { + std::cerr << "Unknown feed kind: " + << feedArgs[feedArgIndex] << std::endl; + printUsage(argv[0]); + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + result.config.feeds[slot].kind = parsed.value(); + ++feedArgIndex; + } + + if (feedArgIndex < feedArgs.size()) + { + std::cerr << "Too many feed arguments for available slots" + << std::endl; + printUsage(argv[0]); + result.shouldExit = true; + result.exitCode = 1; + return result; + } + + return result; +} diff --git a/AppConfig.hpp b/AppConfig.hpp new file mode 100644 index 0000000..2ad0baa --- /dev/null +++ b/AppConfig.hpp @@ -0,0 +1,65 @@ +#pragma once + +#include +#include +#include +#include +#include + +constexpr uint32_t DefaultGridCols = 2; +constexpr uint32_t DefaultGridRows = 2; +constexpr uint32_t MaxFeedCount = 16; +constexpr const char* AppName = "MXL Multiviewer"; +constexpr uint32_t AppVersionMajor = 0; +constexpr uint32_t AppVersionMinor = 1; +constexpr uint32_t AppVersionPatch = 0; + +enum class FeedKind +{ + NoSignal, + MxlPlaceholder, + SmpteBars, + MxlSdk +}; + +enum class PresentModeConfig +{ + Fifo, + Mailbox, + Immediate +}; + +struct FeedConfig +{ + FeedKind kind = FeedKind::NoSignal; + std::string mxlDomain; + std::string mxlFlowId; +}; + +struct AppConfig +{ + bool logFps = true; + bool logPerf = false; + bool verbose = false; + uint32_t fpsCap = 60; + uint32_t gridCols = DefaultGridCols; + uint32_t gridRows = DefaultGridRows; + PresentModeConfig presentMode = PresentModeConfig::Mailbox; + std::vector feeds; +}; + +std::optional parseFeedKind(std::string_view text); +std::string_view feedKindName(FeedKind kind); + +void printUsage(const char* executableName); + +struct ConfigParseResult +{ + AppConfig config; + bool shouldExit = false; + int exitCode = 0; +}; + +ConfigParseResult parseAppConfig( + int argc, + char* argv[]); diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..9cb2f3d --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,113 @@ +cmake_minimum_required(VERSION 3.20) + +project(mxl_multiviewer LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 20) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +option( + MXL_MULTIVIEWER_ENABLE_MXL_SDK + "Enable real MXL SDK integration" + OFF +) + +find_package(PkgConfig REQUIRED) +find_package(Vulkan REQUIRED) + +pkg_check_modules(SDL3 REQUIRED sdl3) + +add_executable(mxl_multiviewer + main.cpp + imgui/imgui.cpp + imgui/imgui_draw.cpp + imgui/imgui_tables.cpp + imgui/imgui_widgets.cpp + imgui/backends/imgui_impl_sdl3.cpp + imgui/backends/imgui_impl_vulkan.cpp + AppConfig.cpp + FeedCreate.cpp + FeedTexture.cpp + NoSignalFeed.cpp + MxlFeed.cpp + MxlInstanceCache.cpp + MxlSdkFeed.cpp + SmpteBarsFeed.cpp + TileLayout.cpp + VulkanContext.cpp + VulkanUtils.cpp + Swapchain.cpp + RenderPipeline.cpp + V210ComputeDecoder.cpp +) + +target_include_directories(mxl_multiviewer PRIVATE + ${SDL3_INCLUDE_DIRS} + ${CMAKE_SOURCE_DIR}/imgui + ${CMAKE_SOURCE_DIR}/imgui/backends +) + +set_source_files_properties( + imgui/imgui.cpp + imgui/imgui_draw.cpp + imgui/imgui_tables.cpp + imgui/imgui_widgets.cpp + imgui/backends/imgui_impl_sdl3.cpp + imgui/backends/imgui_impl_vulkan.cpp + PROPERTIES COMPILE_OPTIONS "-w" +) + +target_link_libraries(mxl_multiviewer PRIVATE + ${SDL3_LIBRARIES} +) + +target_compile_options(mxl_multiviewer PRIVATE + -Wall + -Wextra + -Wpedantic +) + +target_compile_definitions(mxl_multiviewer PRIVATE + MXL_MULTIVIEWER_ENABLE_MXL_SDK=$ +) + +if(MXL_MULTIVIEWER_ENABLE_MXL_SDK) + set(MXL_SDK_ROOT "" CACHE PATH "Path to MXL SDK root directory") + + if(NOT MXL_SDK_ROOT) + message(FATAL_ERROR "MXL_SDK_ROOT must be set when MXL_MULTIVIEWER_ENABLE_MXL_SDK is ON") + endif() + + target_include_directories(mxl_multiviewer PRIVATE + ${MXL_SDK_ROOT}/lib/include + ${MXL_SDK_ROOT}/build/Linux-Clang-Release/lib/include + ) + + target_link_directories(mxl_multiviewer PRIVATE + ${MXL_SDK_ROOT}/build/Linux-Clang-Release/lib + ${MXL_SDK_ROOT}/build/Linux-Clang-Release/lib/internal + ) + + target_link_libraries(mxl_multiviewer PRIVATE + mxl + mxl-common + ) +endif() + +target_link_libraries(mxl_multiviewer PRIVATE + ${SDL3_LIBRARIES} + Vulkan::Vulkan +) + +# v210 conversion test +add_executable(v210_test v210_test.cpp) +target_include_directories(v210_test PRIVATE ${CMAKE_SOURCE_DIR}) + +# Compile compute shader +add_custom_command( + OUTPUT ${CMAKE_SOURCE_DIR}/shaders/bin/v210_decode.comp.spv + COMMAND glslangValidator -V + ${CMAKE_SOURCE_DIR}/shaders/v210_decode.comp + -o ${CMAKE_SOURCE_DIR}/shaders/bin/v210_decode.comp.spv + DEPENDS ${CMAKE_SOURCE_DIR}/shaders/v210_decode.comp + COMMENT "Compiling v210_decode.comp to SPIR-V" +) diff --git a/FeedCreate.cpp b/FeedCreate.cpp new file mode 100644 index 0000000..5adb7c7 --- /dev/null +++ b/FeedCreate.cpp @@ -0,0 +1,90 @@ +#include "FeedCreate.hpp" + +#include "NoSignalFeed.hpp" +#include "MxlFeed.hpp" +#include "MxlSdkFeed.hpp" +#include "SmpteBarsFeed.hpp" + +#include + +std::unique_ptr createFeed( + const FeedConfig& config, + uint32_t feedIndex, + uint32_t frameWidth, + uint32_t frameHeight, + bool verbose) +{ + switch (config.kind) + { + case FeedKind::MxlSdk: + { + if (config.mxlDomain.empty() || config.mxlFlowId.empty()) + { + std::cerr << "Feed " << (feedIndex + 1) + << ": mxlsdk requires domain and flowId" + << std::endl; + return std::make_unique( + feedIndex, frameWidth, frameHeight); + } + + if (verbose) + { + std::cerr << "Feed " << (feedIndex + 1) + << ": mxlsdk domain=" << config.mxlDomain + << " flowId=" << config.mxlFlowId + << std::endl; + } + + return std::make_unique( + config.mxlDomain, + config.mxlFlowId, + frameWidth, + frameHeight, + verbose); + } + + case FeedKind::MxlPlaceholder: + { + auto feed = std::make_unique( + frameWidth, + frameHeight + ); + + if (verbose) + { + std::cerr + << "MXL SDK: " + << (feed->isUsingRealSdk() + ? "enabled" + : "disabled, using placeholder") + << std::endl; + } + + return feed; + } + + case FeedKind::SmpteBars: + if (verbose) + { + std::cerr << "Feed " << (feedIndex + 1) + << ": smpte bars" << std::endl; + } + return std::make_unique( + frameWidth, + frameHeight + ); + + case FeedKind::NoSignal: + default: + if (verbose) + { + std::cerr << "Feed " << (feedIndex + 1) + << ": no signal" << std::endl; + } + return std::make_unique( + feedIndex, + frameWidth, + frameHeight + ); + } +} diff --git a/FeedCreate.hpp b/FeedCreate.hpp new file mode 100644 index 0000000..9c43816 --- /dev/null +++ b/FeedCreate.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include "AppConfig.hpp" + +#include "IVideoFeed.hpp" + +#include +#include + +std::unique_ptr createFeed( + const FeedConfig& config, + uint32_t feedIndex, + uint32_t frameWidth, + uint32_t frameHeight, + bool verbose); diff --git a/FeedTexture.cpp b/FeedTexture.cpp new file mode 100644 index 0000000..24092d5 --- /dev/null +++ b/FeedTexture.cpp @@ -0,0 +1,234 @@ +#include "FeedTexture.hpp" + +#include "VulkanUtils.hpp" + +#include +#include + +void createFeedTexture( + VkDevice device, + VkPhysicalDevice physicalDevice, + VkCommandPool commandPool, + VkQueue graphicsQueue, + const VideoFrame& initialFrame, + VkDeviceSize imageSize, + FeedTexture& texture) +{ + createBuffer( + device, + physicalDevice, + imageSize, + VK_BUFFER_USAGE_TRANSFER_SRC_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + texture.stagingBuffer, + texture.stagingBufferMemory + ); + + if (vkMapMemory( + device, + texture.stagingBufferMemory, + 0, + imageSize, + 0, + &texture.mappedData) != VK_SUCCESS) + { + throw std::runtime_error("Failed to map staging buffer memory"); + } + + std::memcpy( + texture.mappedData, + initialFrame.pixels.data(), + static_cast(imageSize) + ); + + createImage( + device, + physicalDevice, + initialFrame.width, + initialFrame.height, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_TRANSFER_DST_BIT | + VK_IMAGE_USAGE_SAMPLED_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + texture.image, + texture.imageMemory + ); + + transitionImageLayout( + device, + commandPool, + graphicsQueue, + texture.image, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL + ); + + copyBufferToImage( + device, + commandPool, + graphicsQueue, + texture.stagingBuffer, + texture.image, + initialFrame.width, + initialFrame.height + ); + + transitionImageLayout( + device, + commandPool, + graphicsQueue, + texture.image, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL + ); + + VkImageViewCreateInfo textureViewInfo{}; + textureViewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + textureViewInfo.image = texture.image; + textureViewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + textureViewInfo.format = VK_FORMAT_R8G8B8A8_UNORM; + textureViewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + textureViewInfo.subresourceRange.baseMipLevel = 0; + textureViewInfo.subresourceRange.levelCount = 1; + textureViewInfo.subresourceRange.baseArrayLayer = 0; + textureViewInfo.subresourceRange.layerCount = 1; + + if (vkCreateImageView( + device, + &textureViewInfo, + nullptr, + &texture.imageView) != VK_SUCCESS) + { + throw std::runtime_error("Failed to create texture image view"); + } + + VkSamplerCreateInfo samplerInfo{}; + samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + samplerInfo.magFilter = VK_FILTER_LINEAR; + samplerInfo.minFilter = VK_FILTER_LINEAR; + samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.anisotropyEnable = VK_FALSE; + samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK; + samplerInfo.unnormalizedCoordinates = VK_FALSE; + samplerInfo.compareEnable = VK_FALSE; + samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR; + + if (vkCreateSampler( + device, + &samplerInfo, + nullptr, + &texture.sampler) != VK_SUCCESS) + { + throw std::runtime_error("Failed to create texture sampler"); + } +} + +void updateFeedDescriptorSet( + VkDevice device, + const FeedTexture& texture) +{ + updateSampledImageDescriptorSet( + device, + texture.descriptorSet, + texture.imageView, + texture.sampler, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL + ); +} + +void updateSampledImageDescriptorSet( + VkDevice device, + VkDescriptorSet descriptorSet, + VkImageView imageView, + VkSampler sampler, + VkImageLayout imageLayout) +{ + VkDescriptorImageInfo imageInfo{}; + imageInfo.imageLayout = imageLayout; + imageInfo.imageView = imageView; + imageInfo.sampler = sampler; + + VkWriteDescriptorSet descriptorWrite{}; + descriptorWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + descriptorWrite.dstSet = descriptorSet; + descriptorWrite.dstBinding = 0; + descriptorWrite.dstArrayElement = 0; + descriptorWrite.descriptorType = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + descriptorWrite.descriptorCount = 1; + descriptorWrite.pImageInfo = &imageInfo; + + vkUpdateDescriptorSets( + device, + 1, + &descriptorWrite, + 0, + nullptr + ); +} + +void copyFrameToFeedTextureStaging( + const VideoFrame& frame, + VkDeviceSize imageSize, + FeedTexture& texture) +{ + std::memcpy( + texture.mappedData, + frame.pixels.data(), + static_cast(imageSize) + ); +} + +void recordFeedTextureUpload( + VkCommandBuffer commandBuffer, + const FeedTexture& texture, + uint32_t width, + uint32_t height) +{ + recordImageLayoutTransition( + commandBuffer, + texture.image, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL + ); + + recordCopyBufferToImage( + commandBuffer, + texture.stagingBuffer, + texture.image, + width, + height + ); + + recordImageLayoutTransition( + commandBuffer, + texture.image, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL + ); +} + +void destroyFeedTexture( + VkDevice device, + FeedTexture& texture) +{ + vkDestroySampler(device, texture.sampler, nullptr); + + vkDestroyImageView(device, texture.imageView, nullptr); + + vkDestroyImage(device, texture.image, nullptr); + vkFreeMemory(device, texture.imageMemory, nullptr); + + vkUnmapMemory(device, texture.stagingBufferMemory); + + vkDestroyBuffer(device, texture.stagingBuffer, nullptr); + vkFreeMemory(device, texture.stagingBufferMemory, nullptr); +} diff --git a/FeedTexture.hpp b/FeedTexture.hpp new file mode 100644 index 0000000..26364c1 --- /dev/null +++ b/FeedTexture.hpp @@ -0,0 +1,54 @@ +#pragma once + +#include "VideoFrame.hpp" + +#include + +struct FeedTexture +{ + VkBuffer stagingBuffer = VK_NULL_HANDLE; + VkDeviceMemory stagingBufferMemory = VK_NULL_HANDLE; + void* mappedData = nullptr; + + VkImage image = VK_NULL_HANDLE; + VkDeviceMemory imageMemory = VK_NULL_HANDLE; + VkImageView imageView = VK_NULL_HANDLE; + VkSampler sampler = VK_NULL_HANDLE; + + VkDescriptorSet descriptorSet = VK_NULL_HANDLE; +}; + +void createFeedTexture( + VkDevice device, + VkPhysicalDevice physicalDevice, + VkCommandPool commandPool, + VkQueue graphicsQueue, + const VideoFrame& initialFrame, + VkDeviceSize imageSize, + FeedTexture& texture); + +void updateFeedDescriptorSet( + VkDevice device, + const FeedTexture& texture); + +void updateSampledImageDescriptorSet( + VkDevice device, + VkDescriptorSet descriptorSet, + VkImageView imageView, + VkSampler sampler, + VkImageLayout imageLayout); + +void copyFrameToFeedTextureStaging( + const VideoFrame& frame, + VkDeviceSize imageSize, + FeedTexture& texture); + +void recordFeedTextureUpload( + VkCommandBuffer commandBuffer, + const FeedTexture& texture, + uint32_t width, + uint32_t height); + +void destroyFeedTexture( + VkDevice device, + FeedTexture& texture); diff --git a/IVideoFeed.hpp b/IVideoFeed.hpp new file mode 100644 index 0000000..60c5236 --- /dev/null +++ b/IVideoFeed.hpp @@ -0,0 +1,56 @@ +#pragma once + +#include "VideoFrame.hpp" + +#include +#include + +enum class FeedRuntimeStatus +{ + NoSignal, + Placeholder, + Bars, + Connecting, + Live, + Reconnecting, + Error +}; + +class IVideoFeed +{ +public: + virtual ~IVideoFeed() = default; + + virtual const VideoFrame& getFrame(uint32_t frameCounter) = 0; + + virtual FeedRuntimeStatus status() const + { + return FeedRuntimeStatus::NoSignal; + } + + virtual std::string displayName() const + { + return "NO SIGNAL"; + } + + virtual std::string sourceInfo() const + { + return ""; + } + + virtual uint64_t frameVersion() const { return 0; } + virtual bool hasGrainIndex() const { return false; } + virtual uint64_t grainIndex() const { return 0; } + + virtual float srcAspectRatio() const + { + return 16.0f / 9.0f; + } + + virtual bool hasV210() const { return false; } + + virtual const uint8_t* v210Data() const { return nullptr; } + virtual uint32_t v210Width() const { return 0; } + virtual uint32_t v210Height() const { return 0; } + virtual uint32_t v210Stride() const { return 0; } +}; diff --git a/MxlFeed.cpp b/MxlFeed.cpp new file mode 100644 index 0000000..2b77496 --- /dev/null +++ b/MxlFeed.cpp @@ -0,0 +1,75 @@ +#include "MxlFeed.hpp" +#include "PixelFormat.hpp" + +namespace +{ +constexpr uint32_t MxlPlaceholderUpdateIntervalFrames = 6; +} + +MxlFeed::MxlFeed( + uint32_t frameWidth, + uint32_t frameHeight) +{ + frame.width = frameWidth; + frame.height = frameHeight; + frame.pixels.resize(frame.width * frame.height); +} + +bool MxlFeed::isUsingRealSdk() const +{ + return MXL_MULTIVIEWER_ENABLE_MXL_SDK != 0; +} + +const VideoFrame& MxlFeed::getFrame(uint32_t frameCounter) +{ + if (lastGeneratedFrame != UINT32_MAX && + frameCounter - lastGeneratedFrame < + MxlPlaceholderUpdateIntervalFrames) + { + return frame; + } + + ++animationFrame; + lastGeneratedFrame = frameCounter; + ++version; + + for (uint32_t y = 0; y < frame.height; ++y) + { + for (uint32_t x = 0; x < frame.width; ++x) + { + const bool stripe = + ((x + animationFrame) / 16) % 2 == 0; + + const bool border = + x < 4 || + y < 4 || + x >= frame.width - 4 || + y >= frame.height - 4; + + const uint8_t r = border ? 255 : stripe ? 40 : 10; + const uint8_t g = border ? 80 : stripe ? 40 : 10; + const uint8_t b = border ? 255 : stripe ? 60 : 20; + const RgbColor color = + { + r, + g, + b + }; + + frame.pixels[y * frame.width + x] = + packRgba8(color); + } + } + + return frame; +} + +FeedRuntimeStatus MxlFeed::status() const +{ + return FeedRuntimeStatus::Placeholder; +} + +std::string MxlFeed::displayName() const +{ + return "MXL PLACEHOLDER"; +} diff --git a/MxlFeed.hpp b/MxlFeed.hpp new file mode 100644 index 0000000..5d65fa1 --- /dev/null +++ b/MxlFeed.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include "IVideoFeed.hpp" + +#include + +class MxlFeed : public IVideoFeed +{ +public: + MxlFeed( + uint32_t frameWidth, + uint32_t frameHeight); + + bool isUsingRealSdk() const; + + const VideoFrame& getFrame(uint32_t frameCounter) override; + FeedRuntimeStatus status() const override; + std::string displayName() const override; + uint64_t frameVersion() const override { return version; } + +private: + uint32_t lastGeneratedFrame = UINT32_MAX; + uint32_t animationFrame = 0; + uint64_t version = 0; + VideoFrame frame; +}; diff --git a/MxlInstanceCache.cpp b/MxlInstanceCache.cpp new file mode 100644 index 0000000..d8bd03d --- /dev/null +++ b/MxlInstanceCache.cpp @@ -0,0 +1,92 @@ +#include "MxlInstanceCache.hpp" + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + +#include + +#include +#include + +MxlInstanceCache& MxlInstanceCache::instance() +{ + static MxlInstanceCache cache; + return cache; +} + +MxlInstanceHandle* MxlInstanceCache::acquire( + const std::string& domain, + bool verbose) +{ + for (auto& handle : m_handles) + { + if (handle.domain == domain) + { + ++handle.refCount; + return &handle; + } + } + + mxlInstance inst = mxlCreateInstance(domain.c_str(), nullptr); + if (!inst) + { + return nullptr; + } + + if (verbose) + { + std::cerr << "MxlInstanceCache: created instance for domain: " + << domain << std::endl; + } + + MxlInstanceHandle handle; + handle.instance = inst; + handle.domain = domain; + handle.refCount = 1; + + m_handles.push_back(handle); + + return &m_handles.back(); +} + +void MxlInstanceCache::release(MxlInstanceHandle* handle) +{ + if (!handle) + { + return; + } + + --handle->refCount; + + if (handle->refCount <= 0) + { + mxlDestroyInstance(handle->instance); + handle->instance = nullptr; + + m_handles.erase( + std::remove_if( + m_handles.begin(), + m_handles.end(), + [](const MxlInstanceHandle& h) + { return h.instance == nullptr; }), + m_handles.end()); + } +} + +#else + +MxlInstanceCache& MxlInstanceCache::instance() +{ + static MxlInstanceCache cache; + return cache; +} + +MxlInstanceHandle* MxlInstanceCache::acquire(const std::string&, bool) +{ + return nullptr; +} + +void MxlInstanceCache::release(MxlInstanceHandle*) +{ +} + +#endif diff --git a/MxlInstanceCache.hpp b/MxlInstanceCache.hpp new file mode 100644 index 0000000..75b140e --- /dev/null +++ b/MxlInstanceCache.hpp @@ -0,0 +1,44 @@ +#pragma once + +#include +#include +#include + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + +#include +#include +#include +#include + +#endif + +struct MxlInstanceHandle +{ +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + mxlInstance instance = nullptr; +#endif + std::string domain; + int refCount = 0; +}; + +class MxlInstanceCache +{ +public: + static MxlInstanceCache& instance(); + + MxlInstanceHandle* acquire( + const std::string& domain, + bool verbose = false); + void release(MxlInstanceHandle* handle); + + MxlInstanceCache(const MxlInstanceCache&) = delete; + MxlInstanceCache& operator=(const MxlInstanceCache&) = delete; + +private: + MxlInstanceCache() = default; + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + std::vector m_handles; +#endif +}; diff --git a/MxlSdkFeed.cpp b/MxlSdkFeed.cpp new file mode 100644 index 0000000..5bef6eb --- /dev/null +++ b/MxlSdkFeed.cpp @@ -0,0 +1,631 @@ +#include "MxlSdkFeed.hpp" +#include "MxlInstanceCache.hpp" +#include "PixelFormat.hpp" + +#include +#include +#include +#include +#include +#include + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + +#include + +#include +#include +#include + +namespace +{ + std::string unescapeJsonString( + const char* begin, + const char* end) + { + std::string value; + value.reserve(static_cast(end - begin)); + + for (const char* p = begin; p < end; ++p) + { + if (*p != '\\' || p + 1 >= end) + { + value.push_back(*p); + continue; + } + + ++p; + + switch (*p) + { + case '"': value.push_back('"'); break; + case '\\': value.push_back('\\'); break; + case '/': value.push_back('/'); break; + case 'b': value.push_back('\b'); break; + case 'f': value.push_back('\f'); break; + case 'n': value.push_back('\n'); break; + case 'r': value.push_back('\r'); break; + case 't': value.push_back('\t'); break; + default: + value.push_back(*p); + break; + } + } + + return value; + } + + std::string parseStringFromJson( + const char* json, + const char* key) + { + std::string searchKey = std::string("\"") + key + "\""; + const char* pos = std::strstr(json, searchKey.c_str()); + if (!pos) + { + return ""; + } + + pos += searchKey.size(); + + while (*pos == ' ' || *pos == '\t' || *pos == '\n' || + *pos == '\r' || *pos == ':') + { + pos++; + } + + if (*pos != '"') + { + return ""; + } + + ++pos; + const char* valueBegin = pos; + bool escaped = false; + + while (*pos != '\0') + { + if (!escaped && *pos == '"') + { + return unescapeJsonString(valueBegin, pos); + } + + escaped = !escaped && *pos == '\\'; + if (*pos != '\\') + { + escaped = false; + } + + ++pos; + } + + return ""; + } + + std::string firstNonEmptyFlowLabel(const char* json) + { + const char* keys[] = + { + "name", + "flow_name", + "description", + "label" + }; + + for (const char* key : keys) + { + std::string value = parseStringFromJson(json, key); + if (!value.empty()) + { + return value; + } + } + + return ""; + } + + uint32_t parseUintFromJson(const char* json, const char* key) + { + std::string searchKey = std::string("\"") + key + "\""; + const char* pos = std::strstr(json, searchKey.c_str()); + if (!pos) + { + return 0; + } + + pos += searchKey.size(); + + while (*pos == ' ' || *pos == '\t' || *pos == '\n' || + *pos == '\r' || *pos == ':') + { + pos++; + } + + return static_cast(std::strtoul(pos, nullptr, 10)); + } + + uint32_t deriveV210Width(uint32_t stride) + { + if (stride == 0 || stride % 16 != 0) + { + return 0; + } + + return (stride / 16) * 6; + } +} + +#endif + +MxlSdkFeed::MxlSdkFeed( + const std::string& domain, + const std::string& flowId, + uint32_t outputWidth, + uint32_t outputHeight, + bool verbose) + : mDomain(domain) + , mFlowId(flowId) +{ + (void)verbose; + + mFrame.width = outputWidth; + mFrame.height = outputHeight; + mFrame.pixels.resize( + static_cast(outputWidth) * outputHeight, 0); + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + mVerbose = verbose; + mGrainRate.numerator = 30000; + mGrainRate.denominator = 1001; + + auto& cache = MxlInstanceCache::instance(); + mInstanceHandle = cache.acquire(mDomain, mVerbose); + + if (!mInstanceHandle) + { + std::cerr << "MxlSdkFeed: failed to create MXL instance" + << " for domain: " << mDomain << std::endl; + } +#endif +} + +MxlSdkFeed::~MxlSdkFeed() +{ +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + closeFlow(); + + if (mInstanceHandle) + { + auto& cache = MxlInstanceCache::instance(); + cache.release(mInstanceHandle); + mInstanceHandle = nullptr; + } +#endif +} + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + +bool MxlSdkFeed::openFlow() +{ + if (mFlowOpened) + { + return true; + } + + if (mOpenRetryCount >= 300) + { + mFlowInvalid = true; + return false; + } + + if (!mInstanceHandle || !mInstanceHandle->instance) + { + mFlowInvalid = true; + return false; + } + + if (mOpenRetryCount > 0) + { + int delayMs = 100; + if (mOpenRetryCount > 5) + { + delayMs = 500; + } + + if (mOpenRetryCount > 20) + { + delayMs = 2000; + } + + std::this_thread::sleep_for( + std::chrono::milliseconds(delayMs)); + } + + ++mOpenRetryCount; + + mxlInstance instance = mInstanceHandle->instance; + + mxlStatus status = mxlCreateFlowReader( + instance, + mFlowId.c_str(), + nullptr, + &mReader); + + if (status == MXL_ERR_FLOW_NOT_FOUND || + status == MXL_ERR_CONFLICT) + { + mFlowInvalid = true; + return false; + } + + if (status != MXL_STATUS_OK) + { + std::cerr << "MxlSdkFeed: failed to open flow " << mFlowId + << " (status=" << status << ")" << std::endl; + mFlowInvalid = true; + return false; + } + + mxlFlowConfigInfo configInfo{}; + std::memset(&configInfo, 0, sizeof(configInfo)); + + status = mxlFlowReaderGetConfigInfo(mReader, &configInfo); + if (status != MXL_STATUS_OK) + { + std::cerr << "MxlSdkFeed: failed to get config info" + << " (status=" << status << ")" << std::endl; + mxlReleaseFlowReader(instance, mReader); + mReader = nullptr; + return false; + } + + mSourceStride = configInfo.discrete.sliceSizes[0]; + mGrainRate = configInfo.common.grainRate; + + if (mVerbose) + { + std::cerr << "MxlSdkFeed: stride=" << mSourceStride + << " grainRate=" << mGrainRate.numerator + << "/" << mGrainRate.denominator + << " grainsPerFrame=" << configInfo.discrete.grainCount + << std::endl; + } + + mSourceWidth = deriveV210Width(mSourceStride); + + if (mSourceWidth == 0) + { + std::cerr << "MxlSdkFeed: could not determine source width from stride=" + << mSourceStride << std::endl; + mxlReleaseFlowReader(instance, mReader); + mReader = nullptr; + return false; + } + + size_t defBufSize = 0; + mxlStatus defStatus = mxlGetFlowDef( + instance, + mFlowId.c_str(), + nullptr, + &defBufSize); + + if (mVerbose) + { + std::cerr << "MxlSdkFeed: mxlGetFlowDef status=" << defStatus + << " bufSize=" << defBufSize << std::endl; + } + + if (defBufSize > 0) + { + std::vector defBuf(defBufSize + 1); + size_t readSize = defBufSize; + defStatus = mxlGetFlowDef( + instance, + mFlowId.c_str(), + defBuf.data(), + &readSize); + + if (mVerbose) + { + std::cerr << "MxlSdkFeed: mxlGetFlowDef(read) status=" + << defStatus + << " readSize=" << readSize << std::endl; + } + + if (readSize > 0) + { + defBuf[readSize] = '\0'; + uint32_t jsonWidth = parseUintFromJson(defBuf.data(), "frame_width"); + uint32_t jsonHeight = parseUintFromJson(defBuf.data(), "frame_height"); + std::string flowName = + firstNonEmptyFlowLabel(defBuf.data()); + + if (jsonWidth > 0) + { + mSourceWidth = jsonWidth; + } + + if (jsonHeight > 0) + { + mSourceHeight = jsonHeight; + } + + if (!flowName.empty()) + { + mFlowName = std::move(flowName); + } + + if (mVerbose) + { + std::cerr << "MxlSdkFeed: flow definition: " + << jsonWidth << "x" << jsonHeight << std::endl; + if (!mFlowName.empty()) + { + std::cerr << "MxlSdkFeed: flow name: " + << mFlowName << std::endl; + } + } + } + } + + if (mSourceHeight == 0) + { + mSourceHeight = 1080; + std::cerr << "MxlSdkFeed: assuming height=1080" << std::endl; + } + + if (mGrainRate.denominator == 0) + { + mGrainRate.numerator = 30000; + mGrainRate.denominator = 1001; + } + + mxlFlowRuntimeInfo runtimeInfo{}; + if (mxlFlowReaderGetRuntimeInfo(mReader, &runtimeInfo) == + MXL_STATUS_OK && + runtimeInfo.headIndex > 0) + { + mLastDisplayedIndex = runtimeInfo.headIndex - 1; + } + else + { + mLastDisplayedIndex = mxlGetCurrentIndex(&mGrainRate); + } + + if (mVerbose) + { + std::cerr << "MxlSdkFeed: opened flow " << mFlowId + << " stride=" << mSourceStride + << " grainRate=" << mGrainRate.numerator + << "/" << mGrainRate.denominator + << " src=" << mSourceWidth << "x" << mSourceHeight + << std::endl; + } + + mFlowOpened = true; + mFlowInvalid = false; + mOpenRetryCount = 0; + return true; +} + +void MxlSdkFeed::closeFlow() +{ + if (mReader && mInstanceHandle && mInstanceHandle->instance) + { + mxlReleaseFlowReader(mInstanceHandle->instance, mReader); + mReader = nullptr; + } + + mFlowOpened = false; + mFlowInvalid = true; + mOpenRetryCount = 0; +} + +const VideoFrame& MxlSdkFeed::getFrame(uint32_t frameCounter) +{ + (void)frameCounter; + + if (!mFlowOpened && !openFlow()) + { + return mFrame; + } + + uint64_t index = mLastDisplayedIndex + 1; + const uint64_t currentIndex = mxlGetCurrentIndex(&mGrainRate); + + if (index > currentIndex) + { + return mFrame; + } + + mxlGrainInfo grain{}; + grain.version = 2; + grain.size = sizeof(mxlGrainInfo); + + uint8_t* payload = nullptr; + + while (true) + { + mxlStatus status = mxlFlowReaderGetGrainNonBlocking( + mReader, + index, + &grain, + &payload); + + if (status == MXL_STATUS_OK) + { + break; + } + + if (status == MXL_ERR_OUT_OF_RANGE_TOO_EARLY) + { + return mFrame; + } + + if (status == MXL_ERR_OUT_OF_RANGE_TOO_LATE) + { + mxlFlowRuntimeInfo runtimeInfo{}; + if (mxlFlowReaderGetRuntimeInfo(mReader, &runtimeInfo) != + MXL_STATUS_OK) + { + return mFrame; + } + + if (runtimeInfo.headIndex == 0) + { + return mFrame; + } + + index = runtimeInfo.headIndex - 1; + + if (index <= mLastDisplayedIndex) + { + return mFrame; + } + + continue; + } + + if (status == MXL_ERR_FLOW_INVALID) + { + std::cerr << "MxlSdkFeed: flow invalidated, reconnecting" + << std::endl; + closeFlow(); + return mFrame; + } + + std::cerr << "MxlSdkFeed: grain read error status=" + << static_cast(status) << std::endl; + return mFrame; + } + + mLastDisplayedIndex = index; + + mV210Payload = payload; + ++mFrameVersion; + + return mFrame; +} + +FeedRuntimeStatus MxlSdkFeed::status() const +{ + if (mFlowOpened && mV210Payload != nullptr) + { + return FeedRuntimeStatus::Live; + } + + if (mFlowOpened) + { + return FeedRuntimeStatus::Connecting; + } + + return mFlowInvalid + ? FeedRuntimeStatus::Reconnecting + : FeedRuntimeStatus::Connecting; +} + +std::string MxlSdkFeed::displayName() const +{ + return mFlowName.empty() ? "MXL LIVE" : mFlowName; +} + +std::string MxlSdkFeed::sourceInfo() const +{ + std::ostringstream out; + + if (!mFlowName.empty()) + { + out << mFlowName; + } + + if (mSourceWidth == 0 || mSourceHeight == 0) + { + return out.str(); + } + + if (!mFlowName.empty()) + { + out << " "; + } + + out << mSourceWidth << "x" << mSourceHeight; + + if (mGrainRate.denominator > 0) + { + const double fps = + static_cast(mGrainRate.numerator) / + static_cast(mGrainRate.denominator); + + out << "@"; + + if (mGrainRate.denominator == 1) + { + out << mGrainRate.numerator; + } + else + { + out << std::fixed << std::setprecision(2) << fps; + } + + out << "p"; + } + + return out.str(); +} + +uint64_t MxlSdkFeed::frameVersion() const { return mFrameVersion; } +bool MxlSdkFeed::hasGrainIndex() const { return mFlowOpened; } +uint64_t MxlSdkFeed::grainIndex() const { return mLastDisplayedIndex; } + +float MxlSdkFeed::srcAspectRatio() const +{ + if (mSourceWidth > 0 && mSourceHeight > 0) + { + return static_cast(mSourceWidth) / + static_cast(mSourceHeight); + } + + return 16.0f / 9.0f; +} + +bool MxlSdkFeed::hasV210() const { return mFlowOpened && mV210Payload != nullptr; } +const uint8_t* MxlSdkFeed::v210Data() const { return mV210Payload; } +uint32_t MxlSdkFeed::v210Width() const { return mSourceWidth; } +uint32_t MxlSdkFeed::v210Height() const { return mSourceHeight; } +uint32_t MxlSdkFeed::v210Stride() const { return mSourceStride; } + +#else + +bool MxlSdkFeed::openFlow() { return false; } +void MxlSdkFeed::closeFlow() {} +FeedRuntimeStatus MxlSdkFeed::status() const { return FeedRuntimeStatus::Error; } +std::string MxlSdkFeed::displayName() const { return "MXL SDK DISABLED"; } +std::string MxlSdkFeed::sourceInfo() const { return ""; } +uint64_t MxlSdkFeed::frameVersion() const { return 0; } +bool MxlSdkFeed::hasGrainIndex() const { return false; } +uint64_t MxlSdkFeed::grainIndex() const { return 0; } +float MxlSdkFeed::srcAspectRatio() const { return 16.0f / 9.0f; } +bool MxlSdkFeed::hasV210() const { return false; } +const uint8_t* MxlSdkFeed::v210Data() const { return nullptr; } +uint32_t MxlSdkFeed::v210Width() const { return 0; } +uint32_t MxlSdkFeed::v210Height() const { return 0; } +uint32_t MxlSdkFeed::v210Stride() const { return 0; } + +const VideoFrame& MxlSdkFeed::getFrame(uint32_t frameCounter) +{ + (void)frameCounter; + + for (uint32_t y = 0; y < mFrame.height; ++y) + { + for (uint32_t x = 0; x < mFrame.width; ++x) + { + uint8_t v = ((x + y) % 2 == 0) ? 80 : 40; + mFrame.pixels[y * mFrame.width + x] = + packRgba8({v, v, v}); + } + } + + return mFrame; +} + +#endif diff --git a/MxlSdkFeed.hpp b/MxlSdkFeed.hpp new file mode 100644 index 0000000..fbbed94 --- /dev/null +++ b/MxlSdkFeed.hpp @@ -0,0 +1,75 @@ +#pragma once + +#include "IVideoFeed.hpp" + +#include +#include + +struct MxlInstanceHandle; + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + +#include +#include +#include +#include + +#endif + +class MxlSdkFeed : public IVideoFeed +{ +public: + MxlSdkFeed( + const std::string& domain, + const std::string& flowId, + uint32_t outputWidth, + uint32_t outputHeight, + bool verbose = false); + + ~MxlSdkFeed() override; + + MxlSdkFeed(const MxlSdkFeed&) = delete; + MxlSdkFeed& operator=(const MxlSdkFeed&) = delete; + + const VideoFrame& getFrame(uint32_t frameCounter) override; + FeedRuntimeStatus status() const override; + std::string displayName() const override; + std::string sourceInfo() const override; + uint64_t frameVersion() const override; + bool hasGrainIndex() const override; + uint64_t grainIndex() const override; + + float srcAspectRatio() const override; + + bool hasV210() const override; + const uint8_t* v210Data() const override; + uint32_t v210Width() const override; + uint32_t v210Height() const override; + uint32_t v210Stride() const override; + +private: + bool openFlow(); + void closeFlow(); + + std::string mDomain; + std::string mFlowId; + std::string mFlowName; + + VideoFrame mFrame; + +#if MXL_MULTIVIEWER_ENABLE_MXL_SDK + MxlInstanceHandle* mInstanceHandle = nullptr; + mxlFlowReader mReader = nullptr; + mxlRational mGrainRate{}; + uint64_t mLastDisplayedIndex = 0; + uint32_t mSourceWidth = 0; + uint32_t mSourceHeight = 0; + uint32_t mSourceStride = 0; + uint64_t mFrameVersion = 0; + int mOpenRetryCount = 0; + bool mVerbose = false; + bool mFlowOpened = false; + bool mFlowInvalid = false; + const uint8_t* mV210Payload = nullptr; +#endif +}; diff --git a/NoSignalFeed.cpp b/NoSignalFeed.cpp new file mode 100644 index 0000000..7afb858 --- /dev/null +++ b/NoSignalFeed.cpp @@ -0,0 +1,220 @@ +#include "NoSignalFeed.hpp" +#include "PixelFormat.hpp" + +namespace +{ +constexpr uint32_t TileBorderPixels = 0; + +uint32_t glyphRows(char c, uint32_t row) +{ + switch (c) + { + case 'A': + { + constexpr uint32_t rows[] = + {0x0E, 0x11, 0x11, 0x1F, 0x11, 0x11, 0x11}; + return rows[row]; + } + + case 'G': + { + constexpr uint32_t rows[] = + {0x0E, 0x11, 0x10, 0x17, 0x11, 0x11, 0x0E}; + return rows[row]; + } + + case 'I': + { + constexpr uint32_t rows[] = + {0x1F, 0x04, 0x04, 0x04, 0x04, 0x04, 0x1F}; + return rows[row]; + } + + case 'L': + { + constexpr uint32_t rows[] = + {0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1F}; + return rows[row]; + } + + case 'N': + { + constexpr uint32_t rows[] = + {0x11, 0x19, 0x15, 0x13, 0x11, 0x11, 0x11}; + return rows[row]; + } + + case 'O': + { + constexpr uint32_t rows[] = + {0x0E, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0E}; + return rows[row]; + } + + case 'S': + { + constexpr uint32_t rows[] = + {0x0F, 0x10, 0x10, 0x0E, 0x01, 0x01, 0x1E}; + return rows[row]; + } + + default: + return 0; + } +} + +void drawText( + VideoFrame& frame, + const char* text, + uint32_t originX, + uint32_t originY, + uint32_t scale, + RgbColor color) +{ + for (uint32_t charIndex = 0; text[charIndex] != '\0'; ++charIndex) + { + const char c = text[charIndex]; + + if (c == ' ') + { + continue; + } + + const uint32_t charX = + originX + charIndex * 6 * scale; + + for (uint32_t gy = 0; gy < 7; ++gy) + { + const uint32_t bits = glyphRows(c, gy); + + for (uint32_t gx = 0; gx < 5; ++gx) + { + if ((bits & (1u << (4 - gx))) == 0) + { + continue; + } + + for (uint32_t sy = 0; sy < scale; ++sy) + { + for (uint32_t sx = 0; sx < scale; ++sx) + { + const uint32_t x = + charX + gx * scale + sx; + const uint32_t y = + originY + gy * scale + sy; + + if (x < frame.width && y < frame.height) + { + frame.pixels[y * frame.width + x] = + packRgba8(color); + } + } + } + } + } + } +} + +void fillNoSignalFrame(VideoFrame& frame) +{ + frame.pixels.resize(frame.width * frame.height); + + for (uint32_t y = 0; y < frame.height; ++y) + { + for (uint32_t x = 0; x < frame.width; ++x) + { + const bool isBorder = + x < TileBorderPixels || + y < TileBorderPixels || + x >= frame.width - TileBorderPixels || + y >= frame.height - TileBorderPixels; + + const bool hatch = + ((x + y) / 18) % 2 == 0; + + const RgbColor color = + isBorder + ? RgbColor{95, 100, 110} + : (hatch + ? RgbColor{18, 20, 24} + : RgbColor{12, 14, 18}); + + frame.pixels[y * frame.width + x] = + packRgba8(color); + } + } + + const uint32_t scale = + frame.width >= 512 ? 5 : 3; + constexpr uint32_t textChars = 9; + const uint32_t textWidth = + (textChars * 6 - 1) * scale; + const uint32_t textHeight = 7 * scale; + const uint32_t textX = + frame.width > textWidth + ? (frame.width - textWidth) / 2 + : 0; + const uint32_t textY = + frame.height > textHeight + ? (frame.height - textHeight) / 2 + : 0; + + drawText( + frame, + "NO SIGNAL", + textX, + textY, + scale, + {210, 215, 225} + ); +} +} + +NoSignalFeed::NoSignalFeed( + uint32_t feedIndex, + uint32_t frameWidth, + uint32_t frameHeight) +{ + configure( + feedIndex, + frameWidth, + frameHeight + ); +} + +void NoSignalFeed::configure( + uint32_t feedIndex, + uint32_t frameWidth, + uint32_t frameHeight) +{ + (void)feedIndex; + generated = false; + version = 0; + frame.width = frameWidth; + frame.height = frameHeight; + frame.pixels.resize(frame.width * frame.height); +} + +const VideoFrame& NoSignalFeed::getFrame(uint32_t frameCounter) +{ + (void)frameCounter; + + if (!generated) + { + fillNoSignalFrame(frame); + generated = true; + ++version; + } + + return frame; +} + +FeedRuntimeStatus NoSignalFeed::status() const +{ + return FeedRuntimeStatus::NoSignal; +} + +std::string NoSignalFeed::displayName() const +{ + return "NO SIGNAL"; +} diff --git a/NoSignalFeed.hpp b/NoSignalFeed.hpp new file mode 100644 index 0000000..550a6ce --- /dev/null +++ b/NoSignalFeed.hpp @@ -0,0 +1,30 @@ +#pragma once + +#include "IVideoFeed.hpp" +#include "VideoFrame.hpp" + +#include + +class NoSignalFeed : public IVideoFeed +{ +public: + NoSignalFeed( + uint32_t feedIndex, + uint32_t frameWidth, + uint32_t frameHeight); + + void configure( + uint32_t feedIndex, + uint32_t frameWidth, + uint32_t frameHeight); + + const VideoFrame& getFrame(uint32_t frameCounter) override; + FeedRuntimeStatus status() const override; + std::string displayName() const override; + uint64_t frameVersion() const override { return version; } + +private: + bool generated = false; + uint64_t version = 0; + VideoFrame frame; +}; diff --git a/PixelFormat.hpp b/PixelFormat.hpp new file mode 100644 index 0000000..74dce4e --- /dev/null +++ b/PixelFormat.hpp @@ -0,0 +1,190 @@ +#pragma once + +#include + +struct RgbColor +{ + uint8_t r = 0; + uint8_t g = 0; + uint8_t b = 0; +}; + +inline uint32_t packRgba8(RgbColor color) +{ + constexpr uint8_t alpha = 255; + + return (alpha << 24) | + (color.b << 16) | + (color.g << 8) | + color.r; +} + +inline uint8_t clampUint8(int32_t v) +{ + return static_cast( + v < 0 ? 0 : (v > 255 ? 255 : v) + ); +} + +inline uint32_t v210LineStride(uint32_t width) +{ + uint32_t groups = (width + 5) / 6; + uint32_t rawBytes = groups * 16; + return ((rawBytes + 127) / 128) * 128; +} + +inline void decodeV210Line( + const uint8_t* lineData, + uint32_t* rgbaLine, + uint32_t width) +{ + for (uint32_t x = 0; x < width; ++x) + { + uint32_t group = x / 6; + uint32_t pos = x % 6; + + const uint32_t baseOffset = group * 16; + uint32_t w0; + uint32_t w1; + uint32_t w2; + uint32_t w3; + + const uint8_t* p = lineData + baseOffset; + w0 = static_cast(p[0]) | + (static_cast(p[1]) << 8) | + (static_cast(p[2]) << 16) | + (static_cast(p[3]) << 24); + w1 = static_cast(p[4]) | + (static_cast(p[5]) << 8) | + (static_cast(p[6]) << 16) | + (static_cast(p[7]) << 24); + w2 = static_cast(p[8]) | + (static_cast(p[9]) << 8) | + (static_cast(p[10]) << 16) | + (static_cast(p[11]) << 24); + w3 = static_cast(p[12]) | + (static_cast(p[13]) << 8) | + (static_cast(p[14]) << 16) | + (static_cast(p[15]) << 24); + + uint32_t cb0 = (w0 >> 0) & 0x3FF; + uint32_t y0 = (w0 >> 10) & 0x3FF; + uint32_t cr0 = (w0 >> 20) & 0x3FF; + uint32_t y1 = (w1 >> 0) & 0x3FF; + uint32_t cb2 = (w1 >> 10) & 0x3FF; + uint32_t y2 = (w1 >> 20) & 0x3FF; + uint32_t cr2 = (w2 >> 0) & 0x3FF; + uint32_t y3 = (w2 >> 10) & 0x3FF; + uint32_t cb4 = (w2 >> 20) & 0x3FF; + uint32_t y4 = (w3 >> 0) & 0x3FF; + uint32_t cr4 = (w3 >> 10) & 0x3FF; + uint32_t y5 = (w3 >> 20) & 0x3FF; + + uint32_t y10; + uint32_t cb10; + uint32_t cr10; + + switch (pos) + { + case 0: y10 = y0; cb10 = cb0; cr10 = cr0; break; + case 1: y10 = y1; cb10 = cb0; cr10 = cr0; break; + case 2: y10 = y2; cb10 = cb2; cr10 = cr2; break; + case 3: y10 = y3; cb10 = cb2; cr10 = cr2; break; + case 4: y10 = y4; cb10 = cb4; cr10 = cr4; break; + case 5: y10 = y5; cb10 = cb4; cr10 = cr4; break; + default: y10 = y0; cb10 = cb0; cr10 = cr0; break; + } + + int32_t yp = (static_cast(y10) - 64) >> 2; + int32_t cbp = (static_cast(cb10) - 512) >> 2; + int32_t crp = (static_cast(cr10) - 512) >> 2; + + int32_t r = (298 * yp + 459 * crp + 128) >> 8; + int32_t g = (298 * yp - 137 * crp - 55 * cbp + 128) >> 8; + int32_t b = (298 * yp + 541 * cbp + 128) >> 8; + + rgbaLine[x] = packRgba8({clampUint8(r), clampUint8(g), clampUint8(b)}); + } +} + +inline void convertV210ToRgba( + const uint8_t* v210Data, + uint32_t srcWidth, + uint32_t srcHeight, + uint32_t srcStride, + uint32_t* rgbaData, + uint32_t dstWidth, + uint32_t dstHeight) +{ + for (uint32_t dy = 0; dy < dstHeight; ++dy) + { + uint32_t sy = dy * srcHeight / dstHeight; + + const uint8_t* srcLine = v210Data + sy * srcStride; + + for (uint32_t dx = 0; dx < dstWidth; ++dx) + { + uint32_t sx = dx * srcWidth / dstWidth; + + uint32_t group = sx / 6; + uint32_t pos = sx % 6; + + const uint8_t* p = srcLine + group * 16; + uint32_t w0 = static_cast(p[0]) | + (static_cast(p[1]) << 8) | + (static_cast(p[2]) << 16) | + (static_cast(p[3]) << 24); + uint32_t w1 = static_cast(p[4]) | + (static_cast(p[5]) << 8) | + (static_cast(p[6]) << 16) | + (static_cast(p[7]) << 24); + uint32_t w2 = static_cast(p[8]) | + (static_cast(p[9]) << 8) | + (static_cast(p[10]) << 16) | + (static_cast(p[11]) << 24); + uint32_t w3 = static_cast(p[12]) | + (static_cast(p[13]) << 8) | + (static_cast(p[14]) << 16) | + (static_cast(p[15]) << 24); + + uint32_t cb0 = (w0 >> 0) & 0x3FF; + uint32_t y0 = (w0 >> 10) & 0x3FF; + uint32_t cr0 = (w0 >> 20) & 0x3FF; + uint32_t y1 = (w1 >> 0) & 0x3FF; + uint32_t cb2 = (w1 >> 10) & 0x3FF; + uint32_t y2 = (w1 >> 20) & 0x3FF; + uint32_t cr2 = (w2 >> 0) & 0x3FF; + uint32_t y3 = (w2 >> 10) & 0x3FF; + uint32_t cb4 = (w2 >> 20) & 0x3FF; + uint32_t y4 = (w3 >> 0) & 0x3FF; + uint32_t cr4 = (w3 >> 10) & 0x3FF; + uint32_t y5 = (w3 >> 20) & 0x3FF; + + uint32_t y10; + uint32_t cb10; + uint32_t cr10; + + switch (pos) + { + case 0: y10 = y0; cb10 = cb0; cr10 = cr0; break; + case 1: y10 = y1; cb10 = cb0; cr10 = cr0; break; + case 2: y10 = y2; cb10 = cb2; cr10 = cr2; break; + case 3: y10 = y3; cb10 = cb2; cr10 = cr2; break; + case 4: y10 = y4; cb10 = cb4; cr10 = cr4; break; + case 5: y10 = y5; cb10 = cb4; cr10 = cr4; break; + default: y10 = y0; cb10 = cb0; cr10 = cr0; break; + } + + int32_t yp = (static_cast(y10) - 64) >> 2; + int32_t cbp = (static_cast(cb10) - 512) >> 2; + int32_t crp = (static_cast(cr10) - 512) >> 2; + + int32_t r = (298 * yp + 459 * crp + 128) >> 8; + int32_t g = (298 * yp - 137 * crp - 55 * cbp + 128) >> 8; + int32_t b = (298 * yp + 541 * cbp + 128) >> 8; + + rgbaData[dy * dstWidth + dx] = packRgba8( + {clampUint8(r), clampUint8(g), clampUint8(b)}); + } + } +} \ No newline at end of file diff --git a/RenderPipeline.cpp b/RenderPipeline.cpp new file mode 100644 index 0000000..fc868c0 --- /dev/null +++ b/RenderPipeline.cpp @@ -0,0 +1,424 @@ +#include "RenderPipeline.hpp" +#include "TileLayout.hpp" + +#include +#include +#include +#include +#include + +std::vector RenderPipeline::readFile( + const std::string& filename) +{ + std::ifstream file( + filename, + std::ios::ate | std::ios::binary + ); + + if (!file.is_open()) + { + throw std::runtime_error( + "Failed to open file: " + filename + ); + } + + size_t fileSize = + static_cast(file.tellg()); + + std::vector buffer(fileSize); + file.seekg(0); + file.read(buffer.data(), fileSize); + file.close(); + + return buffer; +} + +VkShaderModule RenderPipeline::createShaderModule( + const std::vector& code) +{ + VkShaderModuleCreateInfo createInfo{}; + createInfo.sType = + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + createInfo.codeSize = code.size(); + createInfo.pCode = + reinterpret_cast( + code.data() + ); + + VkShaderModule shaderModule; + + if (vkCreateShaderModule( + m_device, + &createInfo, + nullptr, + &shaderModule) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create shader module" + ); + } + + return shaderModule; +} + +RenderPipeline::RenderPipeline( + VkDevice device, + VkFormat swapchainImageFormat) + : m_device(device) +{ + // Render pass + VkAttachmentDescription colorAttachment{}; + colorAttachment.format = swapchainImageFormat; + colorAttachment.samples = VK_SAMPLE_COUNT_1_BIT; + colorAttachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; + colorAttachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; + colorAttachment.stencilLoadOp = + VK_ATTACHMENT_LOAD_OP_DONT_CARE; + colorAttachment.stencilStoreOp = + VK_ATTACHMENT_STORE_OP_DONT_CARE; + colorAttachment.initialLayout = + VK_IMAGE_LAYOUT_UNDEFINED; + colorAttachment.finalLayout = + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; + + VkAttachmentReference colorAttachmentRef{}; + colorAttachmentRef.attachment = 0; + colorAttachmentRef.layout = + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; + + VkSubpassDescription subpass{}; + subpass.pipelineBindPoint = + VK_PIPELINE_BIND_POINT_GRAPHICS; + subpass.colorAttachmentCount = 1; + subpass.pColorAttachments = &colorAttachmentRef; + + VkRenderPassCreateInfo renderPassInfo{}; + renderPassInfo.sType = + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; + renderPassInfo.attachmentCount = 1; + renderPassInfo.pAttachments = &colorAttachment; + renderPassInfo.subpassCount = 1; + renderPassInfo.pSubpasses = &subpass; + + if (vkCreateRenderPass( + m_device, + &renderPassInfo, + nullptr, + &m_renderPass) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create render pass" + ); + } + + std::cout << "Render pass created" << std::endl; + + // Shaders + auto vertShaderCode = + readFile( + "../shaders/bin/textured.vert.spv" + ); + auto fragShaderCode = + readFile( + "../shaders/bin/textured.frag.spv" + ); + + m_vertShaderModule = + createShaderModule(vertShaderCode); + m_fragShaderModule = + createShaderModule(fragShaderCode); + + std::cout << "Shaders loaded" << std::endl; + + VkPipelineShaderStageCreateInfo vertStageInfo{}; + vertStageInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + vertStageInfo.stage = VK_SHADER_STAGE_VERTEX_BIT; + vertStageInfo.module = m_vertShaderModule; + vertStageInfo.pName = "main"; + + VkPipelineShaderStageCreateInfo fragStageInfo{}; + fragStageInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + fragStageInfo.stage = + VK_SHADER_STAGE_FRAGMENT_BIT; + fragStageInfo.module = m_fragShaderModule; + fragStageInfo.pName = "main"; + + VkPipelineShaderStageCreateInfo shaderStages[] = + { + vertStageInfo, + fragStageInfo + }; + + // Vertex input + VkVertexInputBindingDescription + bindingDescription{}; + bindingDescription.binding = 0; + bindingDescription.stride = sizeof(Vertex); + bindingDescription.inputRate = + VK_VERTEX_INPUT_RATE_VERTEX; + + std::array< + VkVertexInputAttributeDescription, + 2 + > attributeDescriptions{}; + + attributeDescriptions[0].binding = 0; + attributeDescriptions[0].location = 0; + attributeDescriptions[0].format = + VK_FORMAT_R32G32_SFLOAT; + attributeDescriptions[0].offset = + offsetof(Vertex, pos); + + attributeDescriptions[1].binding = 0; + attributeDescriptions[1].location = 1; + attributeDescriptions[1].format = + VK_FORMAT_R32G32_SFLOAT; + attributeDescriptions[1].offset = + offsetof(Vertex, uv); + + VkPipelineVertexInputStateCreateInfo + vertexInputInfo{}; + vertexInputInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO; + vertexInputInfo + .vertexBindingDescriptionCount = 1; + vertexInputInfo + .pVertexBindingDescriptions = + &bindingDescription; + vertexInputInfo + .vertexAttributeDescriptionCount = + static_cast( + attributeDescriptions.size() + ); + vertexInputInfo + .pVertexAttributeDescriptions = + attributeDescriptions.data(); + + // Input assembly + VkPipelineInputAssemblyStateCreateInfo + inputAssembly{}; + inputAssembly.sType = + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO; + inputAssembly.topology = + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST; + + // Viewport state (dynamic, values don't matter) + VkViewport dummyViewport{}; + dummyViewport.x = 0.0f; + dummyViewport.y = 0.0f; + dummyViewport.width = 1.0f; + dummyViewport.height = 1.0f; + dummyViewport.minDepth = 0.0f; + dummyViewport.maxDepth = 1.0f; + + VkRect2D dummyScissor{}; + dummyScissor.offset = {0, 0}; + dummyScissor.extent = {1, 1}; + + VkPipelineViewportStateCreateInfo + viewportState{}; + viewportState.sType = + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO; + viewportState.viewportCount = 1; + viewportState.pViewports = &dummyViewport; + viewportState.scissorCount = 1; + viewportState.pScissors = &dummyScissor; + + // Rasterizer + VkPipelineRasterizationStateCreateInfo + rasterizer{}; + rasterizer.sType = + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; + rasterizer.polygonMode = VK_POLYGON_MODE_FILL; + rasterizer.lineWidth = 1.0f; + rasterizer.cullMode = VK_CULL_MODE_BACK_BIT; + rasterizer.frontFace = + VK_FRONT_FACE_CLOCKWISE; + + // Multisampling + VkPipelineMultisampleStateCreateInfo + multisampling{}; + multisampling.sType = + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; + multisampling.rasterizationSamples = + VK_SAMPLE_COUNT_1_BIT; + + // Dynamic state + VkDynamicState dynamicStates[] = + { + VK_DYNAMIC_STATE_VIEWPORT, + VK_DYNAMIC_STATE_SCISSOR + }; + + VkPipelineDynamicStateCreateInfo + dynamicState{}; + dynamicState.sType = + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO; + dynamicState.dynamicStateCount = 2; + dynamicState.pDynamicStates = dynamicStates; + + // Color blend + VkPipelineColorBlendAttachmentState + colorBlendAttachment{}; + colorBlendAttachment.colorWriteMask = + VK_COLOR_COMPONENT_R_BIT | + VK_COLOR_COMPONENT_G_BIT | + VK_COLOR_COMPONENT_B_BIT | + VK_COLOR_COMPONENT_A_BIT; + + VkPipelineColorBlendStateCreateInfo + colorBlending{}; + colorBlending.sType = + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO; + colorBlending.attachmentCount = 1; + colorBlending.pAttachments = + &colorBlendAttachment; + + // Descriptor set layout + VkDescriptorSetLayoutBinding + samplerLayoutBinding{}; + samplerLayoutBinding.binding = 0; + samplerLayoutBinding.descriptorCount = 1; + samplerLayoutBinding.descriptorType = + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; + samplerLayoutBinding.pImmutableSamplers = + nullptr; + samplerLayoutBinding.stageFlags = + VK_SHADER_STAGE_FRAGMENT_BIT; + + VkDescriptorSetLayoutCreateInfo + layoutInfo{}; + layoutInfo.sType = + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layoutInfo.bindingCount = 1; + layoutInfo.pBindings = &samplerLayoutBinding; + + if (vkCreateDescriptorSetLayout( + m_device, + &layoutInfo, + nullptr, + &m_descriptorSetLayout) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create descriptor set layout" + ); + } + + VkPipelineLayoutCreateInfo + pipelineLayoutInfo{}; + pipelineLayoutInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + pipelineLayoutInfo.setLayoutCount = 1; + pipelineLayoutInfo.pSetLayouts = + &m_descriptorSetLayout; + + if (vkCreatePipelineLayout( + m_device, + &pipelineLayoutInfo, + nullptr, + &m_pipelineLayout) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create pipeline layout" + ); + } + + // Graphics pipeline + VkGraphicsPipelineCreateInfo + pipelineInfo{}; + pipelineInfo.sType = + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO; + pipelineInfo.stageCount = 2; + pipelineInfo.pStages = shaderStages; + pipelineInfo.pVertexInputState = + &vertexInputInfo; + pipelineInfo.pInputAssemblyState = + &inputAssembly; + pipelineInfo.pViewportState = + &viewportState; + pipelineInfo.pRasterizationState = + &rasterizer; + pipelineInfo.pMultisampleState = + &multisampling; + pipelineInfo.pDynamicState = &dynamicState; + pipelineInfo.pColorBlendState = + &colorBlending; + pipelineInfo.layout = m_pipelineLayout; + pipelineInfo.renderPass = m_renderPass; + pipelineInfo.subpass = 0; + + if (vkCreateGraphicsPipelines( + m_device, + VK_NULL_HANDLE, + 1, + &pipelineInfo, + nullptr, + &m_graphicsPipeline) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create graphics pipeline" + ); + } + + std::cout << "Graphics pipeline created" + << std::endl; +} + +RenderPipeline::~RenderPipeline() +{ + release(); +} + +void RenderPipeline::release() +{ + if (m_device == VK_NULL_HANDLE) + { + return; + } + + vkDestroyPipeline( + m_device, + m_graphicsPipeline, + nullptr + ); + m_graphicsPipeline = VK_NULL_HANDLE; + + vkDestroyPipelineLayout( + m_device, + m_pipelineLayout, + nullptr + ); + m_pipelineLayout = VK_NULL_HANDLE; + + vkDestroyDescriptorSetLayout( + m_device, + m_descriptorSetLayout, + nullptr + ); + m_descriptorSetLayout = VK_NULL_HANDLE; + + vkDestroyShaderModule( + m_device, + m_vertShaderModule, + nullptr + ); + m_vertShaderModule = VK_NULL_HANDLE; + + vkDestroyShaderModule( + m_device, + m_fragShaderModule, + nullptr + ); + m_fragShaderModule = VK_NULL_HANDLE; + + vkDestroyRenderPass( + m_device, + m_renderPass, + nullptr + ); + m_renderPass = VK_NULL_HANDLE; + + m_device = VK_NULL_HANDLE; +} diff --git a/RenderPipeline.hpp b/RenderPipeline.hpp new file mode 100644 index 0000000..fab072b --- /dev/null +++ b/RenderPipeline.hpp @@ -0,0 +1,42 @@ +#pragma once + +#include + +#include +#include +#include + +class RenderPipeline +{ +public: + RenderPipeline( + VkDevice device, + VkFormat swapchainImageFormat); + + ~RenderPipeline(); + + RenderPipeline(const RenderPipeline&) = delete; + RenderPipeline& operator=(const RenderPipeline&) = delete; + + VkRenderPass renderPass() const { return m_renderPass; } + VkPipelineLayout pipelineLayout() const { return m_pipelineLayout; } + VkDescriptorSetLayout descriptorSetLayout() const { return m_descriptorSetLayout; } + VkPipeline graphicsPipeline() const { return m_graphicsPipeline; } + + void release(); + +private: + std::vector readFile( + const std::string& filename); + VkShaderModule createShaderModule( + const std::vector& code); + + VkDevice m_device; + + VkRenderPass m_renderPass = VK_NULL_HANDLE; + VkShaderModule m_vertShaderModule = VK_NULL_HANDLE; + VkShaderModule m_fragShaderModule = VK_NULL_HANDLE; + VkDescriptorSetLayout m_descriptorSetLayout = VK_NULL_HANDLE; + VkPipelineLayout m_pipelineLayout = VK_NULL_HANDLE; + VkPipeline m_graphicsPipeline = VK_NULL_HANDLE; +}; diff --git a/SmpteBarsFeed.cpp b/SmpteBarsFeed.cpp new file mode 100644 index 0000000..44bd66d --- /dev/null +++ b/SmpteBarsFeed.cpp @@ -0,0 +1,114 @@ +#include "SmpteBarsFeed.hpp" +#include "PixelFormat.hpp" + +#include + +namespace +{ +RgbColor smpteColorAt( + uint32_t x, + uint32_t y, + uint32_t width, + uint32_t height) +{ + // 75% SMPTE color bars: 0.75 * 255 = 191 + static constexpr std::array TopBars = + { + RgbColor{191, 191, 191}, // 75% white + RgbColor{191, 191, 0}, // yellow + RgbColor{0, 191, 191}, // cyan + RgbColor{0, 191, 0}, // green + RgbColor{191, 0, 191}, // magenta + RgbColor{191, 0, 0}, // red + RgbColor{0, 0, 191}, // blue + RgbColor{16, 16, 16} // black (reference) + }; + + static constexpr std::array MiddleBars = + { + RgbColor{16, 16, 130}, // blue -I + RgbColor{16, 16, 16}, // black + RgbColor{130, 16, 130}, // magenta +Q + RgbColor{16, 16, 16}, // black + RgbColor{16, 130, 130}, // cyan +I + RgbColor{16, 16, 16}, // black + RgbColor{191, 191, 191}, // 75% white + RgbColor{191, 191, 191} // 75% white + }; + + const uint32_t topHeight = (height * 2) / 3; + const uint32_t middleHeight = (height * 3) / 4; + const size_t bar = (x * TopBars.size()) / width; + + if (y < topHeight) + { + return TopBars[bar]; + } + + if (y < middleHeight) + { + return MiddleBars[bar]; + } + + const uint32_t segment = (x * 4) / width; + + if (segment == 0) + { + return {0, 33, 76}; // -I (narrow cyan) + } + + if (segment == 1) + { + return {33, 0, 51}; // +Q (purple) + } + + if (segment == 2) + { + return {16, 16, 16}; // black + } + + return {26, 26, 26}; // 10% gray (pluge reference) +} +} + +SmpteBarsFeed::SmpteBarsFeed( + uint32_t frameWidth, + uint32_t frameHeight) +{ + frame.width = frameWidth; + frame.height = frameHeight; + frame.pixels.resize(frame.width * frame.height); + + for (uint32_t y = 0; y < frame.height; ++y) + { + for (uint32_t x = 0; x < frame.width; ++x) + { + frame.pixels[y * frame.width + x] = + packRgba8( + smpteColorAt( + x, + y, + frame.width, + frame.height + ) + ); + } + } +} + +const VideoFrame& SmpteBarsFeed::getFrame(uint32_t frameCounter) +{ + (void)frameCounter; + + return frame; +} + +FeedRuntimeStatus SmpteBarsFeed::status() const +{ + return FeedRuntimeStatus::Bars; +} + +std::string SmpteBarsFeed::displayName() const +{ + return "BARS"; +} diff --git a/SmpteBarsFeed.hpp b/SmpteBarsFeed.hpp new file mode 100644 index 0000000..72e1a9c --- /dev/null +++ b/SmpteBarsFeed.hpp @@ -0,0 +1,21 @@ +#pragma once + +#include "IVideoFeed.hpp" + +#include + +class SmpteBarsFeed : public IVideoFeed +{ +public: + SmpteBarsFeed( + uint32_t frameWidth, + uint32_t frameHeight); + + const VideoFrame& getFrame(uint32_t frameCounter) override; + FeedRuntimeStatus status() const override; + std::string displayName() const override; + uint64_t frameVersion() const override { return 1; } + +private: + VideoFrame frame; +}; diff --git a/Swapchain.cpp b/Swapchain.cpp new file mode 100644 index 0000000..d94f7e4 --- /dev/null +++ b/Swapchain.cpp @@ -0,0 +1,327 @@ +#include "Swapchain.hpp" + +#include +#include +#include + +namespace +{ +const char* presentModeName(VkPresentModeKHR mode) +{ + switch (mode) + { + case VK_PRESENT_MODE_FIFO_KHR: + return "fifo"; + + case VK_PRESENT_MODE_MAILBOX_KHR: + return "mailbox"; + + case VK_PRESENT_MODE_IMMEDIATE_KHR: + return "immediate"; + + default: + return "other"; + } +} +} + +Swapchain::Swapchain( + VkDevice device, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkRenderPass renderPass, + VkPresentModeKHR preferredPresentMode, + uint32_t windowWidth, + uint32_t windowHeight) + : m_device(device) + , m_physicalDevice(physicalDevice) + , m_surface(surface) + , m_preferredPresentMode(preferredPresentMode) +{ + createSwapchain(windowWidth, windowHeight); + createImageViews(); + createFramebuffers(renderPass); + + std::cout << "Swapchain created (" + << m_imageCount << " images)" + << std::endl; +} + +Swapchain::~Swapchain() +{ + destroy(); +} + +void Swapchain::recreate( + VkRenderPass renderPass, + uint32_t windowWidth, + uint32_t windowHeight) +{ + destroy(); + createSwapchain(windowWidth, windowHeight); + createImageViews(); + createFramebuffers(renderPass); + + std::cout << "Swapchain recreated (" + << m_imageCount << " images)" + << std::endl; +} + +void Swapchain::createSwapchain( + uint32_t windowWidth, + uint32_t windowHeight) +{ + SwapchainSupportDetails support = + querySwapchainSupport( + m_physicalDevice, + m_surface + ); + + m_surfaceFormat = support.formats[0]; + + for (const auto& availableFormat : + support.formats) + { + if (availableFormat.format == + VK_FORMAT_B8G8R8A8_SRGB && + availableFormat.colorSpace == + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) + { + m_surfaceFormat = availableFormat; + break; + } + } + + m_presentMode = VK_PRESENT_MODE_FIFO_KHR; + + for (const auto& availablePresentMode : + support.presentModes) + { + if (availablePresentMode == m_preferredPresentMode) + { + m_presentMode = availablePresentMode; + break; + } + } + + m_extent.width = windowWidth; + m_extent.height = windowHeight; + + m_imageCount = + support.capabilities.minImageCount + 1; + + if (support.capabilities.maxImageCount > 0 && + m_imageCount > + support.capabilities.maxImageCount) + { + m_imageCount = + support.capabilities.maxImageCount; + } + + VkSwapchainCreateInfoKHR swapchainInfo{}; + swapchainInfo.sType = + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + swapchainInfo.surface = m_surface; + swapchainInfo.minImageCount = m_imageCount; + swapchainInfo.imageFormat = + m_surfaceFormat.format; + swapchainInfo.imageColorSpace = + m_surfaceFormat.colorSpace; + swapchainInfo.imageExtent = m_extent; + swapchainInfo.imageArrayLayers = 1; + swapchainInfo.imageUsage = + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + + QueueFamilyIndices indices = + findQueueFamilies( + m_physicalDevice, + m_surface + ); + + uint32_t queueFamilyIndices[] = + { + *indices.graphicsFamily, + *indices.presentFamily + }; + + if (*indices.graphicsFamily != + *indices.presentFamily) + { + swapchainInfo.imageSharingMode = + VK_SHARING_MODE_CONCURRENT; + swapchainInfo.queueFamilyIndexCount = 2; + swapchainInfo.pQueueFamilyIndices = + queueFamilyIndices; + } + else + { + swapchainInfo.imageSharingMode = + VK_SHARING_MODE_EXCLUSIVE; + } + + swapchainInfo.preTransform = + support.capabilities.currentTransform; + swapchainInfo.compositeAlpha = + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; + swapchainInfo.presentMode = m_presentMode; + swapchainInfo.clipped = VK_TRUE; + + if (vkCreateSwapchainKHR( + m_device, + &swapchainInfo, + nullptr, + &m_swapchain) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create swapchain" + ); + } + + vkGetSwapchainImagesKHR( + m_device, + m_swapchain, + &m_imageCount, + nullptr + ); + + m_swapchainImages.resize(m_imageCount); + + vkGetSwapchainImagesKHR( + m_device, + m_swapchain, + &m_imageCount, + m_swapchainImages.data() + ); + + std::cout << "Present mode: " + << presentModeName(m_presentMode) + << std::endl; +} + +void Swapchain::createImageViews() +{ + m_imageViews.resize(m_swapchainImages.size()); + + for (size_t i = 0; + i < m_swapchainImages.size(); + ++i) + { + VkImageViewCreateInfo viewInfo{}; + viewInfo.sType = + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + viewInfo.image = m_swapchainImages[i]; + viewInfo.viewType = + VK_IMAGE_VIEW_TYPE_2D; + viewInfo.format = + m_surfaceFormat.format; + viewInfo.components.r = + VK_COMPONENT_SWIZZLE_IDENTITY; + viewInfo.components.g = + VK_COMPONENT_SWIZZLE_IDENTITY; + viewInfo.components.b = + VK_COMPONENT_SWIZZLE_IDENTITY; + viewInfo.components.a = + VK_COMPONENT_SWIZZLE_IDENTITY; + viewInfo.subresourceRange.aspectMask = + VK_IMAGE_ASPECT_COLOR_BIT; + viewInfo.subresourceRange.baseMipLevel = 0; + viewInfo.subresourceRange.levelCount = 1; + viewInfo.subresourceRange.baseArrayLayer = 0; + viewInfo.subresourceRange.layerCount = 1; + + if (vkCreateImageView( + m_device, + &viewInfo, + nullptr, + &m_imageViews[i]) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create image view" + ); + } + } + + std::cout << "Image views created" + << std::endl; +} + +void Swapchain::createFramebuffers( + VkRenderPass renderPass) +{ + m_framebuffers.resize(m_imageViews.size()); + + for (size_t i = 0; + i < m_imageViews.size(); + ++i) + { + VkImageView attachments[] = + { + m_imageViews[i] + }; + + VkFramebufferCreateInfo fbInfo{}; + fbInfo.sType = + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO; + fbInfo.renderPass = renderPass; + fbInfo.attachmentCount = 1; + fbInfo.pAttachments = attachments; + fbInfo.width = m_extent.width; + fbInfo.height = m_extent.height; + fbInfo.layers = 1; + + if (vkCreateFramebuffer( + m_device, + &fbInfo, + nullptr, + &m_framebuffers[i]) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create framebuffer" + ); + } + } + + std::cout << "Framebuffers created" + << std::endl; +} + +void Swapchain::destroy() +{ + if (m_swapchain == VK_NULL_HANDLE) + { + return; + } + + for (VkFramebuffer fb : m_framebuffers) + { + vkDestroyFramebuffer( + m_device, + fb, + nullptr + ); + } + m_framebuffers.clear(); + + for (VkImageView view : m_imageViews) + { + vkDestroyImageView( + m_device, + view, + nullptr + ); + } + m_imageViews.clear(); + m_swapchainImages.clear(); + + vkDestroySwapchainKHR( + m_device, + m_swapchain, + nullptr + ); + m_swapchain = VK_NULL_HANDLE; +} + +void Swapchain::release() +{ + destroy(); +} diff --git a/Swapchain.hpp b/Swapchain.hpp new file mode 100644 index 0000000..57abd2f --- /dev/null +++ b/Swapchain.hpp @@ -0,0 +1,67 @@ +#pragma once + +#include "VulkanContext.hpp" + +#include + +#include +#include + +class Swapchain +{ +public: + Swapchain( + VkDevice device, + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkRenderPass renderPass, + VkPresentModeKHR preferredPresentMode, + uint32_t windowWidth, + uint32_t windowHeight); + + ~Swapchain(); + + Swapchain(const Swapchain&) = delete; + Swapchain& operator=(const Swapchain&) = delete; + + void recreate( + VkRenderPass renderPass, + uint32_t windowWidth, + uint32_t windowHeight); + + VkSwapchainKHR handle() const { return m_swapchain; } + VkExtent2D extent() const { return m_extent; } + VkFormat imageFormat() const { return m_surfaceFormat.format; } + uint32_t imageCount() const { return m_imageCount; } + + const std::vector& imageViews() const { return m_imageViews; } + const std::vector& framebuffers() const { return m_framebuffers; } + + void release(); + +private: + void createSwapchain( + uint32_t windowWidth, + uint32_t windowHeight); + void createImageViews(); + void createFramebuffers( + VkRenderPass renderPass); + void destroy(); + + VkDevice m_device; + VkPhysicalDevice m_physicalDevice; + VkSurfaceKHR m_surface; + + VkSwapchainKHR m_swapchain = VK_NULL_HANDLE; + VkPresentModeKHR m_preferredPresentMode = + VK_PRESENT_MODE_FIFO_KHR; + VkExtent2D m_extent{}; + VkSurfaceFormatKHR m_surfaceFormat{}; + VkPresentModeKHR m_presentMode = + VK_PRESENT_MODE_FIFO_KHR; + uint32_t m_imageCount = 0; + + std::vector m_swapchainImages; + std::vector m_imageViews; + std::vector m_framebuffers; +}; diff --git a/TileLayout.cpp b/TileLayout.cpp new file mode 100644 index 0000000..0c9b0be --- /dev/null +++ b/TileLayout.cpp @@ -0,0 +1,121 @@ +#include "TileLayout.hpp" + +#include +#include + +namespace +{ +std::vector makeQuad( + float x0, + float y0, + float x1, + float y1) +{ + return { + {{x0, y0}, {0.0f, 0.0f}}, + {{x1, y0}, {1.0f, 0.0f}}, + {{x1, y1}, {1.0f, 1.0f}}, + + {{x0, y0}, {0.0f, 0.0f}}, + {{x1, y1}, {1.0f, 1.0f}}, + {{x0, y1}, {0.0f, 1.0f}}, + }; +} +} + +std::vector makeGridLayout( + uint32_t cols, + uint32_t rows, + float gapX, + float gapY) +{ + std::vector vertices; + vertices.reserve( + static_cast(cols) * rows * 6); + + const float tileW = + (2.0f - gapX * static_cast(cols - 1)) / + static_cast(cols); + const float tileH = + (2.0f - gapY * static_cast(rows - 1)) / + static_cast(rows); + + for (uint32_t row = 0; row < rows; ++row) + { + for (uint32_t col = 0; col < cols; ++col) + { + const float x0 = + -1.0f + + static_cast(col) * (tileW + gapX); + const float y0 = + -1.0f + + static_cast(row) * (tileH + gapY); + const float x1 = x0 + tileW; + const float y1 = y0 + tileH; + + auto quad = makeQuad(x0, y0, x1, y1); + vertices.insert( + vertices.end(), + quad.begin(), + quad.end()); + } + } + + return vertices; +} + +void updateGridLayout( + Vertex* vertices, + uint32_t cols, + uint32_t rows, + float gapX, + float gapY) +{ + std::vector updated = + makeGridLayout(cols, rows, gapX, gapY); + + std::copy( + updated.begin(), + updated.end(), + vertices + ); +} + +void updateUvForAspectRatio( + Vertex* vertices, + uint32_t quadIndex, + float srcAspect, + float tileAspect) +{ + Vertex* quad = vertices + quadIndex * 6; + + float uMin = 0.0f; + float uMax = 1.0f; + float vMin = 0.0f; + float vMax = 1.0f; + + if (srcAspect > tileAspect) + { + float scale = tileAspect / srcAspect; + float bar = (1.0f - scale) * 0.5f; + vMin = bar; + vMax = 1.0f - bar; + } + else if (srcAspect < tileAspect) + { + float scale = srcAspect / tileAspect; + float bar = (1.0f - scale) * 0.5f; + uMin = bar; + uMax = 1.0f - bar; + } + + // Triangle 1: vertices 0-2 + quad[0].uv[0] = uMin; quad[0].uv[1] = vMin; + quad[1].uv[0] = uMax; quad[1].uv[1] = vMin; + quad[2].uv[0] = uMax; quad[2].uv[1] = vMax; + + // Triangle 2: vertices 3-5 + quad[3].uv[0] = uMin; quad[3].uv[1] = vMin; + quad[4].uv[0] = uMax; quad[4].uv[1] = vMax; + quad[5].uv[0] = uMin; quad[5].uv[1] = vMax; +} diff --git a/TileLayout.hpp b/TileLayout.hpp new file mode 100644 index 0000000..8c10674 --- /dev/null +++ b/TileLayout.hpp @@ -0,0 +1,29 @@ +#pragma once + +#include +#include + +struct Vertex +{ + float pos[2]; + float uv[2]; +}; + +std::vector makeGridLayout( + uint32_t cols, + uint32_t rows, + float gapX, + float gapY); + +void updateGridLayout( + Vertex* vertices, + uint32_t cols, + uint32_t rows, + float gapX, + float gapY); + +void updateUvForAspectRatio( + Vertex* vertices, + uint32_t quadIndex, + float srcAspect, + float tileAspect); diff --git a/V210ComputeDecoder.cpp b/V210ComputeDecoder.cpp new file mode 100644 index 0000000..4a0b73b --- /dev/null +++ b/V210ComputeDecoder.cpp @@ -0,0 +1,451 @@ +#include "V210ComputeDecoder.hpp" +#include "VulkanUtils.hpp" + +#include +#include +#include + +namespace +{ + std::vector readFile(const std::string& path) + { + std::ifstream file(path, std::ios::ate | std::ios::binary); + + if (!file.is_open()) + { + throw std::runtime_error( + "Failed to open shader file: " + path); + } + + size_t fileSize = static_cast(file.tellg()); + std::vector buffer(fileSize); + file.seekg(0); + file.read(buffer.data(), static_cast(fileSize)); + file.close(); + + return buffer; + } + + VkShaderModule createShaderModule( + VkDevice device, + const std::vector& code) + { + VkShaderModuleCreateInfo createInfo{}; + createInfo.sType = + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + createInfo.codeSize = code.size(); + createInfo.pCode = reinterpret_cast( + code.data()); + + VkShaderModule shaderModule; + + if (vkCreateShaderModule( + device, + &createInfo, + nullptr, + &shaderModule) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create shader module"); + } + + return shaderModule; + } +} + +void V210ComputeDecoder::init( + VkDevice device, + uint32_t feedCount, + uint32_t dstWidth, + uint32_t dstHeight) +{ + m_device = device; + m_dstWidth = dstWidth; + m_dstHeight = dstHeight; + + std::vector bindings(2); + + bindings[0].binding = 0; + bindings[0].descriptorType = + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + bindings[0].descriptorCount = 1; + bindings[0].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + bindings[0].pImmutableSamplers = nullptr; + + bindings[1].binding = 1; + bindings[1].descriptorType = + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + bindings[1].descriptorCount = 1; + bindings[1].stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + bindings[1].pImmutableSamplers = nullptr; + + VkDescriptorSetLayoutCreateInfo layoutInfo{}; + layoutInfo.sType = + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO; + layoutInfo.bindingCount = + static_cast(bindings.size()); + layoutInfo.pBindings = bindings.data(); + + if (vkCreateDescriptorSetLayout( + device, + &layoutInfo, + nullptr, + &m_descriptorSetLayout) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create v210 descriptor set layout"); + } + + std::vector shaderCode = + readFile("../shaders/bin/v210_decode.comp.spv"); + + VkShaderModule shaderModule = + createShaderModule(device, shaderCode); + + VkPushConstantRange pushRange{}; + pushRange.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT; + pushRange.offset = 0; + pushRange.size = 5 * sizeof(uint32_t); + + VkPipelineLayoutCreateInfo pipelineLayoutInfo{}; + pipelineLayoutInfo.sType = + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO; + pipelineLayoutInfo.setLayoutCount = 1; + pipelineLayoutInfo.pSetLayouts = + &m_descriptorSetLayout; + pipelineLayoutInfo.pushConstantRangeCount = 1; + pipelineLayoutInfo.pPushConstantRanges = &pushRange; + + if (vkCreatePipelineLayout( + device, + &pipelineLayoutInfo, + nullptr, + &m_pipelineLayout) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create v210 pipeline layout"); + } + + VkComputePipelineCreateInfo pipelineInfo{}; + pipelineInfo.sType = + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO; + pipelineInfo.stage.sType = + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO; + pipelineInfo.stage.stage = VK_SHADER_STAGE_COMPUTE_BIT; + pipelineInfo.stage.module = shaderModule; + pipelineInfo.stage.pName = "main"; + pipelineInfo.layout = m_pipelineLayout; + + if (vkCreateComputePipelines( + device, + VK_NULL_HANDLE, + 1, + &pipelineInfo, + nullptr, + &m_pipeline) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create v210 compute pipeline"); + } + + vkDestroyShaderModule(device, shaderModule, nullptr); + + VkDescriptorPoolSize poolSizes[2]; + poolSizes[0].type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + poolSizes[0].descriptorCount = feedCount; + poolSizes[1].type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + poolSizes[1].descriptorCount = feedCount; + + VkDescriptorPoolCreateInfo poolInfo{}; + poolInfo.sType = + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO; + poolInfo.poolSizeCount = 2; + poolInfo.pPoolSizes = poolSizes; + poolInfo.maxSets = feedCount; + + if (vkCreateDescriptorPool( + device, + &poolInfo, + nullptr, + &m_descriptorPool) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create v210 descriptor pool"); + } + + std::vector layouts( + feedCount, m_descriptorSetLayout); + + VkDescriptorSetAllocateInfo allocInfo{}; + allocInfo.sType = + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO; + allocInfo.descriptorPool = m_descriptorPool; + allocInfo.descriptorSetCount = feedCount; + allocInfo.pSetLayouts = layouts.data(); + + m_descSets.resize(feedCount); + + if (vkAllocateDescriptorSets( + device, + &allocInfo, + m_descSets.data()) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to allocate v210 descriptor sets"); + } +} + +void V210ComputeDecoder::destroy() +{ + if (m_device == VK_NULL_HANDLE) return; + + vkDestroyPipeline(m_device, m_pipeline, nullptr); + vkDestroyPipelineLayout(m_device, m_pipelineLayout, nullptr); + vkDestroyDescriptorSetLayout( + m_device, m_descriptorSetLayout, nullptr); + vkDestroyDescriptorPool(m_device, m_descriptorPool, nullptr); +} + +void V210ComputeDecoder::createFeedResources( + VkPhysicalDevice physicalDevice, + VkCommandPool commandPool, + VkQueue graphicsQueue, + uint32_t feedIndex, + uint32_t srcWidth, + uint32_t srcHeight, + uint32_t srcStride, + uint32_t dstWidth, + uint32_t dstHeight, + V210ComputeFeed& feed) +{ + feed.srcWidth = srcWidth; + feed.srcHeight = srcHeight; + feed.srcStride = srcStride; + + VkDeviceSize v210Size = static_cast(srcStride) * srcHeight; + + createBuffer( + m_device, + physicalDevice, + v210Size, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT, + feed.v210Buffer, + feed.v210BufferMemory); + + if (vkMapMemory( + m_device, + feed.v210BufferMemory, + 0, + v210Size, + 0, + &feed.v210MappedData) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to map v210 buffer memory"); + } + + createImage( + m_device, + physicalDevice, + dstWidth, + dstHeight, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_STORAGE_BIT | + VK_IMAGE_USAGE_SAMPLED_BIT, + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, + feed.image, + feed.imageMemory); + + transitionImageLayout( + m_device, + commandPool, + graphicsQueue, + feed.image, + VK_FORMAT_R8G8B8A8_UNORM, + VK_IMAGE_LAYOUT_UNDEFINED, + VK_IMAGE_LAYOUT_GENERAL); + + VkImageViewCreateInfo viewInfo{}; + viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + viewInfo.image = feed.image; + viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + viewInfo.format = VK_FORMAT_R8G8B8A8_UNORM; + viewInfo.subresourceRange.aspectMask = + VK_IMAGE_ASPECT_COLOR_BIT; + viewInfo.subresourceRange.baseMipLevel = 0; + viewInfo.subresourceRange.levelCount = 1; + viewInfo.subresourceRange.baseArrayLayer = 0; + viewInfo.subresourceRange.layerCount = 1; + + if (vkCreateImageView( + m_device, + &viewInfo, + nullptr, + &feed.imageView) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create v210 output image view"); + } + + VkSamplerCreateInfo samplerInfo{}; + samplerInfo.sType = + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO; + samplerInfo.magFilter = VK_FILTER_LINEAR; + samplerInfo.minFilter = VK_FILTER_LINEAR; + samplerInfo.addressModeU = + VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeV = + VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.addressModeW = + VK_SAMPLER_ADDRESS_MODE_REPEAT; + samplerInfo.anisotropyEnable = VK_FALSE; + samplerInfo.borderColor = + VK_BORDER_COLOR_INT_OPAQUE_BLACK; + samplerInfo.unnormalizedCoordinates = VK_FALSE; + samplerInfo.compareEnable = VK_FALSE; + samplerInfo.mipmapMode = + VK_SAMPLER_MIPMAP_MODE_LINEAR; + + if (vkCreateSampler( + m_device, + &samplerInfo, + nullptr, + &feed.sampler) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create v210 output sampler"); + } + + feed.descriptorSet = m_descSets[feedIndex]; + + VkDescriptorBufferInfo bufferInfo{}; + bufferInfo.buffer = feed.v210Buffer; + bufferInfo.offset = 0; + bufferInfo.range = v210Size; + + VkDescriptorImageInfo imageInfo{}; + imageInfo.imageLayout = VK_IMAGE_LAYOUT_GENERAL; + imageInfo.imageView = feed.imageView; + + VkWriteDescriptorSet writes[2]; + + writes[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + writes[0].dstSet = feed.descriptorSet; + writes[0].dstBinding = 0; + writes[0].dstArrayElement = 0; + writes[0].descriptorCount = 1; + writes[0].descriptorType = + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; + writes[0].pBufferInfo = &bufferInfo; + writes[0].pImageInfo = nullptr; + writes[0].pTexelBufferView = nullptr; + + writes[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET; + writes[1].dstSet = feed.descriptorSet; + writes[1].dstBinding = 1; + writes[1].dstArrayElement = 0; + writes[1].descriptorCount = 1; + writes[1].descriptorType = + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; + writes[1].pBufferInfo = nullptr; + writes[1].pImageInfo = &imageInfo; + writes[1].pTexelBufferView = nullptr; + + vkUpdateDescriptorSets( + m_device, 2, writes, 0, nullptr); +} + +void V210ComputeDecoder::destroyFeedResources( + V210ComputeFeed& feed) +{ + if (m_device == VK_NULL_HANDLE) return; + + vkDestroySampler(m_device, feed.sampler, nullptr); + vkDestroyImageView(m_device, feed.imageView, nullptr); + vkDestroyImage(m_device, feed.image, nullptr); + vkFreeMemory(m_device, feed.imageMemory, nullptr); + + vkUnmapMemory(m_device, feed.v210BufferMemory); + vkDestroyBuffer(m_device, feed.v210Buffer, nullptr); + vkFreeMemory(m_device, feed.v210BufferMemory, nullptr); +} + +void V210ComputeDecoder::recordDecode( + VkCommandBuffer cmdBuf, + uint32_t feedIndex, + uint32_t srcWidth, + uint32_t srcHeight, + uint32_t srcStrideBytes, + uint32_t dstWidth, + uint32_t dstHeight) const +{ + vkCmdBindPipeline( + cmdBuf, + VK_PIPELINE_BIND_POINT_COMPUTE, + m_pipeline); + + vkCmdBindDescriptorSets( + cmdBuf, + VK_PIPELINE_BIND_POINT_COMPUTE, + m_pipelineLayout, + 0, + 1, + &m_descSets[feedIndex], + 0, + nullptr); + + uint32_t pushConstants[5]; + pushConstants[0] = srcWidth; + pushConstants[1] = srcHeight; + pushConstants[2] = srcStrideBytes; + pushConstants[3] = dstWidth; + pushConstants[4] = dstHeight; + + vkCmdPushConstants( + cmdBuf, + m_pipelineLayout, + VK_SHADER_STAGE_COMPUTE_BIT, + 0, + sizeof(pushConstants), + pushConstants); + + uint32_t groupCountX = (dstWidth + 15) / 16; + uint32_t groupCountY = (dstHeight + 15) / 16; + + vkCmdDispatch(cmdBuf, groupCountX, groupCountY, 1); +} + +void V210ComputeDecoder::recordOutputReadyForSampling( + VkCommandBuffer cmdBuf, + const V210ComputeFeed& feed) const +{ + VkImageMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT; + barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + barrier.oldLayout = VK_IMAGE_LAYOUT_GENERAL; + barrier.newLayout = VK_IMAGE_LAYOUT_GENERAL; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = feed.image; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = 1; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = 1; + + vkCmdPipelineBarrier( + cmdBuf, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &barrier); +} diff --git a/V210ComputeDecoder.hpp b/V210ComputeDecoder.hpp new file mode 100644 index 0000000..5fcad91 --- /dev/null +++ b/V210ComputeDecoder.hpp @@ -0,0 +1,78 @@ +#pragma once + +#include + +#include +#include + +struct V210ComputeFeed +{ + VkBuffer v210Buffer = VK_NULL_HANDLE; + VkDeviceMemory v210BufferMemory = VK_NULL_HANDLE; + void* v210MappedData = nullptr; + + VkImage image = VK_NULL_HANDLE; + VkDeviceMemory imageMemory = VK_NULL_HANDLE; + VkImageView imageView = VK_NULL_HANDLE; + VkSampler sampler = VK_NULL_HANDLE; + + VkDescriptorSet descriptorSet = VK_NULL_HANDLE; + + uint32_t srcWidth = 0; + uint32_t srcHeight = 0; + uint32_t srcStride = 0; +}; + +class V210ComputeDecoder +{ +public: + void init( + VkDevice device, + uint32_t feedCount, + uint32_t dstWidth, + uint32_t dstHeight); + + void destroy(); + + void createFeedResources( + VkPhysicalDevice physicalDevice, + VkCommandPool commandPool, + VkQueue graphicsQueue, + uint32_t feedIndex, + uint32_t srcWidth, + uint32_t srcHeight, + uint32_t srcStride, + uint32_t dstWidth, + uint32_t dstHeight, + V210ComputeFeed& feed); + + void destroyFeedResources(V210ComputeFeed& feed); + + void updateDescriptorSet( + uint32_t feedIndex, + const V210ComputeFeed& feed); + + void recordDecode( + VkCommandBuffer cmdBuf, + uint32_t feedIndex, + uint32_t srcWidth, + uint32_t srcHeight, + uint32_t srcStride, + uint32_t dstWidth, + uint32_t dstHeight) const; + + void recordOutputReadyForSampling( + VkCommandBuffer cmdBuf, + const V210ComputeFeed& feed) const; + +private: + VkDevice m_device = VK_NULL_HANDLE; + VkDescriptorSetLayout m_descriptorSetLayout = VK_NULL_HANDLE; + VkPipelineLayout m_pipelineLayout = VK_NULL_HANDLE; + VkPipeline m_pipeline = VK_NULL_HANDLE; + VkDescriptorPool m_descriptorPool = VK_NULL_HANDLE; + uint32_t m_dstWidth = 0; + uint32_t m_dstHeight = 0; + + std::vector m_descSets; +}; diff --git a/VideoFrame.hpp b/VideoFrame.hpp new file mode 100644 index 0000000..f1b9654 --- /dev/null +++ b/VideoFrame.hpp @@ -0,0 +1,11 @@ +#pragma once + +#include +#include + +struct VideoFrame +{ + uint32_t width = 0; + uint32_t height = 0; + std::vector pixels; +}; diff --git a/VulkanContext.cpp b/VulkanContext.cpp new file mode 100644 index 0000000..b6af7b3 --- /dev/null +++ b/VulkanContext.cpp @@ -0,0 +1,413 @@ +#include "VulkanContext.hpp" + +#include +#include + +#include + +QueueFamilyIndices findQueueFamilies( + VkPhysicalDevice device, + VkSurfaceKHR surface) +{ + QueueFamilyIndices indices; + + uint32_t queueFamilyCount = 0; + vkGetPhysicalDeviceQueueFamilyProperties( + device, + &queueFamilyCount, + nullptr + ); + + std::vector queueFamilies( + queueFamilyCount + ); + + vkGetPhysicalDeviceQueueFamilyProperties( + device, + &queueFamilyCount, + queueFamilies.data() + ); + + for (uint32_t i = 0; i < queueFamilyCount; ++i) + { + if (queueFamilies[i].queueFlags & + VK_QUEUE_GRAPHICS_BIT) + { + indices.graphicsFamily = i; + } + + VkBool32 presentSupport = VK_FALSE; + vkGetPhysicalDeviceSurfaceSupportKHR( + device, + i, + surface, + &presentSupport + ); + + if (presentSupport) + { + indices.presentFamily = i; + } + + if (indices.isComplete()) + { + break; + } + } + + return indices; +} + +SwapchainSupportDetails querySwapchainSupport( + VkPhysicalDevice device, + VkSurfaceKHR surface) +{ + SwapchainSupportDetails details; + + vkGetPhysicalDeviceSurfaceCapabilitiesKHR( + device, + surface, + &details.capabilities + ); + + uint32_t formatCount; + vkGetPhysicalDeviceSurfaceFormatsKHR( + device, + surface, + &formatCount, + nullptr + ); + + if (formatCount != 0) + { + details.formats.resize(formatCount); + vkGetPhysicalDeviceSurfaceFormatsKHR( + device, + surface, + &formatCount, + details.formats.data() + ); + } + + uint32_t presentModeCount; + vkGetPhysicalDeviceSurfacePresentModesKHR( + device, + surface, + &presentModeCount, + nullptr + ); + + if (presentModeCount != 0) + { + details.presentModes.resize(presentModeCount); + vkGetPhysicalDeviceSurfacePresentModesKHR( + device, + surface, + &presentModeCount, + details.presentModes.data() + ); + } + + return details; +} + +VulkanContext::VulkanContext( + SDL_Window* window, + const char* appName, + uint32_t versionMajor, + uint32_t versionMinor, + uint32_t versionPatch) +{ + uint32_t extensionCount = 0; + const char* const* extensions = + SDL_Vulkan_GetInstanceExtensions( + &extensionCount + ); + + VkApplicationInfo appInfo{}; + appInfo.sType = + VK_STRUCTURE_TYPE_APPLICATION_INFO; + appInfo.pApplicationName = appName; + appInfo.applicationVersion = + VK_MAKE_VERSION( + versionMajor, + versionMinor, + versionPatch + ); + appInfo.apiVersion = VK_API_VERSION_1_3; + + VkInstanceCreateInfo createInfo{}; + createInfo.sType = + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + createInfo.pApplicationInfo = &appInfo; + createInfo.enabledExtensionCount = + extensionCount; + createInfo.ppEnabledExtensionNames = + extensions; + + if (vkCreateInstance( + &createInfo, + nullptr, + &m_instance) != VK_SUCCESS) + { + throw std::runtime_error( + "Failed to create Vulkan instance" + ); + } + + if (!SDL_Vulkan_CreateSurface( + window, + m_instance, + nullptr, + &m_surface)) + { + vkDestroyInstance(m_instance, nullptr); + throw std::runtime_error( + "Failed to create Vulkan surface" + ); + } + + uint32_t gpuCount = 0; + vkEnumeratePhysicalDevices( + m_instance, + &gpuCount, + nullptr + ); + + if (gpuCount == 0) + { + vkDestroySurfaceKHR( + m_instance, + m_surface, + nullptr + ); + vkDestroyInstance(m_instance, nullptr); + throw std::runtime_error( + "No Vulkan GPUs found" + ); + } + + std::vector gpus(gpuCount); + vkEnumeratePhysicalDevices( + m_instance, + &gpuCount, + gpus.data() + ); + + for (const auto& gpu : gpus) + { + QueueFamilyIndices testIndices = + findQueueFamilies(gpu, m_surface); + + if (testIndices.isComplete()) + { + m_physicalDevice = gpu; + m_queueIndices = testIndices; + break; + } + } + + if (m_physicalDevice == VK_NULL_HANDLE) + { + vkDestroySurfaceKHR( + m_instance, + m_surface, + nullptr + ); + vkDestroyInstance(m_instance, nullptr); + throw std::runtime_error( + "No suitable GPU found" + ); + } + + VkPhysicalDeviceProperties props{}; + vkGetPhysicalDeviceProperties( + m_physicalDevice, + &props + ); + + std::cout << "Selected GPU: " + << props.deviceName + << std::endl; + + float queuePriority = 1.0f; + std::vector + queueCreateInfos; + std::vector uniqueQueues; + + uniqueQueues.push_back( + *m_queueIndices.graphicsFamily + ); + + if (*m_queueIndices.presentFamily != + *m_queueIndices.graphicsFamily) + { + uniqueQueues.push_back( + *m_queueIndices.presentFamily + ); + } + + for (uint32_t queueFamily : uniqueQueues) + { + VkDeviceQueueCreateInfo queueInfo{}; + queueInfo.sType = + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queueInfo.queueFamilyIndex = queueFamily; + queueInfo.queueCount = 1; + queueInfo.pQueuePriorities = &queuePriority; + queueCreateInfos.push_back(queueInfo); + } + + const std::vector + deviceExtensions = + { + VK_KHR_SWAPCHAIN_EXTENSION_NAME + }; + + VkPhysicalDeviceFeatures deviceFeatures{}; + + VkDeviceCreateInfo deviceInfo{}; + deviceInfo.sType = + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + deviceInfo.queueCreateInfoCount = + static_cast( + queueCreateInfos.size() + ); + deviceInfo.pQueueCreateInfos = + queueCreateInfos.data(); + deviceInfo.enabledExtensionCount = + static_cast( + deviceExtensions.size() + ); + deviceInfo.ppEnabledExtensionNames = + deviceExtensions.data(); + deviceInfo.pEnabledFeatures = &deviceFeatures; + + if (vkCreateDevice( + m_physicalDevice, + &deviceInfo, + nullptr, + &m_device) != VK_SUCCESS) + { + vkDestroySurfaceKHR( + m_instance, + m_surface, + nullptr + ); + vkDestroyInstance(m_instance, nullptr); + throw std::runtime_error( + "Failed to create logical device" + ); + } + + std::cout << "Graphics queue: " + << *m_queueIndices.graphicsFamily + << std::endl; + std::cout << "Present queue: " + << *m_queueIndices.presentFamily + << std::endl; + + vkGetDeviceQueue( + m_device, + *m_queueIndices.graphicsFamily, + 0, + &m_graphicsQueue + ); + + vkGetDeviceQueue( + m_device, + *m_queueIndices.presentFamily, + 0, + &m_presentQueue + ); + + VkCommandPoolCreateInfo poolInfo{}; + poolInfo.sType = + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + poolInfo.flags = + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT; + poolInfo.queueFamilyIndex = + *m_queueIndices.graphicsFamily; + + if (vkCreateCommandPool( + m_device, + &poolInfo, + nullptr, + &m_commandPool) != VK_SUCCESS) + { + vkDestroyDevice(m_device, nullptr); + vkDestroySurfaceKHR( + m_instance, + m_surface, + nullptr + ); + vkDestroyInstance(m_instance, nullptr); + throw std::runtime_error( + "Failed to create command pool" + ); + } + + std::cout << "Vulkan context created" + << std::endl; +} + +VulkanContext::~VulkanContext() +{ + if (m_device != VK_NULL_HANDLE) + { + vkDestroyCommandPool( + m_device, + m_commandPool, + nullptr + ); + vkDestroyDevice(m_device, nullptr); + m_device = VK_NULL_HANDLE; + } + + if (m_surface != VK_NULL_HANDLE) + { + vkDestroySurfaceKHR( + m_instance, + m_surface, + nullptr + ); + m_surface = VK_NULL_HANDLE; + } + + if (m_instance != VK_NULL_HANDLE) + { + vkDestroyInstance(m_instance, nullptr); + m_instance = VK_NULL_HANDLE; + } +} + +void VulkanContext::release() +{ + if (m_device != VK_NULL_HANDLE) + { + vkDeviceWaitIdle(m_device); + vkDestroyCommandPool( + m_device, + m_commandPool, + nullptr + ); + vkDestroyDevice(m_device, nullptr); + m_device = VK_NULL_HANDLE; + } + + if (m_surface != VK_NULL_HANDLE) + { + vkDestroySurfaceKHR( + m_instance, + m_surface, + nullptr + ); + m_surface = VK_NULL_HANDLE; + } + + if (m_instance != VK_NULL_HANDLE) + { + vkDestroyInstance(m_instance, nullptr); + m_instance = VK_NULL_HANDLE; + } +} diff --git a/VulkanContext.hpp b/VulkanContext.hpp new file mode 100644 index 0000000..81da548 --- /dev/null +++ b/VulkanContext.hpp @@ -0,0 +1,75 @@ +#pragma once + +#include + +#include +#include +#include +#include +#include + +struct SDL_Window; + +struct QueueFamilyIndices +{ + std::optional graphicsFamily; + std::optional presentFamily; + + bool isComplete() const + { + return graphicsFamily.has_value() && + presentFamily.has_value(); + } +}; + +struct SwapchainSupportDetails +{ + VkSurfaceCapabilitiesKHR capabilities; + std::vector formats; + std::vector presentModes; +}; + +QueueFamilyIndices findQueueFamilies( + VkPhysicalDevice device, + VkSurfaceKHR surface); + +SwapchainSupportDetails querySwapchainSupport( + VkPhysicalDevice device, + VkSurfaceKHR surface); + +class VulkanContext +{ +public: + VulkanContext( + SDL_Window* window, + const char* appName, + uint32_t versionMajor, + uint32_t versionMinor, + uint32_t versionPatch); + + ~VulkanContext(); + + VulkanContext(const VulkanContext&) = delete; + VulkanContext& operator=(const VulkanContext&) = delete; + + VkDevice device() const { return m_device; } + VkPhysicalDevice physicalDevice() const { return m_physicalDevice; } + VkInstance instance() const { return m_instance; } + VkSurfaceKHR surface() const { return m_surface; } + VkQueue graphicsQueue() const { return m_graphicsQueue; } + VkQueue presentQueue() const { return m_presentQueue; } + VkCommandPool commandPool() const { return m_commandPool; } + const QueueFamilyIndices& queueIndices() const { return m_queueIndices; } + + void release(); + +private: + VkInstance m_instance = VK_NULL_HANDLE; + VkSurfaceKHR m_surface = VK_NULL_HANDLE; + VkPhysicalDevice m_physicalDevice = VK_NULL_HANDLE; + VkDevice m_device = VK_NULL_HANDLE; + VkQueue m_graphicsQueue = VK_NULL_HANDLE; + VkQueue m_presentQueue = VK_NULL_HANDLE; + VkCommandPool m_commandPool = VK_NULL_HANDLE; + QueueFamilyIndices m_queueIndices; +}; diff --git a/VulkanUtils.cpp b/VulkanUtils.cpp new file mode 100644 index 0000000..a2b177c --- /dev/null +++ b/VulkanUtils.cpp @@ -0,0 +1,326 @@ +#include "VulkanUtils.hpp" + +#include + +uint32_t findMemoryType( + VkPhysicalDevice physicalDevice, + uint32_t typeFilter, + VkMemoryPropertyFlags properties) +{ + VkPhysicalDeviceMemoryProperties memProperties; + + vkGetPhysicalDeviceMemoryProperties( + physicalDevice, + &memProperties + ); + + for (uint32_t i = 0; i < memProperties.memoryTypeCount; ++i) + { + if ((typeFilter & (1 << i)) && + (memProperties.memoryTypes[i].propertyFlags & properties) == properties) + { + return i; + } + } + + throw std::runtime_error("Failed to find suitable memory type"); +} + +void createBuffer( + VkDevice device, + VkPhysicalDevice physicalDevice, + VkDeviceSize size, + VkBufferUsageFlags usage, + VkMemoryPropertyFlags properties, + VkBuffer& buffer, + VkDeviceMemory& bufferMemory) +{ + VkBufferCreateInfo bufferInfo{}; + bufferInfo.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; + bufferInfo.size = size; + bufferInfo.usage = usage; + bufferInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + if (vkCreateBuffer(device, &bufferInfo, nullptr, &buffer) != VK_SUCCESS) + { + throw std::runtime_error("Failed to create buffer"); + } + + VkMemoryRequirements memRequirements; + vkGetBufferMemoryRequirements(device, buffer, &memRequirements); + + VkMemoryAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocInfo.allocationSize = memRequirements.size; + allocInfo.memoryTypeIndex = findMemoryType( + physicalDevice, + memRequirements.memoryTypeBits, + properties + ); + + if (vkAllocateMemory(device, &allocInfo, nullptr, &bufferMemory) != VK_SUCCESS) + { + throw std::runtime_error("Failed to allocate buffer memory"); + } + + vkBindBufferMemory(device, buffer, bufferMemory, 0); +} + +VkCommandBuffer beginSingleTimeCommands( + VkDevice device, + VkCommandPool commandPool) +{ + VkCommandBufferAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY; + allocInfo.commandPool = commandPool; + allocInfo.commandBufferCount = 1; + + VkCommandBuffer commandBuffer; + vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer); + + VkCommandBufferBeginInfo beginInfo{}; + beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; + beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; + + vkBeginCommandBuffer(commandBuffer, &beginInfo); + + return commandBuffer; +} + +void endSingleTimeCommands( + VkDevice device, + VkCommandPool commandPool, + VkQueue graphicsQueue, + VkCommandBuffer commandBuffer) +{ + vkEndCommandBuffer(commandBuffer); + + VkSubmitInfo submitInfo{}; + submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; + submitInfo.commandBufferCount = 1; + submitInfo.pCommandBuffers = &commandBuffer; + + vkQueueSubmit(graphicsQueue, 1, &submitInfo, VK_NULL_HANDLE); + vkQueueWaitIdle(graphicsQueue); + + vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer); +} + +void createImage( + VkDevice device, + VkPhysicalDevice physicalDevice, + uint32_t width, + uint32_t height, + VkFormat format, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkMemoryPropertyFlags properties, + VkImage& image, + VkDeviceMemory& imageMemory) +{ + VkImageCreateInfo imageInfo{}; + imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO; + imageInfo.imageType = VK_IMAGE_TYPE_2D; + imageInfo.extent.width = width; + imageInfo.extent.height = height; + imageInfo.extent.depth = 1; + imageInfo.mipLevels = 1; + imageInfo.arrayLayers = 1; + imageInfo.format = format; + imageInfo.tiling = tiling; + imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; + imageInfo.usage = usage; + imageInfo.samples = VK_SAMPLE_COUNT_1_BIT; + imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE; + + if (vkCreateImage(device, &imageInfo, nullptr, &image) != VK_SUCCESS) + { + throw std::runtime_error("Failed to create image"); + } + + VkMemoryRequirements memRequirements; + vkGetImageMemoryRequirements(device, image, &memRequirements); + + VkMemoryAllocateInfo allocInfo{}; + allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; + allocInfo.allocationSize = memRequirements.size; + allocInfo.memoryTypeIndex = findMemoryType( + physicalDevice, + memRequirements.memoryTypeBits, + properties + ); + + if (vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory) != VK_SUCCESS) + { + throw std::runtime_error("Failed to allocate image memory"); + } + + vkBindImageMemory(device, image, imageMemory, 0); +} + +void recordImageLayoutTransition( + VkCommandBuffer commandBuffer, + VkImage image, + VkFormat format, + VkImageLayout oldLayout, + VkImageLayout newLayout) +{ + (void)format; + + VkImageMemoryBarrier barrier{}; + barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + barrier.oldLayout = oldLayout; + barrier.newLayout = newLayout; + barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED; + barrier.image = image; + barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + barrier.subresourceRange.baseMipLevel = 0; + barrier.subresourceRange.levelCount = 1; + barrier.subresourceRange.baseArrayLayer = 0; + barrier.subresourceRange.layerCount = 1; + + VkPipelineStageFlags sourceStage; + VkPipelineStageFlags destinationStage; + + if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && + newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) + { + barrier.srcAccessMask = 0; + barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + + sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; + destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + } + else if (oldLayout == VK_IMAGE_LAYOUT_UNDEFINED && + newLayout == VK_IMAGE_LAYOUT_GENERAL) + { + barrier.srcAccessMask = 0; + barrier.dstAccessMask = VK_ACCESS_SHADER_WRITE_BIT; + + sourceStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT; + destinationStage = VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; + } + else if (oldLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL && + newLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL) + { + barrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + barrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT; + + sourceStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + destinationStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + } + else if (oldLayout == VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL && + newLayout == VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL) + { + barrier.srcAccessMask = VK_ACCESS_SHADER_READ_BIT; + barrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT; + + sourceStage = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT; + destinationStage = VK_PIPELINE_STAGE_TRANSFER_BIT; + } + else + { + throw std::runtime_error("Unsupported layout transition"); + } + + vkCmdPipelineBarrier( + commandBuffer, + sourceStage, + destinationStage, + 0, + 0, + nullptr, + 0, + nullptr, + 1, + &barrier + ); +} + +void transitionImageLayout( + VkDevice device, + VkCommandPool commandPool, + VkQueue graphicsQueue, + VkImage image, + VkFormat format, + VkImageLayout oldLayout, + VkImageLayout newLayout) +{ + VkCommandBuffer commandBuffer = + beginSingleTimeCommands(device, commandPool); + + recordImageLayoutTransition( + commandBuffer, + image, + format, + oldLayout, + newLayout + ); + + endSingleTimeCommands( + device, + commandPool, + graphicsQueue, + commandBuffer + ); +} + +void recordCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkImage image, + uint32_t width, + uint32_t height) +{ + VkBufferImageCopy region{}; + region.bufferOffset = 0; + region.bufferRowLength = 0; + region.bufferImageHeight = 0; + + region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + region.imageSubresource.mipLevel = 0; + region.imageSubresource.baseArrayLayer = 0; + region.imageSubresource.layerCount = 1; + + region.imageOffset = {0, 0, 0}; + region.imageExtent = {width, height, 1}; + + vkCmdCopyBufferToImage( + commandBuffer, + buffer, + image, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, + 1, + ®ion + ); +} + +void copyBufferToImage( + VkDevice device, + VkCommandPool commandPool, + VkQueue graphicsQueue, + VkBuffer buffer, + VkImage image, + uint32_t width, + uint32_t height) +{ + VkCommandBuffer commandBuffer = + beginSingleTimeCommands(device, commandPool); + + recordCopyBufferToImage( + commandBuffer, + buffer, + image, + width, + height + ); + + endSingleTimeCommands( + device, + commandPool, + graphicsQueue, + commandBuffer + ); +} diff --git a/VulkanUtils.hpp b/VulkanUtils.hpp new file mode 100644 index 0000000..c857882 --- /dev/null +++ b/VulkanUtils.hpp @@ -0,0 +1,73 @@ +#pragma once + +#include + +#include + +uint32_t findMemoryType( + VkPhysicalDevice physicalDevice, + uint32_t typeFilter, + VkMemoryPropertyFlags properties); + +void createBuffer( + VkDevice device, + VkPhysicalDevice physicalDevice, + VkDeviceSize size, + VkBufferUsageFlags usage, + VkMemoryPropertyFlags properties, + VkBuffer& buffer, + VkDeviceMemory& bufferMemory); + +VkCommandBuffer beginSingleTimeCommands( + VkDevice device, + VkCommandPool commandPool); + +void endSingleTimeCommands( + VkDevice device, + VkCommandPool commandPool, + VkQueue graphicsQueue, + VkCommandBuffer commandBuffer); + +void createImage( + VkDevice device, + VkPhysicalDevice physicalDevice, + uint32_t width, + uint32_t height, + VkFormat format, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkMemoryPropertyFlags properties, + VkImage& image, + VkDeviceMemory& imageMemory); + +void recordImageLayoutTransition( + VkCommandBuffer commandBuffer, + VkImage image, + VkFormat format, + VkImageLayout oldLayout, + VkImageLayout newLayout); + +void transitionImageLayout( + VkDevice device, + VkCommandPool commandPool, + VkQueue graphicsQueue, + VkImage image, + VkFormat format, + VkImageLayout oldLayout, + VkImageLayout newLayout); + +void recordCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkImage image, + uint32_t width, + uint32_t height); + +void copyBufferToImage( + VkDevice device, + VkCommandPool commandPool, + VkQueue graphicsQueue, + VkBuffer buffer, + VkImage image, + uint32_t width, + uint32_t height); diff --git a/build-sdk/CMakeCache.txt b/build-sdk/CMakeCache.txt new file mode 100644 index 0000000..5d5e6ba --- /dev/null +++ b/build-sdk/CMakeCache.txt @@ -0,0 +1,426 @@ +# This is the CMakeCache file. +# For build in directory: /home/itten/mxl-multiviewer/build-sdk +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=/usr/bin/addr2line + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//Choose the type of build, options are: None Debug Release RelWithDebInfo +// MinSizeRel ... +CMAKE_BUILD_TYPE:STRING=Debug + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//CXX compiler +CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/c++ + +//A wrapper around 'ar' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_AR:FILEPATH=/usr/bin/gcc-ar-15 + +//A wrapper around 'ranlib' adding the appropriate '--plugin' option +// for the GCC compiler +CMAKE_CXX_COMPILER_RANLIB:FILEPATH=/usr/bin/gcc-ranlib-15 + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= + +//Value Computed by CMake. +CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/pkgRedirects + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/gmake + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//Value Computed by CMake +CMAKE_PROJECT_COMPAT_VERSION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=mxl_multiviewer + +//Value Computed by CMake +CMAKE_PROJECT_SPDX_LICENSE:STATIC= + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=/usr/bin/readelf + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the archiver during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the archiver during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the archiver during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the archiver during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the archiver during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//Path to a program. +CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Enable real MXL SDK integration +MXL_MULTIVIEWER_ENABLE_MXL_SDK:BOOL=ON + +//Path to MXL SDK root directory +MXL_SDK_ROOT:PATH=/home/itten/dmf-mxl/mxl-1.0.1 + +//Arguments to supply to pkg-config +PKG_CONFIG_ARGN:STRING= + +//pkg-config executable +PKG_CONFIG_EXECUTABLE:FILEPATH=/usr/bin/pkg-config + +//Path to a program. +Vulkan_GLSLANG_VALIDATOR_EXECUTABLE:FILEPATH=/bin/glslangValidator + +//Path to a program. +Vulkan_GLSLC_EXECUTABLE:FILEPATH=Vulkan_GLSLC_EXECUTABLE-NOTFOUND + +//Path to a file. +Vulkan_INCLUDE_DIR:PATH=/usr/include + +//Path to a library. +Vulkan_LIBRARY:FILEPATH=/usr/lib/x86_64-linux-gnu/libvulkan.so + +//Value Computed by CMake +mxl_multiviewer_BINARY_DIR:STATIC=/home/itten/mxl-multiviewer/build-sdk + +//Value Computed by CMake +mxl_multiviewer_IS_TOP_LEVEL:STATIC=ON + +//Value Computed by CMake +mxl_multiviewer_SOURCE_DIR:STATIC=/home/itten/mxl-multiviewer + +//Path to a library. +pkgcfg_lib_SDL3_SDL3:FILEPATH=/usr/lib/x86_64-linux-gnu/libSDL3.so + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/home/itten/mxl-multiviewer/build-sdk +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=4 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=2 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=3 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR +CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB +CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/home/itten/mxl-multiviewer +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//Name of CMakeLists files to read +CMAKE_LIST_FILE_NAME:INTERNAL=CMakeLists.txt +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake-4.2 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_TAPI +CMAKE_TAPI-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 +//Details about finding PkgConfig +FIND_PACKAGE_MESSAGE_DETAILS_PkgConfig:INTERNAL=[/usr/bin/pkg-config][v2.5.1()] +//Details about finding Vulkan +FIND_PACKAGE_MESSAGE_DETAILS_Vulkan:INTERNAL=[/usr/lib/x86_64-linux-gnu/libvulkan.so][/usr/include][found components: glslangValidator missing components: glslc][v1.4.341()] +//ADVANCED property for variable: PKG_CONFIG_ARGN +PKG_CONFIG_ARGN-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: PKG_CONFIG_EXECUTABLE +PKG_CONFIG_EXECUTABLE-ADVANCED:INTERNAL=1 +SDL3_CFLAGS:INTERNAL=-I/usr/include;-D_REENTRANT;-I/usr/include/fribidi;-I/usr/include/libdrm;-I/usr/include/libdecor-0 +SDL3_CFLAGS_I:INTERNAL= +SDL3_CFLAGS_OTHER:INTERNAL=-D_REENTRANT +SDL3_FOUND:INTERNAL=1 +SDL3_INCLUDEDIR:INTERNAL=/usr/include +SDL3_INCLUDE_DIRS:INTERNAL=/usr/include;/usr/include/fribidi;/usr/include/libdrm;/usr/include/libdecor-0 +SDL3_LDFLAGS:INTERNAL=-L/usr/lib/x86_64-linux-gnu;-lSDL3 +SDL3_LDFLAGS_OTHER:INTERNAL= +SDL3_LIBDIR:INTERNAL=/usr/lib/x86_64-linux-gnu +SDL3_LIBRARIES:INTERNAL=SDL3 +SDL3_LIBRARY_DIRS:INTERNAL=/usr/lib/x86_64-linux-gnu +SDL3_LIBS:INTERNAL= +SDL3_LIBS_L:INTERNAL= +SDL3_LIBS_OTHER:INTERNAL= +SDL3_LIBS_PATHS:INTERNAL= +SDL3_MODULE_NAME:INTERNAL=sdl3 +SDL3_PREFIX:INTERNAL=/usr +SDL3_STATIC_CFLAGS:INTERNAL=-I/usr/include;-D_REENTRANT;-I/usr/include/fribidi;-I/usr/include/libdrm;-I/usr/include/libdecor-0;-DFRIBIDI_LIB_STATIC +SDL3_STATIC_CFLAGS_I:INTERNAL= +SDL3_STATIC_CFLAGS_OTHER:INTERNAL=-D_REENTRANT;-DFRIBIDI_LIB_STATIC +SDL3_STATIC_INCLUDE_DIRS:INTERNAL=/usr/include;/usr/include/fribidi;/usr/include/libdrm;/usr/include/libdecor-0 +SDL3_STATIC_LDFLAGS:INTERNAL=-L/usr/lib/x86_64-linux-gnu;-lSDL3;-lm;-lasound;-lpthread;-lrt;-lpulse;-pthread;-L/usr/lib/x86_64-linux-gnu/pulseaudio;-lpulsecommon-17.0;-lXcursor;-lXrandr;-lXrender;-lXss;-lXtst;-lXi;-lXext;-lXfixes;-lX11;-lpthread;-lxcb;-lXau;-lXdmcp;-lfribidi;-ldrm;-lgbm;-lwayland-egl;-lwayland-cursor;-lEGL;-lxkbcommon;-ldecor-0;-lwayland-client;-lm;-pthread;-lrt;-lffi +SDL3_STATIC_LDFLAGS_OTHER:INTERNAL=-pthread;-pthread +SDL3_STATIC_LIBDIR:INTERNAL= +SDL3_STATIC_LIBRARIES:INTERNAL=SDL3;m;asound;pthread;rt;pulse;pulsecommon-17.0;Xcursor;Xrandr;Xrender;Xss;Xtst;Xi;Xext;Xfixes;X11;pthread;xcb;Xau;Xdmcp;fribidi;drm;gbm;wayland-egl;wayland-cursor;EGL;xkbcommon;decor-0;wayland-client;m;rt;ffi +SDL3_STATIC_LIBRARY_DIRS:INTERNAL=/usr/lib/x86_64-linux-gnu;/usr/lib/x86_64-linux-gnu/pulseaudio +SDL3_STATIC_LIBS:INTERNAL= +SDL3_STATIC_LIBS_L:INTERNAL= +SDL3_STATIC_LIBS_OTHER:INTERNAL= +SDL3_STATIC_LIBS_PATHS:INTERNAL= +SDL3_VERSION:INTERNAL=3.4.2 +SDL3_sdl3_INCLUDEDIR:INTERNAL= +SDL3_sdl3_LIBDIR:INTERNAL= +SDL3_sdl3_PREFIX:INTERNAL= +SDL3_sdl3_VERSION:INTERNAL= +//ADVANCED property for variable: Vulkan_GLSLANG_VALIDATOR_EXECUTABLE +Vulkan_GLSLANG_VALIDATOR_EXECUTABLE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: Vulkan_GLSLC_EXECUTABLE +Vulkan_GLSLC_EXECUTABLE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: Vulkan_INCLUDE_DIR +Vulkan_INCLUDE_DIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: Vulkan_LIBRARY +Vulkan_LIBRARY-ADVANCED:INTERNAL=1 +__pkg_config_arguments_SDL3:INTERNAL=REQUIRED;sdl3 +__pkg_config_checked_SDL3:INTERNAL=1 +//ADVANCED property for variable: pkgcfg_lib_SDL3_SDL3 +pkgcfg_lib_SDL3_SDL3-ADVANCED:INTERNAL=1 +prefix_result:INTERNAL=/usr/lib/x86_64-linux-gnu + diff --git a/build-sdk/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake b/build-sdk/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..462c565 --- /dev/null +++ b/build-sdk/CMakeFiles/4.2.3/CMakeCXXCompiler.cmake @@ -0,0 +1,108 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "15.2.0") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "17") +set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON") +set(CMAKE_CXX_STANDARD_LATEST "26") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20;cxx_std_23;cxx_std_26") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") +set(CMAKE_CXX23_COMPILE_FEATURES "cxx_std_23") +set(CMAKE_CXX26_COMPILE_FEATURES "cxx_std_26") + +set(CMAKE_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU") +set(CMAKE_CXX_COMPILER_APPLE_SYSROOT "") +set(CMAKE_CXX_SIMULATE_VERSION "") +set(CMAKE_CXX_COMPILER_ARCHITECTURE_ID "x86_64") + + + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar-15") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib-15") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_LINKER_LINK "") +set(CMAKE_LINKER_LLD "") +set(CMAKE_CXX_COMPILER_LINKER "/usr/bin/ld") +set(CMAKE_CXX_COMPILER_LINKER_ID "GNU") +set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.46) +set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU) +set(CMAKE_MT "") +set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang IN ITEMS C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) +set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED TRUE) +set(CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED TRUE) +set(CMAKE_CXX_LINKER_PUSHPOP_STATE_SUPPORTED TRUE) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/15;/usr/include/x86_64-linux-gnu/c++/15;/usr/include/c++/15/backward;/usr/lib/gcc/x86_64-linux-gnu/15/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;c;gcc_s;gcc") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/15;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") +set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "") + +set(CMAKE_CXX_COMPILER_IMPORT_STD "") +### Imported target for C++23 standard library +set(CMAKE_CXX23_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE "Unsupported generator: Unix Makefiles") + + +### Imported target for C++26 standard library +set(CMAKE_CXX26_COMPILER_IMPORT_STD_NOT_FOUND_MESSAGE "Unsupported generator: Unix Makefiles") + + + diff --git a/build-sdk/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CXX.bin b/build-sdk/CMakeFiles/4.2.3/CMakeDetermineCompilerABI_CXX.bin new file mode 100755 index 0000000000000000000000000000000000000000..b3ed2fb1ccd89717dfa8ce339c08dc0380683f2b GIT binary patch literal 16040 zcmeHOeQX>@6`#9&*rkbmO=4n_(rl{)HBfKt#4$-w$T{b8_A18-iCvWjv)S{l?G^W7 z?d>&o#fM8MsvA-niB|m!Syj~vssA7#4MJ*NwF)W{DET7-gpk}qr62|B3R)S6a=bV5 z-g!Mar&8fRcBI=k@Ap3D?VH)X+1;6MrTcp0v6$epN_=R9J z{Is}RtOb6x#FRX#2uM{)tXfVR2}c<10+Q?WZqj4Q5h6vq6$=K0g(;l}+O0vHc%A;5 z8eq!uT6+c>LowvBMlX^b)36 z!QXMpr%tz%8>Xm>1u6clJ zW6JG)3G8?%kjiZd504Yn-b($KpnhW-Bd^%*Cir1D9O)kv-#+`|wTlflR{wEsA@EAM5yI(OxBZF#R)nP{8X*VWe5X_iaoZh>xboT5J!_v28bu?zHy`UI8zzfNuo+zB+z{ZNpg&+vULV1H0gOML>op9DBqoI(hFgSD+Zr zu}d83%N$PGyUpF^-dcT6r?4{vN9~;JyQ5w?aQ%U!seGyE4mjDo3%*7Rr6PH^m1Y)O@c)*9zc=6WFYD~}M(f;~-|rH_dSWh!S1(&<-)wwCrlPv{d4Q`s zUVvlswxmG)>W)`|8)@FwBP8GP*Ua>luUgaZSZDvdaC{)$G1u{yb^hS5z(KX8466Sa zF`Ku2NBRT&M}S!8*Pvf(|6-E1K zvR+?YWyLO8S8fKIz`+i3&{&;Uaj`wdJ9Tg`h(+adgVx!DajaU??*{9va|hP~b8Tm} zTD_Ko!=*LrfsYM=ZLNK@|H~N=Vr3BQroVCBny$?MGJONXJeR(1J!hS7x!MHjxv)CX z{OVjReS^?Vc$$Ae$t$bl&9CT^x0gw*b1hRQJB(d!z95t@z{l(1=h8QZpo=gp*?+Yj z!?2Y)O5M?0BK$L+f15pN+X8^yC-L7Q%dygF`!}q(=h@Be` z{8R1whQj*&nPa`#1Hq*2`Xx7a%Fi6OkMyTAJ^kH6>Ph?TWZ>E*AHMCK>dOoa^rh`| ze@~{nA2g)g$$FU7?Z*}-BYwEpf^)%2Kpicsw1!@7E zUZ_@QfnvdLuUKM_oe;5!L~QH2hQ=BApoTcEB{&W?pFxG52KfbVJ5)R2*9y1Tfb(|+!-?*OmIa&w#DdKsZmRXPB>5*4E1o2JC(%}-Ekv2{^VA%zcWfX*f*RsD76^yM zpt7*Pdx&Sfe^*t!kS7VyMze4ga~e@A$I_H2{wB==vK0 zH%KQ;+5o>V3{c$yd_x?rKJ9uDCx`u@!z{r{dw3gX2hOMfpd3_2M$BQcv?|{Y3idFr z%P)gwu4IqqOIasx=Yo=7ww=m^7%mmY^KRhg%=Y>kxFf)`9p880rC~AfC&h^G6kI!3 zDHJBbB*fXE87xyx9d*9urXGGc1+92_*Y7@@F^9*;h5blhN0(O|DcPZSm5A9#pYCu*{U#UCriV{NYJ<)wszRR>>OG3|=`@4^3 zQUJsIIy-HV)ap4Q>?3{04tMw2$9j8DrU&eS?!)j36cn``6G`3}@ll&0+?*3QLM9Tt zAft9h0JD6Xgq@la9!z~n9M7wRIa-2B;7-61#~f&uWa3PBj7Hg5 z4(yo|W-YXFzclXp!6ZR2%G&UXkPWEus9bU#T6YTGFvN=;V?t7e2^T^E#&?}-@Z&%@ z&%(J3T)wibw7-kQ@E^3iz!Ea}-&nF=X}=v?p>DWz0rMfuWw?EwzcJlT%G@r`pV&td zDmZszd!FAhogqb>Ct=%c&+{@1u<-kDo-Z=R|Ko7c<3A2UoU3vBJU?T~^Indh^_b$v z44nHhKTnEG+o^FqevT;*6*OUco{utJAVqFpKmSKTj_1Vl zhHpXzF>c>TDv3e%x;~wbQbIcb5Yzja?Rj3w25cXuJa$b((?3ivIwza5dim literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/4.2.3/CMakeSystem.cmake b/build-sdk/CMakeFiles/4.2.3/CMakeSystem.cmake new file mode 100644 index 0000000..804d059 --- /dev/null +++ b/build-sdk/CMakeFiles/4.2.3/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Linux-7.0.0-15-generic") +set(CMAKE_HOST_SYSTEM_NAME "Linux") +set(CMAKE_HOST_SYSTEM_VERSION "7.0.0-15-generic") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Linux-7.0.0-15-generic") +set(CMAKE_SYSTEM_NAME "Linux") +set(CMAKE_SYSTEM_VERSION "7.0.0-15-generic") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp b/build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp new file mode 100644 index 0000000..b35f567 --- /dev/null +++ b/build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/CMakeCXXCompilerId.cpp @@ -0,0 +1,949 @@ +/* This source file must have a .cpp extension so that all C++ compilers + recognize the extension without flags. Borland does not know .cxx for + example. */ +#ifndef __cplusplus +# error "A C compiler has been selected for C++." +#endif + +#if !defined(__has_include) +/* If the compiler does not have __has_include, pretend the answer is + always no. */ +# define __has_include(x) 0 +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later, + except that a few beta releases use the old format with V=2021. */ +# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111 +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE) + /* The third version component from --version is an update index, + but no macro is provided for it. */ +# define COMPILER_VERSION_PATCH DEC(0) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER) +# define COMPILER_ID "IntelLLVM" +#if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +#endif +#if defined(__GNUC__) +# define SIMULATE_ID "GNU" +#endif +/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and + * later. Look for 6 digit vs. 8 digit version number to decide encoding. + * VVVV is no smaller than the current year when a version is released. + */ +#if __INTEL_LLVM_COMPILER < 1000000L +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10) +#else +# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000) +# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100) +#endif +#if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +#endif +#if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +#elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +#endif +#if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +#endif +#if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +#endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__open_xl__) && defined(__clang__) +# define COMPILER_ID "IBMClang" +# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__) +# define COMPILER_VERSION_MINOR DEC(__open_xl_release__) +# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__NVCOMPILER) +# define COMPILER_ID "NVHPC" +# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__) +# if defined(__NVCOMPILER_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__) +# endif + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(__clang__) && defined(__cray__) +# define COMPILER_ID "CrayClang" +# define COMPILER_VERSION_MAJOR DEC(__cray_major__) +# define COMPILER_VERSION_MINOR DEC(__cray_minor__) +# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__CLANG_FUJITSU) +# define COMPILER_ID "FujitsuClang" +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# define COMPILER_VERSION_INTERNAL_STR __clang_version__ + + +#elif defined(__FUJITSU) +# define COMPILER_ID "Fujitsu" +# if defined(__FCC_version__) +# define COMPILER_VERSION __FCC_version__ +# elif defined(__FCC_major__) +# define COMPILER_VERSION_MAJOR DEC(__FCC_major__) +# define COMPILER_VERSION_MINOR DEC(__FCC_minor__) +# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__) +# endif +# if defined(__fcc_version) +# define COMPILER_VERSION_INTERNAL DEC(__fcc_version) +# elif defined(__FCC_VERSION) +# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION) +# endif + + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TASKING__) +# define COMPILER_ID "Tasking" + # define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000) + # define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100) +# define COMPILER_VERSION_INTERNAL DEC(__VERSION__) + +#elif defined(__ORANGEC__) +# define COMPILER_ID "OrangeC" +# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__) +# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__) + +#elif defined(__RENESAS__) +# define COMPILER_ID "Renesas" +/* __RENESAS_VERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__RENESAS_VERSION__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR HEX(__RENESAS_VERSION__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__RENESAS_VERSION__ >> 8 & 0xFF) + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) && defined(__ti__) +# define COMPILER_ID "TIClang" + # define COMPILER_VERSION_MAJOR DEC(__ti_major__) + # define COMPILER_VERSION_MINOR DEC(__ti_minor__) + # define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__) +# define COMPILER_VERSION_INTERNAL DEC(__ti_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__)) +# define COMPILER_ID "LCC" +# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100) +# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100) +# if defined(__LCC_MINOR__) +# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__) +# endif +# if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define SIMULATE_ID "GNU" +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(_ADI_COMPILER) +# define COMPILER_ID "ADSP" +#if defined(__VERSIONNUM__) + /* __VERSIONNUM__ = 0xVVRRPPTT */ +# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF) +# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF) +# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF) +# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + +#elif defined(__DCC__) && defined(_DIAB_TOOL) +# define COMPILER_ID "Diab" + # define COMPILER_VERSION_MAJOR DEC(__VERSION_MAJOR_NUMBER__) + # define COMPILER_VERSION_MINOR DEC(__VERSION_MINOR_NUMBER__) + # define COMPILER_VERSION_PATCH DEC(__VERSION_ARCH_FEATURE_NUMBER__) + # define COMPILER_VERSION_TWEAK DEC(__VERSION_BUG_FIX_NUMBER__) + + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__MSYS__) +# define PLATFORM_ID "MSYS" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +# elif defined(_ADI_COMPILER) +# define PLATFORM_ID "ADSP" + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_ARM64EC) +# define ARCHITECTURE_ID "ARM64EC" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__ICCSTM8__) +# define ARCHITECTURE_ID "STM8" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__clang__) && defined(__ti__) +# if defined(__ARM_ARCH) +# define ARCHITECTURE_ID "ARM" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__TI_COMPILER_VERSION__) +# if defined(__TI_ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__MSP430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__TMS320C28XX__) +# define ARCHITECTURE_ID "TMS320C28x" + +# elif defined(__TMS320C6X__) || defined(_TMS320C6X) +# define ARCHITECTURE_ID "TMS320C6x" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +# elif defined(__ADSPSHARC__) +# define ARCHITECTURE_ID "SHARC" + +# elif defined(__ADSPBLACKFIN__) +# define ARCHITECTURE_ID "Blackfin" + +#elif defined(__TASKING__) + +# if defined(__CTC__) || defined(__CPTC__) +# define ARCHITECTURE_ID "TriCore" + +# elif defined(__CMCS__) +# define ARCHITECTURE_ID "MCS" + +# elif defined(__CARM__) || defined(__CPARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__CARC__) +# define ARCHITECTURE_ID "ARC" + +# elif defined(__C51__) +# define ARCHITECTURE_ID "8051" + +# elif defined(__CPCP__) +# define ARCHITECTURE_ID "PCP" + +# else +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__RENESAS__) +# if defined(__CCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__CCRL__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__CCRH__) +# define ARCHITECTURE_ID "RH850" + +# else +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number. */ +#ifdef COMPILER_VERSION +char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]"; + +/* Construct a string literal encoding the version number components. */ +#elif defined(COMPILER_VERSION_MAJOR) +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#elif defined(COMPILER_VERSION_INTERNAL_STR) +char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]"; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + +#define CXX_STD_98 199711L +#define CXX_STD_11 201103L +#define CXX_STD_14 201402L +#define CXX_STD_17 201703L +#define CXX_STD_20 202002L +#define CXX_STD_23 202302L + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) +# if _MSVC_LANG > CXX_STD_17 +# define CXX_STD _MSVC_LANG +# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17 +# define CXX_STD CXX_STD_20 +# elif _MSVC_LANG > CXX_STD_14 +# define CXX_STD CXX_STD_17 +# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# elif defined(__INTEL_CXX11_MODE__) +# define CXX_STD CXX_STD_11 +# else +# define CXX_STD CXX_STD_98 +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# if _MSVC_LANG > __cplusplus +# define CXX_STD _MSVC_LANG +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__NVCOMPILER) +# if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init) +# define CXX_STD CXX_STD_20 +# else +# define CXX_STD __cplusplus +# endif +#elif defined(__INTEL_COMPILER) || defined(__PGI) +# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes) +# define CXX_STD CXX_STD_17 +# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__) +# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi) +# define CXX_STD CXX_STD_14 +# else +# define CXX_STD __cplusplus +# endif +#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__) +# define CXX_STD CXX_STD_11 +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_standard_default = "INFO" ":" "standard_default[" +#if CXX_STD > CXX_STD_23 + "26" +#elif CXX_STD > CXX_STD_20 + "23" +#elif CXX_STD > CXX_STD_17 + "20" +#elif CXX_STD > CXX_STD_14 + "17" +#elif CXX_STD > CXX_STD_11 + "14" +#elif CXX_STD >= CXX_STD_11 + "11" +#else + "98" +#endif +"]"; + +const char* info_language_extensions_default = "INFO" ":" "extensions_default[" +#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \ + defined(__TI_COMPILER_VERSION__) || defined(__RENESAS__)) && \ + !defined(__STRICT_ANSI__) + "ON" +#else + "OFF" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#if defined(COMPILER_VERSION_INTERNAL) || defined(COMPILER_VERSION_INTERNAL_STR) + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXT_COMPUTE_LINUX_TARGET) + require += info_cray[argc]; +#endif + require += info_language_standard_default[argc]; + require += info_language_extensions_default[argc]; + (void)argv; + return require; +} diff --git a/build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/a.out b/build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/a.out new file mode 100755 index 0000000000000000000000000000000000000000..c2ee09f52462e1b319a2c699a05c7e512b0e1eb1 GIT binary patch literal 16088 zcmeHOeQX>@6`#9&xipC{X+uI%nr)O+3Dg_gNnE!m^c?4$HL?>oaiTyPmbGtfpSTa} zZm+egR!x z{iwQ4EhTxe=1h6g0F|1QSTr9SglC%V0x1vUZK4N63mMsNq2zFbC;^r9gYA}ZfyiO} zl~e#kd9^-^jVW3Bw~EtZ2duT@rpz=M{h8hK(TN+mPY`x2>Mq!(oQA_B!6~T^h{=@3WCto`I)g!-ur$@<-BREc12^Yo^27{|dG1gq?`1O&`-+RX zk8NsSPxqcqx7BX7cUAK{b}F~Kzt>IsMSnO`3jAV!Z)diU_xrtptWUm%bA`Nkca3UY zMWrLi4Kx=*jAU*v#9fwnubq=`&h+)C zTBcfFch2m7gB(=Wlt}f@Lw4iFC$vA}FA(FLS@H_QJ+r|Ys`?1$sp^|5(~TQXu;QzN zr2mZ8-}N-Zw(HKsjC0|g`j>fIB2L$n|8sT+k0YnFBPlu#}7Lv zcgH#FOuQ8=cTVqKO2UZeqvDwpu^i|L!3wcB74SG^Pox19rbz&DA&#A`qQ?b-F;$K;S|3*FDI5@NB<&_lXbBhyIFHh9dChtK# z{&ecvaT+#msvgtoC~{My6h$D4Koo%}0#O8_2t*NxA`nF&ia->BC<6b_5#aA*H%i_6 zyAIqtSjdfLvVQRxebGEVUwdA;`=DPeWeWLY%{sO0vQ4JB6`AJaN?VL(yCriIs`2mFqs$c=JOIC)9oG@A=q{&HR~B+jG5_p~oa8_8HLMcggQd zOr%yOz7X$Ru{8by)y#xR+;)rp_}dzPKc>-{Vh-Qt;wOxZZ+l$E?O~bqIkE1IM^&pu zKT!mt2t*NxA`nF&ia->BC<0Lgq6qwtM*#a7v40WI5&GeU`o0|fm;H?^MEiJSoa5Uq{mAwUzGB{ zi41?@{yzuUAO3H8#J*L_GLEn>^(m3D?-ct?_jPvOYi&I|P|gQsiyrjp3BReOt*qsi zZNl83O&qVq>JOE$3XeyOb}(Z)c&D0hehI7#n&p#XOuj~Je^ummSN=b zRA1EmS{2@x{k-tueb(P2K0)&&nS^J94-mha=0j5En|^mhMc)@c3DL)W;G+1!e1o@N zh@Wk8zt!)GsF2U4aKFO(Z;St}A^*$c)vm&|#yg4MG>*hX#v5i(R0d`QAXr4ZLARL@6i_4cUWgZWq5B*s^wxEd;YIp0l}bGdOcsgYdL4CbkJ_IjW9 zJC7dilsA~&X?t*VRJot&X=%;mhYEOONq)KxcJ!v))c(CLoiEt?>HQtO-JL|!OEov; zNU5{;pmO*19N5#*;~wbhI+W^n`#bjZq{t$C{2_@`4j*)~!B2aEr*tpL3k&9$0}1ob zJhx^W?!`P&6g-K6;+uQd!Z@dThXcGJv*yPh zE>I?*kSUv|9cdQy@Yw!{Otg_S*+WuxwP~Zp!l+*i#)azG)7``ug|5I%N#hcEs@={|M%wX7doE@E7q+| zZ6y4a);_2o>pkFRQAWMh`-<>MLSE~^9_vBir0DUoj_Za!)^QGTweP{Pz672UdqBAT zeN@0}JJgT$91!bdv>$pv{vg3?Maa{l2yB*$!|g|VvXo&H*kk<)#QGKWhx`8^*>az- zp03{4<^GO!JE`adKahESQ)_RD9Z*E5huy2kL-x&L0Q?~Pr$hEhF#tXr8nCdx$&fwP z6+k@KpabFlKPUExzp_MA@O2RZLPJzvp&U06_E={D@2YB=Ot}7UhU{l8qX+!55v#u# ze-P&=Q+xe~&v!OMQ7~-J{j0UddK_ql?8EK<8I{v&tNPsv>tURy4A%!4_#3iqtg*-X zd$x&4O3*XXoDBY5D&V<~=fUdwmv3y8reyx$`4e`SM^BOttH2)X;i>IxtyEI~&i%k1 zI7>yf_EiH3eEXcK&cP1!b;>Y@`mye77yGcjbO+{Y5fRLV#~JompTYq4wTQV39mdaz z!^_ezzK`&;3fhDFFRdi2ZKrHCwev?*O81AHqh3?WYtH)i6a0^b((;f&NL2p-$MRlu literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/CMakeConfigureLog.yaml b/build-sdk/CMakeFiles/CMakeConfigureLog.yaml new file mode 100644 index 0000000..67acd2e --- /dev/null +++ b/build-sdk/CMakeFiles/CMakeConfigureLog.yaml @@ -0,0 +1,1590 @@ + +--- +events: + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineSystem.cmake:12 (find_program)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_UNAME" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "uname" + candidate_directories: + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + searched_directories: + - "/home/itten/.opencode/bin/uname" + - "/usr/local/sbin/uname" + - "/usr/local/bin/uname" + - "/usr/sbin/uname" + found: "/usr/bin/uname" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineSystem.cmake:212 (message)" + - "CMakeLists.txt:3 (project)" + message: | + The system is: Linux - 7.0.0-15-generic - x86_64 + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeUnixFindMake.cmake:5 (find_program)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_MAKE_PROGRAM" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "gmake" + - "make" + - "smake" + candidate_directories: + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + searched_directories: + - "/home/itten/.opencode/bin/gmake" + - "/usr/local/sbin/gmake" + - "/usr/local/bin/gmake" + - "/usr/sbin/gmake" + found: "/usr/bin/gmake" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompiler.cmake:73 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:69 (_cmake_find_compiler)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_CXX_COMPILER" + description: "CXX compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "c++" + - "CC" + - "g++" + - "aCC" + - "cl" + - "bcc" + - "xlC" + - "icpx" + - "icx" + - "clang++" + candidate_directories: + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + searched_directories: + - "/home/itten/.opencode/bin/c++" + - "/usr/local/sbin/c++" + - "/usr/local/bin/c++" + - "/usr/sbin/c++" + found: "/usr/bin/c++" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:462 (find_file)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:500 (CMAKE_DETERMINE_COMPILER_ID_WRITE)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:8 (CMAKE_DETERMINE_COMPILER_ID_BUILD)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:125 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:3 (project)" + mode: "file" + variable: "src_in" + description: "Path to a file." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "CMakeCXXCompilerId.cpp.in" + candidate_directories: + - "/usr/share/cmake-4.2/Modules/" + found: "/usr/share/cmake-4.2/Modules/CMakeCXXCompilerId.cpp.in" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:17 (message)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:125 (CMAKE_DETERMINE_COMPILER_ID)" + - "CMakeLists.txt:3 (project)" + message: | + Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. + Compiler: /usr/bin/c++ + Build flags: + Id flags: + + The output was: + 0 + + + Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + + The CXX compiler identification is GNU, found in: + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/4.2.3/CompilerIdCXX/a.out + + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_AR" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "ar" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/ar" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_RANLIB" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "ranlib" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/ranlib" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_STRIP" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "strip" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/strip" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_LINKER" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "ld" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/ld" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_NM" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "nm" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/nm" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_OBJDUMP" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "objdump" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/objdump" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_OBJCOPY" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "objcopy" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/objcopy" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_READELF" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "readelf" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/readelf" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_DLLTOOL" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "dlltool" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + searched_directories: + - "/usr/bin/dlltool" + - "/home/itten/.opencode/bin/dlltool" + - "/usr/local/sbin/dlltool" + - "/usr/local/bin/dlltool" + - "/usr/sbin/dlltool" + - "/sbin/dlltool" + - "/bin/dlltool" + - "/usr/games/dlltool" + - "/usr/local/games/dlltool" + - "/snap/bin/dlltool" + found: false + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_ADDR2LINE" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "addr2line" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + found: "/usr/bin/addr2line" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeFindBinUtils.cmake:243 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:206 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_TAPI" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "tapi" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + searched_directories: + - "/usr/bin/tapi" + - "/home/itten/.opencode/bin/tapi" + - "/usr/local/sbin/tapi" + - "/usr/local/bin/tapi" + - "/usr/sbin/tapi" + - "/sbin/tapi" + - "/bin/tapi" + - "/usr/games/tapi" + - "/usr/local/games/tapi" + - "/snap/bin/tapi" + found: false + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/Compiler/GNU-FindBinUtils.cmake:18 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:207 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_CXX_COMPILER_AR" + description: "A wrapper around 'ar' adding the appropriate '--plugin' option for the GCC compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "gcc-ar-15.2" + - "gcc-ar-15" + - "gcc-ar15" + - "gcc-ar" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + searched_directories: + - "/usr/bin/gcc-ar-15.2" + - "/home/itten/.opencode/bin/gcc-ar-15.2" + - "/usr/local/sbin/gcc-ar-15.2" + - "/usr/local/bin/gcc-ar-15.2" + - "/usr/sbin/gcc-ar-15.2" + - "/sbin/gcc-ar-15.2" + - "/bin/gcc-ar-15.2" + - "/usr/games/gcc-ar-15.2" + - "/usr/local/games/gcc-ar-15.2" + - "/snap/bin/gcc-ar-15.2" + found: "/usr/bin/gcc-ar-15" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/Compiler/GNU-FindBinUtils.cmake:30 (find_program)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCXXCompiler.cmake:207 (include)" + - "CMakeLists.txt:3 (project)" + mode: "program" + variable: "CMAKE_CXX_COMPILER_RANLIB" + description: "A wrapper around 'ranlib' adding the appropriate '--plugin' option for the GCC compiler" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: false + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: false + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "gcc-ranlib-15.2" + - "gcc-ranlib-15" + - "gcc-ranlib15" + - "gcc-ranlib" + candidate_directories: + - "/usr/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + searched_directories: + - "/usr/bin/gcc-ranlib-15.2" + - "/home/itten/.opencode/bin/gcc-ranlib-15.2" + - "/usr/local/sbin/gcc-ranlib-15.2" + - "/usr/local/bin/gcc-ranlib-15.2" + - "/usr/sbin/gcc-ranlib-15.2" + - "/sbin/gcc-ranlib-15.2" + - "/bin/gcc-ranlib-15.2" + - "/usr/games/gcc-ranlib-15.2" + - "/usr/local/games/gcc-ranlib-15.2" + - "/snap/bin/gcc-ranlib-15.2" + found: "/usr/bin/gcc-ranlib-15" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + - + kind: "try_compile-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:83 (try_compile)" + - "/usr/share/cmake-4.2/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + checks: + - "Detecting CXX compiler ABI info" + directories: + source: "/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/CMakeScratch/TryCompile-9UtuIz" + binary: "/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/CMakeScratch/TryCompile-9UtuIz" + cmakeVariables: + CMAKE_CXX_FLAGS: "" + CMAKE_CXX_FLAGS_DEBUG: "-g" + CMAKE_CXX_SCAN_FOR_MODULES: "OFF" + CMAKE_EXE_LINKER_FLAGS: "" + buildResult: + variable: "CMAKE_CXX_ABI_COMPILED" + cached: true + stdout: | + Change Dir: '/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/CMakeScratch/TryCompile-9UtuIz' + + Run Build Command(s): /usr/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_a4631/fast + /usr/bin/gmake -f CMakeFiles/cmTC_a4631.dir/build.make CMakeFiles/cmTC_a4631.dir/build + gmake[1]: Entering directory '/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/CMakeScratch/TryCompile-9UtuIz' + Building CXX object CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o + /usr/bin/c++ -v -o CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 15.2.0-16ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-15/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2,rust,cobol,algol68 --prefix=/usr --with-gcc-major-version-only --program-suffix=-15 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 15.2.0 (Ubuntu 15.2.0-16ubuntu1) + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_a4631.dir/' + /usr/libexec/gcc/x86_64-linux-gnu/15/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_a4631.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -fzero-init-padding-bits=all -Wbidi-chars=any -o /tmp/ccfv5LST.s + GNU C++17 (Ubuntu 15.2.0-16ubuntu1) version 15.2.0 (x86_64-linux-gnu) + compiled by GNU C version 15.2.0, GMP version 6.3.0, MPFR version 4.2.2, MPC version 1.3.1, isl version isl-0.27-GMP + + GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072 + ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/15" + ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/15/include-fixed/x86_64-linux-gnu" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/15/include-fixed" + ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include" + #include "..." search starts here: + #include <...> search starts here: + /usr/include/c++/15 + /usr/include/x86_64-linux-gnu/c++/15 + /usr/include/c++/15/backward + /usr/lib/gcc/x86_64-linux-gnu/15/include + /usr/local/include + /usr/include/x86_64-linux-gnu + /usr/include + End of search list. + Compiler executable checksum: b661a74662ad7cf413c4193391ab5290 + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_a4631.dir/' + /usr/bin/x86_64-linux-gnu-as -v --64 -o CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccfv5LST.s + GNU assembler version 2.46 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.46 + COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.' + Linking CXX executable cmTC_a4631 + /usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_a4631.dir/link.txt --verbose=1 + Using built-in specs. + COLLECT_GCC=/usr/bin/c++ + COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-linux-gnu/15/lto-wrapper + OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa + OFFLOAD_TARGET_DEFAULT=1 + Target: x86_64-linux-gnu + Configured with: ../src/configure -v --with-pkgversion='Ubuntu 15.2.0-16ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-15/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2,rust,cobol,algol68 --prefix=/usr --with-gcc-major-version-only --program-suffix=-15 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2 + Thread model: posix + Supported LTO compression algorithms: zlib zstd + gcc version 15.2.0 (Ubuntu 15.2.0-16ubuntu1) + COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/ + LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../:/lib/:/usr/lib/ + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_a4631' '-foffload-options=-l_GCC_stdc++' '-foffload-options=-l_GCC_m' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_a4631.' + /usr/libexec/gcc/x86_64-linux-gnu/15/collect2 -plugin /usr/libexec/gcc/x86_64-linux-gnu/15/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/15/lto-wrapper -plugin-opt=-fresolution=/tmp/cct536bK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_a4631 /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/15 -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/15/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crtn.o + collect2 version 15.2.0 + /usr/bin/ld -plugin /usr/libexec/gcc/x86_64-linux-gnu/15/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/15/lto-wrapper -plugin-opt=-fresolution=/tmp/cct536bK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_a4631 /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/15 -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/15/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crtn.o + GNU ld (GNU Binutils for Ubuntu) 2.46 + COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_a4631' '-foffload-options=-l_GCC_stdc++' '-foffload-options=-l_GCC_m' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_a4631.' + /usr/bin/c++ -v -Wl,-v CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_a4631 + gmake[1]: Leaving directory '/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/CMakeScratch/TryCompile-9UtuIz' + + exitCode: 0 + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:217 (message)" + - "/usr/share/cmake-4.2/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + message: | + Parsed CXX implicit include dir info: rv=done + found start of include info + found start of implicit include info + add: [/usr/include/c++/15] + add: [/usr/include/x86_64-linux-gnu/c++/15] + add: [/usr/include/c++/15/backward] + add: [/usr/lib/gcc/x86_64-linux-gnu/15/include] + add: [/usr/local/include] + add: [/usr/include/x86_64-linux-gnu] + add: [/usr/include] + end of search list found + collapse include dir [/usr/include/c++/15] ==> [/usr/include/c++/15] + collapse include dir [/usr/include/x86_64-linux-gnu/c++/15] ==> [/usr/include/x86_64-linux-gnu/c++/15] + collapse include dir [/usr/include/c++/15/backward] ==> [/usr/include/c++/15/backward] + collapse include dir [/usr/lib/gcc/x86_64-linux-gnu/15/include] ==> [/usr/lib/gcc/x86_64-linux-gnu/15/include] + collapse include dir [/usr/local/include] ==> [/usr/local/include] + collapse include dir [/usr/include/x86_64-linux-gnu] ==> [/usr/include/x86_64-linux-gnu] + collapse include dir [/usr/include] ==> [/usr/include] + implicit include dirs: [/usr/include/c++/15;/usr/include/x86_64-linux-gnu/c++/15;/usr/include/c++/15/backward;/usr/lib/gcc/x86_64-linux-gnu/15/include;/usr/local/include;/usr/include/x86_64-linux-gnu;/usr/include] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:253 (message)" + - "/usr/share/cmake-4.2/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + message: | + Parsed CXX implicit link information: + link line regex: [^( *|.*[/\\])(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)] + linker tool regex: [^[ ]*(->|"|[0-9]+>[ -]*Build:[ 0-9]+ ms[ ]*)?[ ]*(([^"]*[/\\])?(ld[0-9]*(|\\.[a-rt-z][a-z]*|\\.s[a-np-z][a-z]*|\\.so[a-z]+)))("|,| |$)] + ignore line: [Change Dir: '/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/CMakeScratch/TryCompile-9UtuIz'] + ignore line: [] + ignore line: [Run Build Command(s): /usr/bin/cmake -E env VERBOSE=1 /usr/bin/gmake -f Makefile cmTC_a4631/fast] + ignore line: [/usr/bin/gmake -f CMakeFiles/cmTC_a4631.dir/build.make CMakeFiles/cmTC_a4631.dir/build] + ignore line: [gmake[1]: Entering directory '/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/CMakeScratch/TryCompile-9UtuIz'] + ignore line: [Building CXX object CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o] + ignore line: [/usr/bin/c++ -v -o CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 15.2.0-16ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-15/README.Bugs --enable-languages=c ada c++ go d fortran objc obj-c++ m2 rust cobol algol68 --prefix=/usr --with-gcc-major-version-only --program-suffix=-15 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 15.2.0 (Ubuntu 15.2.0-16ubuntu1) ] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_a4631.dir/'] + ignore line: [ /usr/libexec/gcc/x86_64-linux-gnu/15/cc1plus -quiet -v -imultiarch x86_64-linux-gnu -D_GNU_SOURCE /usr/share/cmake-4.2/Modules/CMakeCXXCompilerABI.cpp -quiet -dumpdir CMakeFiles/cmTC_a4631.dir/ -dumpbase CMakeCXXCompilerABI.cpp.cpp -dumpbase-ext .cpp -mtune=generic -march=x86-64 -version -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -fzero-init-padding-bits=all -Wbidi-chars=any -o /tmp/ccfv5LST.s] + ignore line: [GNU C++17 (Ubuntu 15.2.0-16ubuntu1) version 15.2.0 (x86_64-linux-gnu)] + ignore line: [ compiled by GNU C version 15.2.0 GMP version 6.3.0 MPFR version 4.2.2 MPC version 1.3.1 isl version isl-0.27-GMP] + ignore line: [] + ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072] + ignore line: [ignoring duplicate directory "/usr/include/x86_64-linux-gnu/c++/15"] + ignore line: [ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/15/include-fixed/x86_64-linux-gnu"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/15/include-fixed"] + ignore line: [ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /usr/include/c++/15] + ignore line: [ /usr/include/x86_64-linux-gnu/c++/15] + ignore line: [ /usr/include/c++/15/backward] + ignore line: [ /usr/lib/gcc/x86_64-linux-gnu/15/include] + ignore line: [ /usr/local/include] + ignore line: [ /usr/include/x86_64-linux-gnu] + ignore line: [ /usr/include] + ignore line: [End of search list.] + ignore line: [Compiler executable checksum: b661a74662ad7cf413c4193391ab5290] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_a4631.dir/'] + ignore line: [ /usr/bin/x86_64-linux-gnu-as -v --64 -o CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o /tmp/ccfv5LST.s] + ignore line: [GNU assembler version 2.46 (x86_64-linux-gnu) using BFD version (GNU Binutils for Ubuntu) 2.46] + ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o' '-c' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.'] + ignore line: [Linking CXX executable cmTC_a4631] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_a4631.dir/link.txt --verbose=1] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/c++] + ignore line: [COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-linux-gnu/15/lto-wrapper] + ignore line: [OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa] + ignore line: [OFFLOAD_TARGET_DEFAULT=1] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 15.2.0-16ubuntu1' --with-bugurl=file:///usr/share/doc/gcc-15/README.Bugs --enable-languages=c ada c++ go d fortran objc obj-c++ m2 rust cobol algol68 --prefix=/usr --with-gcc-major-version-only --program-suffix=-15 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32 m64 mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-nvptx/usr amdgcn-amdhsa=/build/gcc-15-j35TAX/gcc-15-15.2.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2] + ignore line: [Thread model: posix] + ignore line: [Supported LTO compression algorithms: zlib zstd] + ignore line: [gcc version 15.2.0 (Ubuntu 15.2.0-16ubuntu1) ] + ignore line: [COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/15/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/15/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/15/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_a4631' '-foffload-options=-l_GCC_stdc++' '-foffload-options=-l_GCC_m' '-shared-libgcc' '-mtune=generic' '-march=x86-64' '-dumpdir' 'cmTC_a4631.'] + link line: [ /usr/libexec/gcc/x86_64-linux-gnu/15/collect2 -plugin /usr/libexec/gcc/x86_64-linux-gnu/15/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/15/lto-wrapper -plugin-opt=-fresolution=/tmp/cct536bK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_a4631 /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/15 -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/15/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/libexec/gcc/x86_64-linux-gnu/15/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/libexec/gcc/x86_64-linux-gnu/15/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/15/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/cct536bK.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-pie] ==> ignore + arg [-znow] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_a4631] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crti.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crti.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/15] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/15] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/15/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/15/../../..] + arg [-L/lib] ==> dir [/lib] + arg [-L/usr/lib] ==> dir [/usr/lib] + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crtn.o] ==> obj [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crtn.o] + ignore line: [collect2 version 15.2.0] + ignore line: [/usr/bin/ld -plugin /usr/libexec/gcc/x86_64-linux-gnu/15/liblto_plugin.so -plugin-opt=/usr/libexec/gcc/x86_64-linux-gnu/15/lto-wrapper -plugin-opt=-fresolution=/tmp/cct536bK.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -dynamic-linker /lib64/ld-linux-x86-64.so.2 -pie -z now -z relro -o cmTC_a4631 /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o -L/usr/lib/gcc/x86_64-linux-gnu/15 -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/15/../../.. -L/lib -L/usr/lib -v CMakeFiles/cmTC_a4631.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o /usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crtn.o] + linker tool for 'CXX': /usr/bin/ld + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/Scrt1.o] ==> [/usr/lib/x86_64-linux-gnu/Scrt1.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crti.o] ==> [/usr/lib/x86_64-linux-gnu/crti.o] + collapse obj [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu/crtn.o] ==> [/usr/lib/x86_64-linux-gnu/crtn.o] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/15] ==> [/usr/lib/gcc/x86_64-linux-gnu/15] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/15/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/15/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/15/../../..] ==> [/usr/lib] + collapse library dir [/lib] ==> [/lib] + collapse library dir [/usr/lib] ==> [/usr/lib] + implicit libs: [stdc++;m;gcc_s;gcc;c;gcc_s;gcc] + implicit objs: [/usr/lib/x86_64-linux-gnu/Scrt1.o;/usr/lib/x86_64-linux-gnu/crti.o;/usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o;/usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o;/usr/lib/x86_64-linux-gnu/crtn.o] + implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/15;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib] + implicit fwks: [] + + + - + kind: "message-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/Internal/CMakeDetermineLinkerId.cmake:38 (message)" + - "/usr/share/cmake-4.2/Modules/CMakeDetermineCompilerABI.cmake:299 (cmake_determine_linker_id)" + - "/usr/share/cmake-4.2/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)" + - "CMakeLists.txt:3 (project)" + message: | + Running the CXX compiler's linker: "/usr/bin/ld" "-v" + GNU ld (GNU Binutils for Ubuntu) 2.46 + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/FindPkgConfig.cmake:517 (find_program)" + - "CMakeLists.txt:14 (find_package)" + mode: "program" + variable: "PKG_CONFIG_EXECUTABLE" + description: "pkg-config executable" + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "pkg-config" + - "pkgconf" + candidate_directories: + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + - "/usr/local/bin/" + - "/usr/local/sbin/" + - "/usr/local/" + - "/usr/bin/" + - "/usr/sbin/" + - "/usr/" + - "/bin/" + - "/sbin/" + - "/usr/X11R6/bin/" + - "/usr/X11R6/sbin/" + - "/usr/X11R6/" + - "/usr/pkg/bin/" + - "/usr/pkg/sbin/" + - "/usr/pkg/" + - "/opt/bin/" + - "/opt/sbin/" + - "/opt/" + searched_directories: + - "/home/itten/.opencode/bin/pkg-config" + - "/home/itten/.opencode/bin/pkgconf" + - "/usr/local/sbin/pkg-config" + - "/usr/local/sbin/pkgconf" + - "/usr/local/bin/pkg-config" + - "/usr/local/bin/pkgconf" + - "/usr/sbin/pkg-config" + - "/usr/sbin/pkgconf" + found: "/usr/bin/pkg-config" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/usr" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/FindVulkan.cmake:392 (find_path)" + - "CMakeLists.txt:15 (find_package)" + mode: "path" + variable: "Vulkan_INCLUDE_DIR" + description: "Path to a file." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "vulkan/vulkan.h" + candidate_directories: + - "/include/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + - "/usr/local/include/x86_64-linux-gnu/" + - "/usr/local/include/" + - "/usr/local/" + - "/usr/include/x86_64-linux-gnu/" + - "/usr/include/" + - "/usr/" + - "/include/x86_64-linux-gnu/" + - "/include/" + - "/usr/X11R6/include/x86_64-linux-gnu/" + - "/usr/X11R6/include/" + - "/usr/X11R6/" + - "/usr/pkg/include/x86_64-linux-gnu/" + - "/usr/pkg/include/" + - "/usr/pkg/" + - "/opt/include/x86_64-linux-gnu/" + - "/opt/include/" + - "/opt/" + - "/usr/include/X11/" + searched_directories: + - "/include/vulkan/vulkan.h" + - "/home/itten/.opencode/bin/vulkan/vulkan.h" + - "/usr/local/sbin/vulkan/vulkan.h" + - "/usr/local/bin/vulkan/vulkan.h" + - "/usr/sbin/vulkan/vulkan.h" + - "/usr/bin/vulkan/vulkan.h" + - "/sbin/vulkan/vulkan.h" + - "/bin/vulkan/vulkan.h" + - "/usr/games/vulkan/vulkan.h" + - "/usr/local/games/vulkan/vulkan.h" + - "/snap/bin/vulkan/vulkan.h" + - "/usr/local/include/x86_64-linux-gnu/vulkan/vulkan.h" + - "/usr/local/include/vulkan/vulkan.h" + - "/usr/local/vulkan/vulkan.h" + - "/usr/include/x86_64-linux-gnu/vulkan/vulkan.h" + found: "/usr/include/" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/usr" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" + CMAKE_SYSTEM_INCLUDE_PATH: + - "/usr/include/X11" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/FindVulkan.cmake:399 (find_library)" + - "CMakeLists.txt:15 (find_package)" + mode: "library" + variable: "Vulkan_LIBRARY" + description: "Path to a library." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "vulkan" + candidate_directories: + - "/lib/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + - "/usr/local/lib/x86_64-linux-gnu/" + - "/usr/local/lib/" + - "/usr/local/" + - "/usr/lib/x86_64-linux-gnu/" + - "/usr/lib/" + - "/usr/" + - "/lib/x86_64-linux-gnu/" + - "/lib/" + - "/usr/X11R6/lib/x86_64-linux-gnu/" + - "/usr/X11R6/lib/" + - "/usr/X11R6/" + - "/usr/pkg/lib/x86_64-linux-gnu/" + - "/usr/pkg/lib/" + - "/usr/pkg/" + - "/opt/lib/x86_64-linux-gnu/" + - "/opt/lib/" + - "/opt/" + - "/usr/lib/X11/" + searched_directories: + - "/lib/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/bin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + - "/usr/local/lib/x86_64-linux-gnu/" + - "/usr/local/lib/" + - "/usr/local/" + found: "/usr/lib/x86_64-linux-gnu/libvulkan.so" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/usr" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" + CMAKE_SYSTEM_LIBRARY_PATH: + - "/usr/lib/X11" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/FindVulkan.cmake:407 (find_program)" + - "CMakeLists.txt:15 (find_package)" + mode: "program" + variable: "Vulkan_GLSLC_EXECUTABLE" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "glslc" + candidate_directories: + - "/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + - "/usr/local/bin/" + - "/usr/local/sbin/" + - "/usr/local/" + - "/usr/bin/" + - "/usr/sbin/" + - "/usr/" + - "/bin/" + - "/sbin/" + - "/usr/X11R6/bin/" + - "/usr/X11R6/sbin/" + - "/usr/X11R6/" + - "/usr/pkg/bin/" + - "/usr/pkg/sbin/" + - "/usr/pkg/" + - "/opt/bin/" + - "/opt/sbin/" + - "/opt/" + searched_directories: + - "/bin/glslc" + - "/home/itten/.opencode/bin/glslc" + - "/usr/local/sbin/glslc" + - "/usr/local/bin/glslc" + - "/usr/sbin/glslc" + - "/usr/bin/glslc" + - "/sbin/glslc" + - "/usr/games/glslc" + - "/usr/local/games/glslc" + - "/snap/bin/glslc" + - "/usr/local/bin/glslc" + - "/usr/local/sbin/glslc" + - "/usr/local/glslc" + - "/usr/bin/glslc" + - "/usr/sbin/glslc" + - "/usr/glslc" + - "/bin/glslc" + - "/sbin/glslc" + - "/usr/X11R6/bin/glslc" + - "/usr/X11R6/sbin/glslc" + - "/usr/X11R6/glslc" + - "/usr/pkg/bin/glslc" + - "/usr/pkg/sbin/glslc" + - "/usr/pkg/glslc" + - "/opt/bin/glslc" + - "/opt/sbin/glslc" + - "/opt/glslc" + found: false + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/usr" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/FindVulkan.cmake:415 (find_program)" + - "CMakeLists.txt:15 (find_package)" + mode: "program" + variable: "Vulkan_GLSLANG_VALIDATOR_EXECUTABLE" + description: "Path to a program." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "glslangValidator" + candidate_directories: + - "/bin/" + - "/home/itten/.opencode/bin/" + - "/usr/local/sbin/" + - "/usr/local/bin/" + - "/usr/sbin/" + - "/usr/bin/" + - "/sbin/" + - "/usr/games/" + - "/usr/local/games/" + - "/snap/bin/" + - "/usr/local/bin/" + - "/usr/local/sbin/" + - "/usr/local/" + - "/usr/bin/" + - "/usr/sbin/" + - "/usr/" + - "/bin/" + - "/sbin/" + - "/usr/X11R6/bin/" + - "/usr/X11R6/sbin/" + - "/usr/X11R6/" + - "/usr/pkg/bin/" + - "/usr/pkg/sbin/" + - "/usr/pkg/" + - "/opt/bin/" + - "/opt/sbin/" + - "/opt/" + found: "/bin/glslangValidator" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/usr" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" + - + kind: "find-v1" + backtrace: + - "/usr/share/cmake-4.2/Modules/FindPkgConfig.cmake:761 (find_library)" + - "/usr/share/cmake-4.2/Modules/FindPkgConfig.cmake:811 (_pkg_find_libs)" + - "/usr/share/cmake-4.2/Modules/FindPkgConfig.cmake:1149 (_pkg_recalculate)" + - "/usr/share/cmake-4.2/Modules/FindPkgConfig.cmake:1166 (_pkg_check_modules_internal)" + - "CMakeLists.txt:17 (pkg_check_modules)" + mode: "library" + variable: "pkgcfg_lib_SDL3_SDL3" + description: "Path to a library." + settings: + SearchFramework: "NEVER" + SearchAppBundle: "NEVER" + CMAKE_FIND_USE_CMAKE_PATH: true + CMAKE_FIND_USE_CMAKE_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_SYSTEM_ENVIRONMENT_PATH: true + CMAKE_FIND_USE_CMAKE_SYSTEM_PATH: true + CMAKE_FIND_USE_INSTALL_PREFIX: true + names: + - "SDL3" + candidate_directories: + - "/usr/lib/x86_64-linux-gnu/" + found: "/usr/lib/x86_64-linux-gnu/libSDL3.so" + search_context: + ENV{PATH}: + - "/home/itten/.opencode/bin" + - "/usr/local/sbin" + - "/usr/local/bin" + - "/usr/sbin" + - "/usr/bin" + - "/sbin" + - "/bin" + - "/usr/games" + - "/usr/local/games" + - "/snap/bin" + - "/snap/bin" + CMAKE_INSTALL_PREFIX: "/usr/local" + CMAKE_SYSTEM_PREFIX_PATH: + - "/usr/local" + - "/usr" + - "/" + - "/usr" + - "/usr/local" + - "/usr/X11R6" + - "/usr/pkg" + - "/opt" + CMAKE_SYSTEM_LIBRARY_PATH: + - "/usr/lib/X11" +... diff --git a/build-sdk/CMakeFiles/CMakeDirectoryInformation.cmake b/build-sdk/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000..df1ff6e --- /dev/null +++ b/build-sdk/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.2 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/itten/mxl-multiviewer") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/itten/mxl-multiviewer/build-sdk") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/build-sdk/CMakeFiles/InstallScripts.json b/build-sdk/CMakeFiles/InstallScripts.json new file mode 100644 index 0000000..cdb6924 --- /dev/null +++ b/build-sdk/CMakeFiles/InstallScripts.json @@ -0,0 +1,7 @@ +{ + "InstallScripts" : + [ + "/home/itten/mxl-multiviewer/build-sdk/cmake_install.cmake" + ], + "Parallel" : false +} diff --git a/build-sdk/CMakeFiles/Makefile.cmake b/build-sdk/CMakeFiles/Makefile.cmake new file mode 100644 index 0000000..906800b --- /dev/null +++ b/build-sdk/CMakeFiles/Makefile.cmake @@ -0,0 +1,56 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.2 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "/home/itten/mxl-multiviewer/CMakeLists.txt" + "CMakeFiles/4.2.3/CMakeCXXCompiler.cmake" + "CMakeFiles/4.2.3/CMakeSystem.cmake" + "/usr/share/cmake-4.2/Modules/CMakeCXXInformation.cmake" + "/usr/share/cmake-4.2/Modules/CMakeCommonLanguageInclude.cmake" + "/usr/share/cmake-4.2/Modules/CMakeGenericSystem.cmake" + "/usr/share/cmake-4.2/Modules/CMakeInitializeConfigs.cmake" + "/usr/share/cmake-4.2/Modules/CMakeLanguageInformation.cmake" + "/usr/share/cmake-4.2/Modules/CMakeSystemSpecificInformation.cmake" + "/usr/share/cmake-4.2/Modules/CMakeSystemSpecificInitialize.cmake" + "/usr/share/cmake-4.2/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + "/usr/share/cmake-4.2/Modules/Compiler/GNU-CXX.cmake" + "/usr/share/cmake-4.2/Modules/Compiler/GNU.cmake" + "/usr/share/cmake-4.2/Modules/FindPackageHandleStandardArgs.cmake" + "/usr/share/cmake-4.2/Modules/FindPackageMessage.cmake" + "/usr/share/cmake-4.2/Modules/FindPkgConfig.cmake" + "/usr/share/cmake-4.2/Modules/FindVulkan.cmake" + "/usr/share/cmake-4.2/Modules/Internal/CMakeCXXLinkerInformation.cmake" + "/usr/share/cmake-4.2/Modules/Internal/CMakeCommonLinkerInformation.cmake" + "/usr/share/cmake-4.2/Modules/Linker/GNU-CXX.cmake" + "/usr/share/cmake-4.2/Modules/Linker/GNU.cmake" + "/usr/share/cmake-4.2/Modules/Platform/Linker/GNU.cmake" + "/usr/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU-CXX.cmake" + "/usr/share/cmake-4.2/Modules/Platform/Linker/Linux-GNU.cmake" + "/usr/share/cmake-4.2/Modules/Platform/Linux-GNU-CXX.cmake" + "/usr/share/cmake-4.2/Modules/Platform/Linux-GNU.cmake" + "/usr/share/cmake-4.2/Modules/Platform/Linux-Initialize.cmake" + "/usr/share/cmake-4.2/Modules/Platform/Linux.cmake" + "/usr/share/cmake-4.2/Modules/Platform/UnixPaths.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/mxl_multiviewer.dir/DependInfo.cmake" + "CMakeFiles/v210_test.dir/DependInfo.cmake" + ) diff --git a/build-sdk/CMakeFiles/Makefile2 b/build-sdk/CMakeFiles/Makefile2 new file mode 100644 index 0000000..5550205 --- /dev/null +++ b/build-sdk/CMakeFiles/Makefile2 @@ -0,0 +1,157 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.2 + +# Default target executed when no arguments are given to make. +default_target: all +.PHONY : default_target + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/itten/mxl-multiviewer + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/itten/mxl-multiviewer/build-sdk + +#============================================================================= +# Directory level rules for the build root directory + +# The main recursive "all" target. +all: CMakeFiles/mxl_multiviewer.dir/all +all: CMakeFiles/v210_test.dir/all +.PHONY : all + +# The main recursive "codegen" target. +codegen: CMakeFiles/mxl_multiviewer.dir/codegen +codegen: CMakeFiles/v210_test.dir/codegen +.PHONY : codegen + +# The main recursive "preinstall" target. +preinstall: +.PHONY : preinstall + +# The main recursive "clean" target. +clean: CMakeFiles/mxl_multiviewer.dir/clean +clean: CMakeFiles/v210_test.dir/clean +.PHONY : clean + +#============================================================================= +# Target rules for target CMakeFiles/mxl_multiviewer.dir + +# All Build rule for target. +CMakeFiles/mxl_multiviewer.dir/all: + $(MAKE) $(MAKESILENT) -f CMakeFiles/mxl_multiviewer.dir/build.make CMakeFiles/mxl_multiviewer.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/mxl_multiviewer.dir/build.make CMakeFiles/mxl_multiviewer.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22 "Built target mxl_multiviewer" +.PHONY : CMakeFiles/mxl_multiviewer.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/mxl_multiviewer.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/itten/mxl-multiviewer/build-sdk/CMakeFiles 22 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/mxl_multiviewer.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/itten/mxl-multiviewer/build-sdk/CMakeFiles 0 +.PHONY : CMakeFiles/mxl_multiviewer.dir/rule + +# Convenience name for target. +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/rule +.PHONY : mxl_multiviewer + +# codegen rule for target. +CMakeFiles/mxl_multiviewer.dir/codegen: + $(MAKE) $(MAKESILENT) -f CMakeFiles/mxl_multiviewer.dir/build.make CMakeFiles/mxl_multiviewer.dir/codegen + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22 "Finished codegen for target mxl_multiviewer" +.PHONY : CMakeFiles/mxl_multiviewer.dir/codegen + +# clean rule for target. +CMakeFiles/mxl_multiviewer.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/mxl_multiviewer.dir/build.make CMakeFiles/mxl_multiviewer.dir/clean +.PHONY : CMakeFiles/mxl_multiviewer.dir/clean + +#============================================================================= +# Target rules for target CMakeFiles/v210_test.dir + +# All Build rule for target. +CMakeFiles/v210_test.dir/all: + $(MAKE) $(MAKESILENT) -f CMakeFiles/v210_test.dir/build.make CMakeFiles/v210_test.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/v210_test.dir/build.make CMakeFiles/v210_test.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=23,24 "Built target v210_test" +.PHONY : CMakeFiles/v210_test.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/v210_test.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/itten/mxl-multiviewer/build-sdk/CMakeFiles 2 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/v210_test.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/itten/mxl-multiviewer/build-sdk/CMakeFiles 0 +.PHONY : CMakeFiles/v210_test.dir/rule + +# Convenience name for target. +v210_test: CMakeFiles/v210_test.dir/rule +.PHONY : v210_test + +# codegen rule for target. +CMakeFiles/v210_test.dir/codegen: + $(MAKE) $(MAKESILENT) -f CMakeFiles/v210_test.dir/build.make CMakeFiles/v210_test.dir/codegen + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=23,24 "Finished codegen for target v210_test" +.PHONY : CMakeFiles/v210_test.dir/codegen + +# clean rule for target. +CMakeFiles/v210_test.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/v210_test.dir/build.make CMakeFiles/v210_test.dir/clean +.PHONY : CMakeFiles/v210_test.dir/clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/build-sdk/CMakeFiles/TargetDirectories.txt b/build-sdk/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000..627d81a --- /dev/null +++ b/build-sdk/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,4 @@ +/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir +/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/v210_test.dir +/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/edit_cache.dir +/home/itten/mxl-multiviewer/build-sdk/CMakeFiles/rebuild_cache.dir diff --git a/build-sdk/CMakeFiles/cmake.check_cache b/build-sdk/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000..3dccd73 --- /dev/null +++ b/build-sdk/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..1ea7a101725e67b2a64f3fcbffb01961d2950f80 GIT binary patch literal 403472 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 literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/FakeFeed.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/FakeFeed.cpp.o.d new file mode 100644 index 0000000..0670620 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/FakeFeed.cpp.o.d @@ -0,0 +1,73 @@ +CMakeFiles/mxl_multiviewer.dir/FakeFeed.cpp.o: \ + /home/itten/mxl-multiviewer/FakeFeed.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/FakeFeed.hpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/15/vector /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/version.h /usr/include/c++/15/type_traits \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/utility.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/stl_iterator.h /usr/include/c++/15/new \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h \ + /home/itten/mxl-multiviewer/PixelFormat.hpp diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..0bfed6559df2c19aa13b20bda7818870db2a84d3 GIT binary patch literal 339560 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

?`Qf_q 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 N2GSq9_Ti%a{~xl9z77BY literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedFactory.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedFactory.cpp.o.d new file mode 100644 index 0000000..a33eeed --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedFactory.cpp.o.d @@ -0,0 +1,226 @@ +CMakeFiles/mxl_multiviewer.dir/FeedFactory.cpp.o: \ + /home/itten/mxl-multiviewer/FeedFactory.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/FeedFactory.hpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/15/vector /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/version.h /usr/include/c++/15/type_traits \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/utility.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/stl_iterator.h /usr/include/c++/15/new \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h /usr/include/c++/15/memory \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/stl_raw_storage_iter.h \ + /usr/include/c++/15/bits/align.h /usr/include/c++/15/bits/unique_ptr.h \ + /usr/include/c++/15/bits/ostream.h /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/postypes.h /usr/include/c++/15/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/exception /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/typeinfo /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/cctype \ + /usr/include/ctype.h /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ios_base.h /usr/include/c++/15/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/15/bits/locale_classes.h /usr/include/c++/15/string \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/basic_string.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/system_error \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/c++/15/stdexcept /usr/include/c++/15/streambuf \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/locale_facets.h /usr/include/c++/15/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/shared_ptr.h \ + /usr/include/c++/15/bits/shared_ptr_base.h \ + /usr/include/c++/15/bits/allocated_ptr.h \ + /usr/include/c++/15/ext/aligned_buffer.h \ + /usr/include/c++/15/ext/concurrence.h \ + /usr/include/c++/15/bits/shared_ptr_atomic.h \ + /usr/include/c++/15/bits/atomic_base.h \ + /usr/include/c++/15/bits/atomic_lockfree_defines.h \ + /usr/include/c++/15/bits/atomic_wait.h /usr/include/c++/15/climits \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h \ + /usr/include/limits.h /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/linux/limits.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/linux/close_range.h /usr/include/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/c++/15/bits/std_mutex.h \ + /usr/include/c++/15/backward/auto_ptr.h \ + /usr/include/c++/15/bits/ranges_uninitialized.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/pstl/glue_memory_defs.h \ + /usr/include/c++/15/pstl/execution_defs.h /usr/include/c++/15/optional \ + /usr/include/c++/15/bits/enable_special_members.h \ + /home/itten/mxl-multiviewer/FakeFeed.hpp \ + /home/itten/mxl-multiviewer/MxlFeed.hpp \ + /home/itten/mxl-multiviewer/MxlSdkFeed.hpp \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h \ + /home/itten/mxl-multiviewer/SmpteBarsFeed.hpp \ + /usr/include/c++/15/iostream /usr/include/c++/15/ostream \ + /usr/include/c++/15/bits/ostream.tcc /usr/include/c++/15/istream \ + /usr/include/c++/15/bits/istream.tcc diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..6434d7713d553cc02986fbba3ec28857472b456b GIT binary patch literal 392392 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

P*6 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 )$W2(*Js43}Uh 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 z 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

9nQZ}^D|0oUYw+J~F=ZWj0teYn9}LEs

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 SdSTao&PdYz*7E5Gw*P+%8y8jp literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o.d new file mode 100644 index 0000000..462d2a6 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o.d @@ -0,0 +1,193 @@ +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o: \ + /home/itten/mxl-multiviewer/MxlInstanceCache.cpp \ + /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/MxlInstanceCache.hpp \ + /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/15/string /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/postypes.h /usr/include/c++/15/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/type_traits /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/compare /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_construct.h /usr/include/c++/15/new \ + /usr/include/c++/15/bits/exception.h /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/refwrap.h /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h /usr/include/c++/15/vector \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/vector.tcc \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h \ + /usr/include/c++/15/algorithm /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/ranges_algo.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/pstl/glue_algorithm_defs.h \ + /usr/include/c++/15/pstl/execution_defs.h /usr/include/c++/15/iostream \ + /usr/include/c++/15/ostream /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/ios /usr/include/c++/15/exception \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/typeinfo /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/ios_base.h /usr/include/c++/15/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/system_error \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/c++/15/stdexcept /usr/include/c++/15/streambuf \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/locale_facets.h /usr/include/c++/15/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/ostream.tcc /usr/include/c++/15/istream \ + /usr/include/c++/15/bits/istream.tcc diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..5069bda572c5cec01250708a14db54d6ad0208c3 GIT binary patch literal 472680 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

SQ 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 literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o.d new file mode 100644 index 0000000..429f469 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o.d @@ -0,0 +1,133 @@ +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o: \ + /home/itten/mxl-multiviewer/NoSignalFeed.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/NoSignalFeed.hpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/15/vector /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/version.h /usr/include/c++/15/type_traits \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/utility.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/stl_iterator.h /usr/include/c++/15/new \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h /usr/include/c++/15/string \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/postypes.h /usr/include/c++/15/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/basic_string.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /home/itten/mxl-multiviewer/PixelFormat.hpp diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..fdbc5b75d0031b1d3b02a4131b3f303c91395081 GIT binary patch literal 571728 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%0D1OROd%Dsl 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

  • 91u_S!k#n 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

    n3~y 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 z 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 literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o.d new file mode 100644 index 0000000..919c573 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o.d @@ -0,0 +1,133 @@ +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o: \ + /home/itten/mxl-multiviewer/SmpteBarsFeed.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/SmpteBarsFeed.hpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/15/vector /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/version.h /usr/include/c++/15/type_traits \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/utility.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/stl_iterator.h /usr/include/c++/15/new \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h /usr/include/c++/15/string \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/postypes.h /usr/include/c++/15/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/basic_string.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /home/itten/mxl-multiviewer/PixelFormat.hpp /usr/include/c++/15/array diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..0665dfea4cfd4ee4493466522912409f7ce4a021 GIT binary patch literal 724120 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 literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o.d new file mode 100644 index 0000000..08ca1a8 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o.d @@ -0,0 +1,198 @@ +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o: \ + /home/itten/mxl-multiviewer/V210ComputeDecoder.cpp \ + /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/V210ComputeDecoder.hpp \ + /usr/include/vulkan/vulkan.h /usr/include/vulkan/vk_platform.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h /usr/include/c++/15/vector \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/version.h /usr/include/c++/15/type_traits \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/utility.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/stl_iterator.h /usr/include/c++/15/new \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h \ + /home/itten/mxl-multiviewer/VulkanUtils.hpp /usr/include/c++/15/fstream \ + /usr/include/c++/15/istream /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/postypes.h /usr/include/c++/15/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/exception /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/typeinfo /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/cctype \ + /usr/include/ctype.h /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ios_base.h /usr/include/c++/15/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/15/bits/locale_classes.h /usr/include/c++/15/string \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/basic_string.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/system_error \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/c++/15/stdexcept /usr/include/c++/15/streambuf \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/locale_facets.h /usr/include/c++/15/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/basic_ios.tcc /usr/include/c++/15/ostream \ + /usr/include/c++/15/bits/ostream.h /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/istream.tcc /usr/include/c++/15/bits/codecvt.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h \ + /usr/include/c++/15/bits/fstream.tcc /usr/include/c++/15/iostream diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..06c1391805fb0eae09d82e84e9a20c2d712de194 GIT binary patch literal 905480 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 W3k?EqM01 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

    {viMNzlYfz&$^pP(UqUfv z@R7wh^8bzdXuDgQ)0$<+)|! zyY-}#YbzXY)i#Uxaa-PaCwv+bghy5`_;WQPh8)QDX^Vrl0fW62JyT%3MY02px5vZL z2qQta%VviSrnTD4tCC8xSi z9^kJx8Jwu>QywSx;3dAQHd-L zacg5&xD16uO-DM+NL=Sqr@?|{0C>l4fxcRP#e`;rNe@6|NxEoFx}~P;;RySj3fr4E zliS&ipzdtHX_)4z%WhdXGbda*x3kmorXi*sr&k zWoc0YEIc)u&{(Fn-OQEUyhc&Hbjrwbc7j}=u#_;b3PQ{iWHegTVC;zFbgg8)aw9(U z&iZdTzr!BqCe`Q}+|e&P=Fb-7s$R}?{6ulg$vtvaBCxH>70lBjR2BSC1VQ%!%fl#D zapsd=?c#x@Tp@jlNt>d(SU7ndZf<1-<#$ac@wLGr>gWdmy&w@mM>vfrcvlVc{cQtm zx8_|OQ^-^X5@$k6A&n*BwBn1`=-#+`%iRl1Q7Fl-twRQXw`NzIc%6@DK*%!@Nq&0( zLKE*<5_j96Bx>U-S4!|BR-Fy@N+c+A>=Ql3B% zoa(W2zcMWyf9&LaM|`paRNDK~zFyvA4y@&yMDE$Ho9jOpA0hU-D<2TG>XpMU`If8J|Z;=9)C7o+JF>iIal<2gnb$t5nQ ze{FA1{|tpYjsUZAO7RAnZ$~puZ%ikw#fpaJ6B@#p1uj; z!;0YljUf33*&P|~=mGX?kgn>;6|AN>qSCjl3|2}`3kl@Rcy#B`Lfrw6bf;3uL+gzy z+$d{DK0?V{Y^QhJgQ#hQ;hjUkTv!(x1JeO~M?3ajm48Xs;~qcqoa%s|47pXF4KRzq z;{`(x5)b!Z&n*8lMp+&gFh661Lxtn<{+u;CjZ;-8(pnrO3BlibGQJ1d=@k;{-KNEJ zVu>W9yKYk|R$VAfVwy$O>||^vzZf17L5ijsmA;G$2nPt4oilRM0#32GQrtpsXWkX8 zh9$9Se%OC0*@sb>;ER&7S@fj3MHf^_AakAkY=q|^1lDWbBpj#TI%A>TIoyQUIP@OQ4P@U49_2x} z*iYXNr^{UFT0M3Acz-`%EcFa_w*P#bE`F7y;MF4J+4f#&YrwY+Jrvr9_eYp;gix;x zor90()!7QJ9p`gAy~T8h=+g*HmU^T(DYtec43~+l^2U4{A7=Ic{(q{c-_XlZp?7Sv z`<7PKS{-6#xXy6!)vB8pw%kVuYr^_Xg7*6@@?ZNKaqwULdY736cpwWg3!C^5u0JM?wMk;kRs>3?+rimWNRfiBrUn+4@To zaL>)LG*PAOy`J1WOa(@yeuSQp7RQ(YA=9az&}!XYS!$_~jxV&UzWkwZoMw#+Aqz^< zGhN~S!ZdTnWOF~q+vVo7dTAKM5?lWKAl5LHtY$KkI0k0m$K)4y82)^m$jGEy{-A##xXZ4|1>zx>t_5;Y< zEQeHQ$5|Uv$C8!Qp?n}Y+--AlM)S{)4@*pde~>nW{pr`q6G-bTH%G6c;lyesSGfX; z2&YKJEm*tCtlOkB4%7w6>G4v6>-+xe?D9eU8m>3F!Vv@>vdEkuntXyGA>|H+#jzbq zOg+4NvY?qzF~IDm3yBf3(@?jGX-hO`1CuI#rEr(;>IMMc?&N376+Rts{fg2V3d^Hi zBV=Eg%}uDJD&7mAP8`Kd%p!nJ_%Ey$sk|$YD9#c4OPSC*M=HUULOA~u7|z@UKn_m- z3OP$L4<2__R$%?(3B3{yVa@FYx!YTBz|L+f9@aT}1a_#Z8N5Ror9c@yG6+#ZE_16r1h&47PhT*%JKDXlnuKL3O#bNaR z9Xp=e(XPeeXO1p&AQy^q3F{XLtB>qz%iCb^yHz5Ux4`)Zx0>_$ck~9}Cd-^}9Wpt% znR1>p@9^c%iNoop&GhFbI<0U;YNzG`WyXPp?lImswH0csggPfQ;wB?ZL6#8*>JUvV zWFf`AxQFUAp%J-SJ}K^gZwHnX)lQgF?*#%>xc?4~p?LB4v*{1|><1tclsW8p?{yl) z)Ccz=#Ily+&T*je2RN^+8lhoK{+SE3

    E)ZJV@f8jvhqDImL* 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 O*^?aqJ(Qn4T>XD{XnI2c literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o.d new file mode 100644 index 0000000..7b0f131 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o.d @@ -0,0 +1,225 @@ +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o: \ + /home/itten/mxl-multiviewer/VulkanContext.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/VulkanContext.hpp \ + /usr/include/vulkan/vulkan.h /usr/include/vulkan/vk_platform.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h /usr/include/c++/15/iostream \ + /usr/include/c++/15/bits/requires_hosted.h /usr/include/c++/15/ostream \ + /usr/include/c++/15/bits/ostream.h /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/memoryfwd.h /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/cwchar /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/exception /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/typeinfo /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/new /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/char_traits.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/cctype \ + /usr/include/ctype.h /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ios_base.h /usr/include/c++/15/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/15/bits/locale_classes.h /usr/include/c++/15/string \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/refwrap.h /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/system_error \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/c++/15/stdexcept /usr/include/c++/15/streambuf \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/locale_facets.h /usr/include/c++/15/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/ostream.tcc /usr/include/c++/15/istream \ + /usr/include/c++/15/bits/istream.tcc /usr/include/c++/15/optional \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/vector /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/vector.tcc /usr/include/SDL3/SDL.h \ + /usr/include/SDL3/SDL_stdinc.h /usr/include/SDL3/SDL_platform_defines.h \ + /usr/include/string.h /usr/include/strings.h \ + /usr/include/SDL3/SDL_begin_code.h /usr/include/SDL3/SDL_close_code.h \ + /usr/include/SDL3/SDL_assert.h /usr/include/SDL3/SDL_asyncio.h \ + /usr/include/SDL3/SDL_atomic.h /usr/include/SDL3/SDL_audio.h \ + /usr/include/SDL3/SDL_endian.h /usr/include/SDL3/SDL_error.h \ + /usr/include/SDL3/SDL_mutex.h /usr/include/SDL3/SDL_thread.h \ + /usr/include/SDL3/SDL_properties.h /usr/include/SDL3/SDL_iostream.h \ + /usr/include/SDL3/SDL_bits.h /usr/include/SDL3/SDL_blendmode.h \ + /usr/include/SDL3/SDL_camera.h /usr/include/SDL3/SDL_pixels.h \ + /usr/include/SDL3/SDL_surface.h /usr/include/SDL3/SDL_rect.h \ + /usr/include/SDL3/SDL_clipboard.h /usr/include/SDL3/SDL_cpuinfo.h \ + /usr/include/SDL3/SDL_dialog.h /usr/include/SDL3/SDL_video.h \ + /usr/include/SDL3/SDL_dlopennote.h /usr/include/SDL3/SDL_events.h \ + /usr/include/SDL3/SDL_gamepad.h /usr/include/SDL3/SDL_guid.h \ + /usr/include/SDL3/SDL_joystick.h /usr/include/SDL3/SDL_power.h \ + /usr/include/SDL3/SDL_sensor.h /usr/include/SDL3/SDL_keyboard.h \ + /usr/include/SDL3/SDL_keycode.h /usr/include/SDL3/SDL_scancode.h \ + /usr/include/SDL3/SDL_mouse.h /usr/include/SDL3/SDL_pen.h \ + /usr/include/SDL3/SDL_touch.h /usr/include/SDL3/SDL_filesystem.h \ + /usr/include/SDL3/SDL_gpu.h /usr/include/SDL3/SDL_haptic.h \ + /usr/include/SDL3/SDL_hidapi.h /usr/include/SDL3/SDL_hints.h \ + /usr/include/SDL3/SDL_init.h /usr/include/SDL3/SDL_loadso.h \ + /usr/include/SDL3/SDL_locale.h /usr/include/SDL3/SDL_log.h \ + /usr/include/SDL3/SDL_messagebox.h /usr/include/SDL3/SDL_metal.h \ + /usr/include/SDL3/SDL_misc.h /usr/include/SDL3/SDL_platform.h \ + /usr/include/SDL3/SDL_process.h /usr/include/SDL3/SDL_render.h \ + /usr/include/SDL3/SDL_storage.h /usr/include/SDL3/SDL_system.h \ + /usr/include/SDL3/SDL_time.h /usr/include/SDL3/SDL_timer.h \ + /usr/include/SDL3/SDL_tray.h /usr/include/SDL3/SDL_version.h \ + /usr/include/SDL3/SDL_oldnames.h /usr/include/SDL3/SDL_vulkan.h diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..af1047c28d4a2800d70517b4710ca001cc0a2fb8 GIT binary patch literal 373016 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 bog&b} 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 LCjNd3pZ|XVoW_V= literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o.d new file mode 100644 index 0000000..4513449 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o.d @@ -0,0 +1,149 @@ +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o: \ + /home/itten/mxl-multiviewer/VulkanUtils.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/VulkanUtils.hpp /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/exception /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/typeinfo /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/new /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/bits/nested_exception.h /usr/include/c++/15/string \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/postypes.h /usr/include/c++/15/cwchar \ + /usr/include/wchar.h /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/compare /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/cctype /usr/include/ctype.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/refwrap.h /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/build.make b/build-sdk/CMakeFiles/mxl_multiviewer.dir/build.make new file mode 100644 index 0000000..06f74b8 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/build.make @@ -0,0 +1,435 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.2 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + +# Disable VCS-based implicit rules. +% : %,v + +# Disable VCS-based implicit rules. +% : RCS/% + +# Disable VCS-based implicit rules. +% : RCS/%,v + +# Disable VCS-based implicit rules. +% : SCCS/s.% + +# Disable VCS-based implicit rules. +% : s.% + +.SUFFIXES: .hpux_make_needs_suffix_list + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/itten/mxl-multiviewer + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/itten/mxl-multiviewer/build-sdk + +# Include any dependencies generated for this target. +include CMakeFiles/mxl_multiviewer.dir/depend.make +# Include any dependencies generated by the compiler for this target. +include CMakeFiles/mxl_multiviewer.dir/compiler_depend.make + +# Include the progress variables for this target. +include CMakeFiles/mxl_multiviewer.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/mxl_multiviewer.dir/flags.make + +CMakeFiles/mxl_multiviewer.dir/codegen: +.PHONY : CMakeFiles/mxl_multiviewer.dir/codegen + +CMakeFiles/mxl_multiviewer.dir/main.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/main.cpp.o: /home/itten/mxl-multiviewer/main.cpp +CMakeFiles/mxl_multiviewer.dir/main.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/mxl_multiviewer.dir/main.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/main.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/main.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/main.cpp.o -c /home/itten/mxl-multiviewer/main.cpp + +CMakeFiles/mxl_multiviewer.dir/main.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/main.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/main.cpp > CMakeFiles/mxl_multiviewer.dir/main.cpp.i + +CMakeFiles/mxl_multiviewer.dir/main.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/main.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/main.cpp -o CMakeFiles/mxl_multiviewer.dir/main.cpp.s + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui.cpp +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -MD -MT CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o -c /home/itten/mxl-multiviewer/imgui/imgui.cpp + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -E /home/itten/mxl-multiviewer/imgui/imgui.cpp > CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.i + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -S /home/itten/mxl-multiviewer/imgui/imgui.cpp -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.s + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui_draw.cpp +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -MD -MT CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o -c /home/itten/mxl-multiviewer/imgui/imgui_draw.cpp + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -E /home/itten/mxl-multiviewer/imgui/imgui_draw.cpp > CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.i + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -S /home/itten/mxl-multiviewer/imgui/imgui_draw.cpp -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.s + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui_tables.cpp +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -MD -MT CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o -c /home/itten/mxl-multiviewer/imgui/imgui_tables.cpp + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -E /home/itten/mxl-multiviewer/imgui/imgui_tables.cpp > CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.i + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -S /home/itten/mxl-multiviewer/imgui/imgui_tables.cpp -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.s + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui_widgets.cpp +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -MD -MT CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o -c /home/itten/mxl-multiviewer/imgui/imgui_widgets.cpp + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -E /home/itten/mxl-multiviewer/imgui/imgui_widgets.cpp > CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.i + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -S /home/itten/mxl-multiviewer/imgui/imgui_widgets.cpp -o CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.s + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o: /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -MD -MT CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o -c /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -E /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp > CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.i + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -S /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp -o CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.s + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o: /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.cpp +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Building CXX object CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -MD -MT CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o -c /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.cpp + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -E /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.cpp > CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.i + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -w -S /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.cpp -o CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.s + +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o: /home/itten/mxl-multiviewer/AppConfig.cpp +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "Building CXX object CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o -c /home/itten/mxl-multiviewer/AppConfig.cpp + +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/AppConfig.cpp > CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.i + +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/AppConfig.cpp -o CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.s + +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o: /home/itten/mxl-multiviewer/FeedCreate.cpp +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Building CXX object CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o -c /home/itten/mxl-multiviewer/FeedCreate.cpp + +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/FeedCreate.cpp > CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.i + +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/FeedCreate.cpp -o CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.s + +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o: /home/itten/mxl-multiviewer/FeedTexture.cpp +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_10) "Building CXX object CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o -c /home/itten/mxl-multiviewer/FeedTexture.cpp + +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/FeedTexture.cpp > CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.i + +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/FeedTexture.cpp -o CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.s + +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o: /home/itten/mxl-multiviewer/NoSignalFeed.cpp +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_11) "Building CXX object CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o -c /home/itten/mxl-multiviewer/NoSignalFeed.cpp + +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/NoSignalFeed.cpp > CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.i + +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/NoSignalFeed.cpp -o CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.s + +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o: /home/itten/mxl-multiviewer/MxlFeed.cpp +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_12) "Building CXX object CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o -c /home/itten/mxl-multiviewer/MxlFeed.cpp + +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/MxlFeed.cpp > CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.i + +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/MxlFeed.cpp -o CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.s + +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o: /home/itten/mxl-multiviewer/MxlInstanceCache.cpp +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_13) "Building CXX object CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o -c /home/itten/mxl-multiviewer/MxlInstanceCache.cpp + +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/MxlInstanceCache.cpp > CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.i + +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/MxlInstanceCache.cpp -o CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.s + +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o: /home/itten/mxl-multiviewer/MxlSdkFeed.cpp +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_14) "Building CXX object CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o -c /home/itten/mxl-multiviewer/MxlSdkFeed.cpp + +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/MxlSdkFeed.cpp > CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.i + +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/MxlSdkFeed.cpp -o CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.s + +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o: /home/itten/mxl-multiviewer/SmpteBarsFeed.cpp +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_15) "Building CXX object CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o -c /home/itten/mxl-multiviewer/SmpteBarsFeed.cpp + +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/SmpteBarsFeed.cpp > CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.i + +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/SmpteBarsFeed.cpp -o CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.s + +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o: /home/itten/mxl-multiviewer/TileLayout.cpp +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_16) "Building CXX object CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o -c /home/itten/mxl-multiviewer/TileLayout.cpp + +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/TileLayout.cpp > CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.i + +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/TileLayout.cpp -o CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.s + +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o: /home/itten/mxl-multiviewer/VulkanContext.cpp +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_17) "Building CXX object CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o -c /home/itten/mxl-multiviewer/VulkanContext.cpp + +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/VulkanContext.cpp > CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.i + +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/VulkanContext.cpp -o CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.s + +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o: /home/itten/mxl-multiviewer/VulkanUtils.cpp +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_18) "Building CXX object CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o -c /home/itten/mxl-multiviewer/VulkanUtils.cpp + +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/VulkanUtils.cpp > CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.i + +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/VulkanUtils.cpp -o CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.s + +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o: /home/itten/mxl-multiviewer/Swapchain.cpp +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_19) "Building CXX object CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o -c /home/itten/mxl-multiviewer/Swapchain.cpp + +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/Swapchain.cpp > CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.i + +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/Swapchain.cpp -o CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.s + +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o: /home/itten/mxl-multiviewer/RenderPipeline.cpp +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_20) "Building CXX object CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o -c /home/itten/mxl-multiviewer/RenderPipeline.cpp + +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/RenderPipeline.cpp > CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.i + +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/RenderPipeline.cpp -o CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.s + +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o: CMakeFiles/mxl_multiviewer.dir/flags.make +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o: /home/itten/mxl-multiviewer/V210ComputeDecoder.cpp +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_21) "Building CXX object CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o -MF CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o.d -o CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o -c /home/itten/mxl-multiviewer/V210ComputeDecoder.cpp + +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.i" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/itten/mxl-multiviewer/V210ComputeDecoder.cpp > CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.i + +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.s" + /usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/itten/mxl-multiviewer/V210ComputeDecoder.cpp -o CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.s + +# Object files for target mxl_multiviewer +mxl_multiviewer_OBJECTS = \ +"CMakeFiles/mxl_multiviewer.dir/main.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o" \ +"CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o" + +# External object files for target mxl_multiviewer +mxl_multiviewer_EXTERNAL_OBJECTS = + +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/main.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/build.make +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts +mxl_multiviewer: /usr/lib/x86_64-linux-gnu/libvulkan.so +mxl_multiviewer: CMakeFiles/mxl_multiviewer.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/itten/mxl-multiviewer/build-sdk/CMakeFiles --progress-num=$(CMAKE_PROGRESS_22) "Linking CXX executable mxl_multiviewer" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/mxl_multiviewer.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +CMakeFiles/mxl_multiviewer.dir/build: mxl_multiviewer +.PHONY : CMakeFiles/mxl_multiviewer.dir/build + +CMakeFiles/mxl_multiviewer.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/mxl_multiviewer.dir/cmake_clean.cmake +.PHONY : CMakeFiles/mxl_multiviewer.dir/clean + +CMakeFiles/mxl_multiviewer.dir/depend: + cd /home/itten/mxl-multiviewer/build-sdk && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/itten/mxl-multiviewer /home/itten/mxl-multiviewer /home/itten/mxl-multiviewer/build-sdk /home/itten/mxl-multiviewer/build-sdk /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/DependInfo.cmake "--color=$(COLOR)" mxl_multiviewer +.PHONY : CMakeFiles/mxl_multiviewer.dir/depend + diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/cmake_clean.cmake b/build-sdk/CMakeFiles/mxl_multiviewer.dir/cmake_clean.cmake new file mode 100644 index 0000000..e81c8c0 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/cmake_clean.cmake @@ -0,0 +1,52 @@ +file(REMOVE_RECURSE + "CMakeFiles/mxl_multiviewer.dir/link.d" + "CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o.d" + "CMakeFiles/mxl_multiviewer.dir/main.cpp.o" + "CMakeFiles/mxl_multiviewer.dir/main.cpp.o.d" + "mxl_multiviewer" + "mxl_multiviewer.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/mxl_multiviewer.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.internal b/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.internal new file mode 100644 index 0000000..695c98b --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.internal @@ -0,0 +1,4843 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.2 + +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o + /home/itten/mxl-multiviewer/AppConfig.cpp + /home/itten/mxl-multiviewer/AppConfig.hpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/enable_special_members.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/optional + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/time.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o + /home/itten/mxl-multiviewer/FeedCreate.cpp + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h + /home/itten/mxl-multiviewer/AppConfig.hpp + /home/itten/mxl-multiviewer/FeedCreate.hpp + /home/itten/mxl-multiviewer/IVideoFeed.hpp + /home/itten/mxl-multiviewer/MxlFeed.hpp + /home/itten/mxl-multiviewer/MxlSdkFeed.hpp + /home/itten/mxl-multiviewer/NoSignalFeed.hpp + /home/itten/mxl-multiviewer/SmpteBarsFeed.hpp + /home/itten/mxl-multiviewer/VideoFrame.hpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/backward/auto_ptr.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/align.h + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocated_ptr.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/atomic_base.h + /usr/include/c++/15/bits/atomic_lockfree_defines.h + /usr/include/c++/15/bits/atomic_wait.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/enable_special_members.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_algobase.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_uninitialized.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/shared_ptr.h + /usr/include/c++/15/bits/shared_ptr_atomic.h + /usr/include/c++/15/bits/shared_ptr_base.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/std_mutex.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_raw_storage_iter.h + /usr/include/c++/15/bits/stl_tempbuf.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/unique_ptr.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/climits + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/aligned_buffer.h + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/concurrence.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/memory + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/optional + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/execution_defs.h + /usr/include/c++/15/pstl/glue_memory_defs.h + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o + /home/itten/mxl-multiviewer/FeedTexture.cpp + /home/itten/mxl-multiviewer/FeedTexture.hpp + /home/itten/mxl-multiviewer/VideoFrame.hpp + /home/itten/mxl-multiviewer/VulkanUtils.hpp + /usr/include/alloca.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cstring + /usr/include/c++/15/cwchar + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/iosfwd + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/locale.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/wchar.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o + /home/itten/mxl-multiviewer/MxlFeed.cpp + /home/itten/mxl-multiviewer/IVideoFeed.hpp + /home/itten/mxl-multiviewer/MxlFeed.hpp + /home/itten/mxl-multiviewer/PixelFormat.hpp + /home/itten/mxl-multiviewer/VideoFrame.hpp + /usr/include/alloca.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/iosfwd + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/locale.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/wchar.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o + /home/itten/mxl-multiviewer/MxlInstanceCache.cpp + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h + /home/itten/mxl-multiviewer/MxlInstanceCache.hpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/algorithm + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/algorithmfwd.h + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_algo.h + /usr/include/c++/15/bits/ranges_algobase.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algo.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_heap.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_tempbuf.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uniform_int_dist.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/execution_defs.h + /usr/include/c++/15/pstl/glue_algorithm_defs.h + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/time.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o + /home/itten/mxl-multiviewer/MxlSdkFeed.cpp + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h + /home/itten/mxl-multiviewer/IVideoFeed.hpp + /home/itten/mxl-multiviewer/MxlInstanceCache.hpp + /home/itten/mxl-multiviewer/MxlSdkFeed.hpp + /home/itten/mxl-multiviewer/PixelFormat.hpp + /home/itten/mxl-multiviewer/VideoFrame.hpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/array + /usr/include/c++/15/atomic + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/algorithmfwd.h + /usr/include/c++/15/bits/align.h + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocated_ptr.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/atomic_base.h + /usr/include/c++/15/bits/atomic_lockfree_defines.h + /usr/include/c++/15/bits/atomic_timed_wait.h + /usr/include/c++/15/bits/atomic_wait.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/chrono.h + /usr/include/c++/15/bits/chrono_io.h + /usr/include/c++/15/bits/codecvt.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/enable_special_members.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/formatfwd.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_conv.h + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/locale_facets_nonio.h + /usr/include/c++/15/bits/locale_facets_nonio.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/monostate.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/parse_numbers.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/quoted_string.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_algobase.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/semaphore_base.h + /usr/include/c++/15/bits/shared_ptr.h + /usr/include/c++/15/bits/shared_ptr_base.h + /usr/include/c++/15/bits/sstream.tcc + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/std_mutex.h + /usr/include/c++/15/bits/std_thread.h + /usr/include/c++/15/bits/stl_algo.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_heap.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_tempbuf.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/this_thread_sleep.h + /usr/include/c++/15/bits/unicode-data.h + /usr/include/c++/15/bits/unicode.h + /usr/include/c++/15/bits/uniform_int_dist.h + /usr/include/c++/15/bits/unique_ptr.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/charconv + /usr/include/c++/15/chrono + /usr/include/c++/15/climits + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cstring + /usr/include/c++/15/ctime + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/aligned_buffer.h + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/concurrence.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/format + /usr/include/c++/15/initializer_list + /usr/include/c++/15/iomanip + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/limits + /usr/include/c++/15/locale + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/optional + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/ratio + /usr/include/c++/15/semaphore + /usr/include/c++/15/span + /usr/include/c++/15/sstream + /usr/include/c++/15/stdexcept + /usr/include/c++/15/stop_token + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/thread + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/semaphore.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/semaphore.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/time.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o + /home/itten/mxl-multiviewer/NoSignalFeed.cpp + /home/itten/mxl-multiviewer/IVideoFeed.hpp + /home/itten/mxl-multiviewer/NoSignalFeed.hpp + /home/itten/mxl-multiviewer/PixelFormat.hpp + /home/itten/mxl-multiviewer/VideoFrame.hpp + /usr/include/alloca.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/iosfwd + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/locale.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/wchar.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o + /home/itten/mxl-multiviewer/RenderPipeline.cpp + /home/itten/mxl-multiviewer/RenderPipeline.hpp + /home/itten/mxl-multiviewer/TileLayout.hpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/array + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/codecvt.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/fstream.tcc + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cstring + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/fstream + /usr/include/c++/15/initializer_list + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/time.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o + /home/itten/mxl-multiviewer/SmpteBarsFeed.cpp + /home/itten/mxl-multiviewer/IVideoFeed.hpp + /home/itten/mxl-multiviewer/PixelFormat.hpp + /home/itten/mxl-multiviewer/SmpteBarsFeed.hpp + /home/itten/mxl-multiviewer/VideoFrame.hpp + /usr/include/alloca.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/c++/15/array + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/iosfwd + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/locale.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/wchar.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o + /home/itten/mxl-multiviewer/Swapchain.cpp + /home/itten/mxl-multiviewer/Swapchain.hpp + /home/itten/mxl-multiviewer/VulkanContext.hpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/algorithm + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/algorithmfwd.h + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/enable_special_members.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_algo.h + /usr/include/c++/15/bits/ranges_algobase.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algo.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_heap.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_tempbuf.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uniform_int_dist.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/optional + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/execution_defs.h + /usr/include/c++/15/pstl/glue_algorithm_defs.h + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/time.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o + /home/itten/mxl-multiviewer/TileLayout.cpp + /home/itten/mxl-multiviewer/TileLayout.hpp + /usr/include/alloca.h + /usr/include/c++/15/algorithm + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/algorithmfwd.h + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_algo.h + /usr/include/c++/15/bits/ranges_algobase.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/specfun.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algo.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_heap.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_tempbuf.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/uniform_int_dist.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cmath + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdlib + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/limits + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/pstl/execution_defs.h + /usr/include/c++/15/pstl/glue_algorithm_defs.h + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/tr1/bessel_function.tcc + /usr/include/c++/15/tr1/beta_function.tcc + /usr/include/c++/15/tr1/ell_integral.tcc + /usr/include/c++/15/tr1/exp_integral.tcc + /usr/include/c++/15/tr1/gamma.tcc + /usr/include/c++/15/tr1/hypergeometric.tcc + /usr/include/c++/15/tr1/legendre_function.tcc + /usr/include/c++/15/tr1/modified_bessel_func.tcc + /usr/include/c++/15/tr1/poly_hermite.tcc + /usr/include/c++/15/tr1/poly_laguerre.tcc + /usr/include/c++/15/tr1/riemann_zeta.tcc + /usr/include/c++/15/tr1/special_function_util.h + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/vector + /usr/include/endian.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/math.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdlib.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h + /usr/include/x86_64-linux-gnu/bits/fp-fast.h + /usr/include/x86_64-linux-gnu/bits/fp-logb.h + /usr/include/x86_64-linux-gnu/bits/iscanonical.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/math-vector.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h + /usr/include/x86_64-linux-gnu/bits/mathcalls.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o + /home/itten/mxl-multiviewer/V210ComputeDecoder.cpp + /home/itten/mxl-multiviewer/V210ComputeDecoder.hpp + /home/itten/mxl-multiviewer/VulkanUtils.hpp + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/codecvt.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/fstream.tcc + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/fstream + /usr/include/c++/15/initializer_list + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/time.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o + /home/itten/mxl-multiviewer/VulkanContext.cpp + /home/itten/mxl-multiviewer/VulkanContext.hpp + /usr/include/SDL3/SDL.h + /usr/include/SDL3/SDL_assert.h + /usr/include/SDL3/SDL_asyncio.h + /usr/include/SDL3/SDL_atomic.h + /usr/include/SDL3/SDL_audio.h + /usr/include/SDL3/SDL_begin_code.h + /usr/include/SDL3/SDL_bits.h + /usr/include/SDL3/SDL_blendmode.h + /usr/include/SDL3/SDL_camera.h + /usr/include/SDL3/SDL_clipboard.h + /usr/include/SDL3/SDL_close_code.h + /usr/include/SDL3/SDL_cpuinfo.h + /usr/include/SDL3/SDL_dialog.h + /usr/include/SDL3/SDL_dlopennote.h + /usr/include/SDL3/SDL_endian.h + /usr/include/SDL3/SDL_error.h + /usr/include/SDL3/SDL_events.h + /usr/include/SDL3/SDL_filesystem.h + /usr/include/SDL3/SDL_gamepad.h + /usr/include/SDL3/SDL_gpu.h + /usr/include/SDL3/SDL_guid.h + /usr/include/SDL3/SDL_haptic.h + /usr/include/SDL3/SDL_hidapi.h + /usr/include/SDL3/SDL_hints.h + /usr/include/SDL3/SDL_init.h + /usr/include/SDL3/SDL_iostream.h + /usr/include/SDL3/SDL_joystick.h + /usr/include/SDL3/SDL_keyboard.h + /usr/include/SDL3/SDL_keycode.h + /usr/include/SDL3/SDL_loadso.h + /usr/include/SDL3/SDL_locale.h + /usr/include/SDL3/SDL_log.h + /usr/include/SDL3/SDL_messagebox.h + /usr/include/SDL3/SDL_metal.h + /usr/include/SDL3/SDL_misc.h + /usr/include/SDL3/SDL_mouse.h + /usr/include/SDL3/SDL_mutex.h + /usr/include/SDL3/SDL_oldnames.h + /usr/include/SDL3/SDL_pen.h + /usr/include/SDL3/SDL_pixels.h + /usr/include/SDL3/SDL_platform.h + /usr/include/SDL3/SDL_platform_defines.h + /usr/include/SDL3/SDL_power.h + /usr/include/SDL3/SDL_process.h + /usr/include/SDL3/SDL_properties.h + /usr/include/SDL3/SDL_rect.h + /usr/include/SDL3/SDL_render.h + /usr/include/SDL3/SDL_scancode.h + /usr/include/SDL3/SDL_sensor.h + /usr/include/SDL3/SDL_stdinc.h + /usr/include/SDL3/SDL_storage.h + /usr/include/SDL3/SDL_surface.h + /usr/include/SDL3/SDL_system.h + /usr/include/SDL3/SDL_thread.h + /usr/include/SDL3/SDL_time.h + /usr/include/SDL3/SDL_timer.h + /usr/include/SDL3/SDL_touch.h + /usr/include/SDL3/SDL_tray.h + /usr/include/SDL3/SDL_version.h + /usr/include/SDL3/SDL_video.h + /usr/include/SDL3/SDL_vulkan.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/enable_special_members.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/optional + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/time.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o + /home/itten/mxl-multiviewer/VulkanUtils.cpp + /home/itten/mxl-multiviewer/VulkanUtils.hpp + /usr/include/alloca.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/clocale + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cwchar + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/initializer_list + /usr/include/c++/15/iosfwd + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdexcept + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/linux/errno.h + /usr/include/locale.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/wchar.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.h + /home/itten/mxl-multiviewer/imgui/imconfig.h + /home/itten/mxl-multiviewer/imgui/imgui.h + /usr/include/SDL3/SDL.h + /usr/include/SDL3/SDL_assert.h + /usr/include/SDL3/SDL_asyncio.h + /usr/include/SDL3/SDL_atomic.h + /usr/include/SDL3/SDL_audio.h + /usr/include/SDL3/SDL_begin_code.h + /usr/include/SDL3/SDL_bits.h + /usr/include/SDL3/SDL_blendmode.h + /usr/include/SDL3/SDL_camera.h + /usr/include/SDL3/SDL_clipboard.h + /usr/include/SDL3/SDL_close_code.h + /usr/include/SDL3/SDL_cpuinfo.h + /usr/include/SDL3/SDL_dialog.h + /usr/include/SDL3/SDL_dlopennote.h + /usr/include/SDL3/SDL_endian.h + /usr/include/SDL3/SDL_error.h + /usr/include/SDL3/SDL_events.h + /usr/include/SDL3/SDL_filesystem.h + /usr/include/SDL3/SDL_gamepad.h + /usr/include/SDL3/SDL_gpu.h + /usr/include/SDL3/SDL_guid.h + /usr/include/SDL3/SDL_haptic.h + /usr/include/SDL3/SDL_hidapi.h + /usr/include/SDL3/SDL_hints.h + /usr/include/SDL3/SDL_init.h + /usr/include/SDL3/SDL_iostream.h + /usr/include/SDL3/SDL_joystick.h + /usr/include/SDL3/SDL_keyboard.h + /usr/include/SDL3/SDL_keycode.h + /usr/include/SDL3/SDL_loadso.h + /usr/include/SDL3/SDL_locale.h + /usr/include/SDL3/SDL_log.h + /usr/include/SDL3/SDL_messagebox.h + /usr/include/SDL3/SDL_metal.h + /usr/include/SDL3/SDL_misc.h + /usr/include/SDL3/SDL_mouse.h + /usr/include/SDL3/SDL_mutex.h + /usr/include/SDL3/SDL_oldnames.h + /usr/include/SDL3/SDL_pen.h + /usr/include/SDL3/SDL_pixels.h + /usr/include/SDL3/SDL_platform.h + /usr/include/SDL3/SDL_platform_defines.h + /usr/include/SDL3/SDL_power.h + /usr/include/SDL3/SDL_process.h + /usr/include/SDL3/SDL_properties.h + /usr/include/SDL3/SDL_rect.h + /usr/include/SDL3/SDL_render.h + /usr/include/SDL3/SDL_scancode.h + /usr/include/SDL3/SDL_sensor.h + /usr/include/SDL3/SDL_stdinc.h + /usr/include/SDL3/SDL_storage.h + /usr/include/SDL3/SDL_surface.h + /usr/include/SDL3/SDL_system.h + /usr/include/SDL3/SDL_thread.h + /usr/include/SDL3/SDL_time.h + /usr/include/SDL3/SDL_timer.h + /usr/include/SDL3/SDL_touch.h + /usr/include/SDL3/SDL_tray.h + /usr/include/SDL3/SDL_version.h + /usr/include/SDL3/SDL_video.h + /usr/include/assert.h + /usr/include/endian.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/wchar.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.cpp + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.h + /home/itten/mxl-multiviewer/imgui/imconfig.h + /home/itten/mxl-multiviewer/imgui/imgui.h + /usr/include/assert.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o + /home/itten/mxl-multiviewer/imgui/imgui.cpp + /home/itten/mxl-multiviewer/imgui/imconfig.h + /home/itten/mxl-multiviewer/imgui/imgui.h + /home/itten/mxl-multiviewer/imgui/imgui_internal.h + /usr/include/alloca.h + /usr/include/assert.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/specfun.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cmath + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstdlib + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/limits + /usr/include/c++/15/math.h + /usr/include/c++/15/new + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdlib.h + /usr/include/c++/15/tr1/bessel_function.tcc + /usr/include/c++/15/tr1/beta_function.tcc + /usr/include/c++/15/tr1/ell_integral.tcc + /usr/include/c++/15/tr1/exp_integral.tcc + /usr/include/c++/15/tr1/gamma.tcc + /usr/include/c++/15/tr1/hypergeometric.tcc + /usr/include/c++/15/tr1/legendre_function.tcc + /usr/include/c++/15/tr1/modified_bessel_func.tcc + /usr/include/c++/15/tr1/poly_hermite.tcc + /usr/include/c++/15/tr1/poly_laguerre.tcc + /usr/include/c++/15/tr1/riemann_zeta.tcc + /usr/include/c++/15/tr1/special_function_util.h + /usr/include/c++/15/type_traits + /usr/include/endian.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/limits.h + /usr/include/math.h + /usr/include/signal.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/unistd.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h + /usr/include/x86_64-linux-gnu/bits/fp-fast.h + /usr/include/x86_64-linux-gnu/bits/fp-logb.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/iscanonical.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/math-vector.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h + /usr/include/x86_64-linux-gnu/bits/mathcalls.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/sigaction.h + /usr/include/x86_64-linux-gnu/bits/sigcontext.h + /usr/include/x86_64-linux-gnu/bits/sigevent-consts.h + /usr/include/x86_64-linux-gnu/bits/siginfo-arch.h + /usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h + /usr/include/x86_64-linux-gnu/bits/siginfo-consts.h + /usr/include/x86_64-linux-gnu/bits/signal_ext.h + /usr/include/x86_64-linux-gnu/bits/signum-arch.h + /usr/include/x86_64-linux-gnu/bits/signum-generic.h + /usr/include/x86_64-linux-gnu/bits/sigstack.h + /usr/include/x86_64-linux-gnu/bits/sigstksz.h + /usr/include/x86_64-linux-gnu/bits/sigthread.h + /usr/include/x86_64-linux-gnu/bits/ss_flags.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/idtype_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h + /usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigval_t.h + /usr/include/x86_64-linux-gnu/bits/types/stack_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/include/x86_64-linux-gnu/sys/ucontext.h + /usr/include/x86_64-linux-gnu/sys/wait.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o + /home/itten/mxl-multiviewer/imgui/imgui_draw.cpp + /home/itten/mxl-multiviewer/imgui/imconfig.h + /home/itten/mxl-multiviewer/imgui/imgui.h + /home/itten/mxl-multiviewer/imgui/imgui_internal.h + /home/itten/mxl-multiviewer/imgui/imstb_rectpack.h + /home/itten/mxl-multiviewer/imgui/imstb_truetype.h + /usr/include/alloca.h + /usr/include/assert.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/specfun.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cmath + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstdlib + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/limits + /usr/include/c++/15/math.h + /usr/include/c++/15/new + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdlib.h + /usr/include/c++/15/tr1/bessel_function.tcc + /usr/include/c++/15/tr1/beta_function.tcc + /usr/include/c++/15/tr1/ell_integral.tcc + /usr/include/c++/15/tr1/exp_integral.tcc + /usr/include/c++/15/tr1/gamma.tcc + /usr/include/c++/15/tr1/hypergeometric.tcc + /usr/include/c++/15/tr1/legendre_function.tcc + /usr/include/c++/15/tr1/modified_bessel_func.tcc + /usr/include/c++/15/tr1/poly_hermite.tcc + /usr/include/c++/15/tr1/poly_laguerre.tcc + /usr/include/c++/15/tr1/riemann_zeta.tcc + /usr/include/c++/15/tr1/special_function_util.h + /usr/include/c++/15/type_traits + /usr/include/endian.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/limits.h + /usr/include/linux/limits.h + /usr/include/math.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h + /usr/include/x86_64-linux-gnu/bits/fp-fast.h + /usr/include/x86_64-linux-gnu/bits/fp-logb.h + /usr/include/x86_64-linux-gnu/bits/iscanonical.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/math-vector.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h + /usr/include/x86_64-linux-gnu/bits/mathcalls.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o + /home/itten/mxl-multiviewer/imgui/imgui_tables.cpp + /home/itten/mxl-multiviewer/imgui/imconfig.h + /home/itten/mxl-multiviewer/imgui/imgui.h + /home/itten/mxl-multiviewer/imgui/imgui_internal.h + /usr/include/alloca.h + /usr/include/assert.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/specfun.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cmath + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstdlib + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/limits + /usr/include/c++/15/math.h + /usr/include/c++/15/new + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdlib.h + /usr/include/c++/15/tr1/bessel_function.tcc + /usr/include/c++/15/tr1/beta_function.tcc + /usr/include/c++/15/tr1/ell_integral.tcc + /usr/include/c++/15/tr1/exp_integral.tcc + /usr/include/c++/15/tr1/gamma.tcc + /usr/include/c++/15/tr1/hypergeometric.tcc + /usr/include/c++/15/tr1/legendre_function.tcc + /usr/include/c++/15/tr1/modified_bessel_func.tcc + /usr/include/c++/15/tr1/poly_hermite.tcc + /usr/include/c++/15/tr1/poly_laguerre.tcc + /usr/include/c++/15/tr1/riemann_zeta.tcc + /usr/include/c++/15/tr1/special_function_util.h + /usr/include/c++/15/type_traits + /usr/include/endian.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/limits.h + /usr/include/linux/limits.h + /usr/include/math.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h + /usr/include/x86_64-linux-gnu/bits/fp-fast.h + /usr/include/x86_64-linux-gnu/bits/fp-logb.h + /usr/include/x86_64-linux-gnu/bits/iscanonical.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/math-vector.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h + /usr/include/x86_64-linux-gnu/bits/mathcalls.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o + /home/itten/mxl-multiviewer/imgui/imgui_widgets.cpp + /home/itten/mxl-multiviewer/imgui/imconfig.h + /home/itten/mxl-multiviewer/imgui/imgui.h + /home/itten/mxl-multiviewer/imgui/imgui_internal.h + /home/itten/mxl-multiviewer/imgui/imstb_textedit.h + /usr/include/alloca.h + /usr/include/assert.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/specfun.h + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cmath + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/cstdlib + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/limits + /usr/include/c++/15/math.h + /usr/include/c++/15/new + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/stdlib.h + /usr/include/c++/15/tr1/bessel_function.tcc + /usr/include/c++/15/tr1/beta_function.tcc + /usr/include/c++/15/tr1/ell_integral.tcc + /usr/include/c++/15/tr1/exp_integral.tcc + /usr/include/c++/15/tr1/gamma.tcc + /usr/include/c++/15/tr1/hypergeometric.tcc + /usr/include/c++/15/tr1/legendre_function.tcc + /usr/include/c++/15/tr1/modified_bessel_func.tcc + /usr/include/c++/15/tr1/poly_hermite.tcc + /usr/include/c++/15/tr1/poly_laguerre.tcc + /usr/include/c++/15/tr1/riemann_zeta.tcc + /usr/include/c++/15/tr1/special_function_util.h + /usr/include/c++/15/type_traits + /usr/include/endian.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/limits.h + /usr/include/linux/limits.h + /usr/include/math.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h + /usr/include/x86_64-linux-gnu/bits/fp-fast.h + /usr/include/x86_64-linux-gnu/bits/fp-logb.h + /usr/include/x86_64-linux-gnu/bits/iscanonical.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/math-vector.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h + /usr/include/x86_64-linux-gnu/bits/mathcalls.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/main.cpp.o + /home/itten/mxl-multiviewer/main.cpp + /home/itten/mxl-multiviewer/AppConfig.hpp + /home/itten/mxl-multiviewer/FeedCreate.hpp + /home/itten/mxl-multiviewer/FeedTexture.hpp + /home/itten/mxl-multiviewer/IVideoFeed.hpp + /home/itten/mxl-multiviewer/RenderPipeline.hpp + /home/itten/mxl-multiviewer/Swapchain.hpp + /home/itten/mxl-multiviewer/TileLayout.hpp + /home/itten/mxl-multiviewer/V210ComputeDecoder.hpp + /home/itten/mxl-multiviewer/VideoFrame.hpp + /home/itten/mxl-multiviewer/VulkanContext.hpp + /home/itten/mxl-multiviewer/VulkanUtils.hpp + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.h + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.h + /home/itten/mxl-multiviewer/imgui/imconfig.h + /home/itten/mxl-multiviewer/imgui/imgui.h + /usr/include/SDL3/SDL.h + /usr/include/SDL3/SDL_assert.h + /usr/include/SDL3/SDL_asyncio.h + /usr/include/SDL3/SDL_atomic.h + /usr/include/SDL3/SDL_audio.h + /usr/include/SDL3/SDL_begin_code.h + /usr/include/SDL3/SDL_bits.h + /usr/include/SDL3/SDL_blendmode.h + /usr/include/SDL3/SDL_camera.h + /usr/include/SDL3/SDL_clipboard.h + /usr/include/SDL3/SDL_close_code.h + /usr/include/SDL3/SDL_cpuinfo.h + /usr/include/SDL3/SDL_dialog.h + /usr/include/SDL3/SDL_dlopennote.h + /usr/include/SDL3/SDL_endian.h + /usr/include/SDL3/SDL_error.h + /usr/include/SDL3/SDL_events.h + /usr/include/SDL3/SDL_filesystem.h + /usr/include/SDL3/SDL_gamepad.h + /usr/include/SDL3/SDL_gpu.h + /usr/include/SDL3/SDL_guid.h + /usr/include/SDL3/SDL_haptic.h + /usr/include/SDL3/SDL_hidapi.h + /usr/include/SDL3/SDL_hints.h + /usr/include/SDL3/SDL_init.h + /usr/include/SDL3/SDL_iostream.h + /usr/include/SDL3/SDL_joystick.h + /usr/include/SDL3/SDL_keyboard.h + /usr/include/SDL3/SDL_keycode.h + /usr/include/SDL3/SDL_loadso.h + /usr/include/SDL3/SDL_locale.h + /usr/include/SDL3/SDL_log.h + /usr/include/SDL3/SDL_messagebox.h + /usr/include/SDL3/SDL_metal.h + /usr/include/SDL3/SDL_misc.h + /usr/include/SDL3/SDL_mouse.h + /usr/include/SDL3/SDL_mutex.h + /usr/include/SDL3/SDL_oldnames.h + /usr/include/SDL3/SDL_pen.h + /usr/include/SDL3/SDL_pixels.h + /usr/include/SDL3/SDL_platform.h + /usr/include/SDL3/SDL_platform_defines.h + /usr/include/SDL3/SDL_power.h + /usr/include/SDL3/SDL_process.h + /usr/include/SDL3/SDL_properties.h + /usr/include/SDL3/SDL_rect.h + /usr/include/SDL3/SDL_render.h + /usr/include/SDL3/SDL_scancode.h + /usr/include/SDL3/SDL_sensor.h + /usr/include/SDL3/SDL_stdinc.h + /usr/include/SDL3/SDL_storage.h + /usr/include/SDL3/SDL_surface.h + /usr/include/SDL3/SDL_system.h + /usr/include/SDL3/SDL_thread.h + /usr/include/SDL3/SDL_time.h + /usr/include/SDL3/SDL_timer.h + /usr/include/SDL3/SDL_touch.h + /usr/include/SDL3/SDL_tray.h + /usr/include/SDL3/SDL_version.h + /usr/include/SDL3/SDL_video.h + /usr/include/alloca.h + /usr/include/asm-generic/bitsperlong.h + /usr/include/asm-generic/errno-base.h + /usr/include/asm-generic/errno.h + /usr/include/asm-generic/int-ll64.h + /usr/include/asm-generic/posix_types.h + /usr/include/asm-generic/types.h + /usr/include/assert.h + /usr/include/c++/15/algorithm + /usr/include/c++/15/atomic + /usr/include/c++/15/backward/auto_ptr.h + /usr/include/c++/15/backward/binders.h + /usr/include/c++/15/bit + /usr/include/c++/15/bits/algorithmfwd.h + /usr/include/c++/15/bits/align.h + /usr/include/c++/15/bits/alloc_traits.h + /usr/include/c++/15/bits/allocated_ptr.h + /usr/include/c++/15/bits/allocator.h + /usr/include/c++/15/bits/atomic_base.h + /usr/include/c++/15/bits/atomic_lockfree_defines.h + /usr/include/c++/15/bits/atomic_wait.h + /usr/include/c++/15/bits/basic_ios.h + /usr/include/c++/15/bits/basic_ios.tcc + /usr/include/c++/15/bits/basic_string.h + /usr/include/c++/15/bits/basic_string.tcc + /usr/include/c++/15/bits/char_traits.h + /usr/include/c++/15/bits/charconv.h + /usr/include/c++/15/bits/chrono.h + /usr/include/c++/15/bits/codecvt.h + /usr/include/c++/15/bits/concept_check.h + /usr/include/c++/15/bits/cpp_type_traits.h + /usr/include/c++/15/bits/cxxabi_forced.h + /usr/include/c++/15/bits/cxxabi_init_exception.h + /usr/include/c++/15/bits/enable_special_members.h + /usr/include/c++/15/bits/erase_if.h + /usr/include/c++/15/bits/exception.h + /usr/include/c++/15/bits/exception_defines.h + /usr/include/c++/15/bits/exception_ptr.h + /usr/include/c++/15/bits/fs_dir.h + /usr/include/c++/15/bits/fs_fwd.h + /usr/include/c++/15/bits/fs_ops.h + /usr/include/c++/15/bits/fs_path.h + /usr/include/c++/15/bits/fstream.tcc + /usr/include/c++/15/bits/functexcept.h + /usr/include/c++/15/bits/functional_hash.h + /usr/include/c++/15/bits/hash_bytes.h + /usr/include/c++/15/bits/invoke.h + /usr/include/c++/15/bits/ios_base.h + /usr/include/c++/15/bits/istream.tcc + /usr/include/c++/15/bits/iterator_concepts.h + /usr/include/c++/15/bits/locale_classes.h + /usr/include/c++/15/bits/locale_classes.tcc + /usr/include/c++/15/bits/locale_conv.h + /usr/include/c++/15/bits/locale_facets.h + /usr/include/c++/15/bits/locale_facets.tcc + /usr/include/c++/15/bits/locale_facets_nonio.h + /usr/include/c++/15/bits/locale_facets_nonio.tcc + /usr/include/c++/15/bits/localefwd.h + /usr/include/c++/15/bits/max_size_type.h + /usr/include/c++/15/bits/memory_resource.h + /usr/include/c++/15/bits/memoryfwd.h + /usr/include/c++/15/bits/move.h + /usr/include/c++/15/bits/nested_exception.h + /usr/include/c++/15/bits/new_allocator.h + /usr/include/c++/15/bits/node_handle.h + /usr/include/c++/15/bits/ostream.h + /usr/include/c++/15/bits/ostream.tcc + /usr/include/c++/15/bits/ostream_insert.h + /usr/include/c++/15/bits/parse_numbers.h + /usr/include/c++/15/bits/postypes.h + /usr/include/c++/15/bits/predefined_ops.h + /usr/include/c++/15/bits/ptr_traits.h + /usr/include/c++/15/bits/quoted_string.h + /usr/include/c++/15/bits/range_access.h + /usr/include/c++/15/bits/ranges_algo.h + /usr/include/c++/15/bits/ranges_algobase.h + /usr/include/c++/15/bits/ranges_base.h + /usr/include/c++/15/bits/ranges_cmp.h + /usr/include/c++/15/bits/ranges_uninitialized.h + /usr/include/c++/15/bits/ranges_util.h + /usr/include/c++/15/bits/refwrap.h + /usr/include/c++/15/bits/requires_hosted.h + /usr/include/c++/15/bits/shared_ptr.h + /usr/include/c++/15/bits/shared_ptr_atomic.h + /usr/include/c++/15/bits/shared_ptr_base.h + /usr/include/c++/15/bits/sstream.tcc + /usr/include/c++/15/bits/std_abs.h + /usr/include/c++/15/bits/std_mutex.h + /usr/include/c++/15/bits/stl_algo.h + /usr/include/c++/15/bits/stl_algobase.h + /usr/include/c++/15/bits/stl_bvector.h + /usr/include/c++/15/bits/stl_construct.h + /usr/include/c++/15/bits/stl_function.h + /usr/include/c++/15/bits/stl_heap.h + /usr/include/c++/15/bits/stl_iterator.h + /usr/include/c++/15/bits/stl_iterator_base_funcs.h + /usr/include/c++/15/bits/stl_iterator_base_types.h + /usr/include/c++/15/bits/stl_map.h + /usr/include/c++/15/bits/stl_multimap.h + /usr/include/c++/15/bits/stl_pair.h + /usr/include/c++/15/bits/stl_raw_storage_iter.h + /usr/include/c++/15/bits/stl_tempbuf.h + /usr/include/c++/15/bits/stl_tree.h + /usr/include/c++/15/bits/stl_uninitialized.h + /usr/include/c++/15/bits/stl_vector.h + /usr/include/c++/15/bits/streambuf.tcc + /usr/include/c++/15/bits/streambuf_iterator.h + /usr/include/c++/15/bits/string_view.tcc + /usr/include/c++/15/bits/stringfwd.h + /usr/include/c++/15/bits/uniform_int_dist.h + /usr/include/c++/15/bits/unique_ptr.h + /usr/include/c++/15/bits/uses_allocator.h + /usr/include/c++/15/bits/uses_allocator_args.h + /usr/include/c++/15/bits/utility.h + /usr/include/c++/15/bits/vector.tcc + /usr/include/c++/15/bits/version.h + /usr/include/c++/15/cctype + /usr/include/c++/15/cerrno + /usr/include/c++/15/climits + /usr/include/c++/15/clocale + /usr/include/c++/15/codecvt + /usr/include/c++/15/compare + /usr/include/c++/15/concepts + /usr/include/c++/15/csignal + /usr/include/c++/15/cstddef + /usr/include/c++/15/cstdint + /usr/include/c++/15/cstdio + /usr/include/c++/15/cstdlib + /usr/include/c++/15/cstring + /usr/include/c++/15/ctime + /usr/include/c++/15/cwchar + /usr/include/c++/15/cwctype + /usr/include/c++/15/debug/assertions.h + /usr/include/c++/15/debug/debug.h + /usr/include/c++/15/exception + /usr/include/c++/15/ext/aligned_buffer.h + /usr/include/c++/15/ext/alloc_traits.h + /usr/include/c++/15/ext/atomicity.h + /usr/include/c++/15/ext/concurrence.h + /usr/include/c++/15/ext/numeric_traits.h + /usr/include/c++/15/ext/string_conversions.h + /usr/include/c++/15/ext/type_traits.h + /usr/include/c++/15/filesystem + /usr/include/c++/15/fstream + /usr/include/c++/15/initializer_list + /usr/include/c++/15/iomanip + /usr/include/c++/15/ios + /usr/include/c++/15/iosfwd + /usr/include/c++/15/iostream + /usr/include/c++/15/istream + /usr/include/c++/15/limits + /usr/include/c++/15/locale + /usr/include/c++/15/map + /usr/include/c++/15/memory + /usr/include/c++/15/new + /usr/include/c++/15/numbers + /usr/include/c++/15/optional + /usr/include/c++/15/ostream + /usr/include/c++/15/pstl/execution_defs.h + /usr/include/c++/15/pstl/glue_algorithm_defs.h + /usr/include/c++/15/pstl/glue_memory_defs.h + /usr/include/c++/15/pstl/pstl_config.h + /usr/include/c++/15/ratio + /usr/include/c++/15/sstream + /usr/include/c++/15/stdexcept + /usr/include/c++/15/streambuf + /usr/include/c++/15/string + /usr/include/c++/15/string_view + /usr/include/c++/15/system_error + /usr/include/c++/15/tuple + /usr/include/c++/15/type_traits + /usr/include/c++/15/typeinfo + /usr/include/c++/15/vector + /usr/include/ctype.h + /usr/include/endian.h + /usr/include/errno.h + /usr/include/features-time64.h + /usr/include/features.h + /usr/include/libintl.h + /usr/include/limits.h + /usr/include/linux/close_range.h + /usr/include/linux/errno.h + /usr/include/linux/limits.h + /usr/include/linux/posix_types.h + /usr/include/linux/sched/types.h + /usr/include/linux/stddef.h + /usr/include/linux/types.h + /usr/include/locale.h + /usr/include/pthread.h + /usr/include/sched.h + /usr/include/signal.h + /usr/include/stdc-predef.h + /usr/include/stdint.h + /usr/include/stdio.h + /usr/include/stdlib.h + /usr/include/string.h + /usr/include/strings.h + /usr/include/syscall.h + /usr/include/time.h + /usr/include/unistd.h + /usr/include/vk_video/vulkan_video_codec_av1std.h + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h + /usr/include/vk_video/vulkan_video_codec_h264std.h + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h + /usr/include/vk_video/vulkan_video_codec_h265std.h + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h + /usr/include/vk_video/vulkan_video_codec_vp9std.h + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h + /usr/include/vk_video/vulkan_video_codecs_common.h + /usr/include/vulkan/vk_platform.h + /usr/include/vulkan/vulkan.h + /usr/include/vulkan/vulkan_core.h + /usr/include/wchar.h + /usr/include/wctype.h + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h + /usr/include/x86_64-linux-gnu/asm/errno.h + /usr/include/x86_64-linux-gnu/asm/posix_types.h + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h + /usr/include/x86_64-linux-gnu/asm/types.h + /usr/include/x86_64-linux-gnu/asm/unistd.h + /usr/include/x86_64-linux-gnu/asm/unistd_64.h + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h + /usr/include/x86_64-linux-gnu/bits/byteswap.h + /usr/include/x86_64-linux-gnu/bits/confname.h + /usr/include/x86_64-linux-gnu/bits/cpu-set.h + /usr/include/x86_64-linux-gnu/bits/endian.h + /usr/include/x86_64-linux-gnu/bits/endianness.h + /usr/include/x86_64-linux-gnu/bits/environments.h + /usr/include/x86_64-linux-gnu/bits/errno.h + /usr/include/x86_64-linux-gnu/bits/floatn-common.h + /usr/include/x86_64-linux-gnu/bits/floatn.h + /usr/include/x86_64-linux-gnu/bits/getopt_core.h + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h + /usr/include/x86_64-linux-gnu/bits/local_lim.h + /usr/include/x86_64-linux-gnu/bits/locale.h + /usr/include/x86_64-linux-gnu/bits/long-double.h + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h + /usr/include/x86_64-linux-gnu/bits/posix_opt.h + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h + /usr/include/x86_64-linux-gnu/bits/sched.h + /usr/include/x86_64-linux-gnu/bits/select.h + /usr/include/x86_64-linux-gnu/bits/setjmp.h + /usr/include/x86_64-linux-gnu/bits/sigaction.h + /usr/include/x86_64-linux-gnu/bits/sigcontext.h + /usr/include/x86_64-linux-gnu/bits/sigevent-consts.h + /usr/include/x86_64-linux-gnu/bits/siginfo-arch.h + /usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h + /usr/include/x86_64-linux-gnu/bits/siginfo-consts.h + /usr/include/x86_64-linux-gnu/bits/signal_ext.h + /usr/include/x86_64-linux-gnu/bits/signum-arch.h + /usr/include/x86_64-linux-gnu/bits/signum-generic.h + /usr/include/x86_64-linux-gnu/bits/sigstack.h + /usr/include/x86_64-linux-gnu/bits/sigstksz.h + /usr/include/x86_64-linux-gnu/bits/sigthread.h + /usr/include/x86_64-linux-gnu/bits/ss_flags.h + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h + /usr/include/x86_64-linux-gnu/bits/stdint-least.h + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h + /usr/include/x86_64-linux-gnu/bits/syscall.h + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h + /usr/include/x86_64-linux-gnu/bits/time.h + /usr/include/x86_64-linux-gnu/bits/time64.h + /usr/include/x86_64-linux-gnu/bits/timesize.h + /usr/include/x86_64-linux-gnu/bits/timex.h + /usr/include/x86_64-linux-gnu/bits/types.h + /usr/include/x86_64-linux-gnu/bits/types/FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h + /usr/include/x86_64-linux-gnu/bits/types/error_t.h + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h + /usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h + /usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h + /usr/include/x86_64-linux-gnu/bits/types/sigval_t.h + /usr/include/x86_64-linux-gnu/bits/types/stack_t.h + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h + /usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h + /usr/include/x86_64-linux-gnu/bits/types/time_t.h + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h + /usr/include/x86_64-linux-gnu/bits/typesizes.h + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h + /usr/include/x86_64-linux-gnu/bits/uio_lim.h + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h + /usr/include/x86_64-linux-gnu/bits/waitflags.h + /usr/include/x86_64-linux-gnu/bits/waitstatus.h + /usr/include/x86_64-linux-gnu/bits/wchar.h + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h + /usr/include/x86_64-linux-gnu/bits/wordsize.h + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h + /usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h + /usr/include/x86_64-linux-gnu/c++/15/bits/messages_members.h + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h + /usr/include/x86_64-linux-gnu/c++/15/bits/time_members.h + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h + /usr/include/x86_64-linux-gnu/gnu/stubs.h + /usr/include/x86_64-linux-gnu/sys/cdefs.h + /usr/include/x86_64-linux-gnu/sys/select.h + /usr/include/x86_64-linux-gnu/sys/single_threaded.h + /usr/include/x86_64-linux-gnu/sys/syscall.h + /usr/include/x86_64-linux-gnu/sys/types.h + /usr/include/x86_64-linux-gnu/sys/ucontext.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + +mxl_multiviewer + /home/itten/dmf-mxl/mxl-1.0.1/build/Linux-Clang-Release/lib/internal/libmxl-common.so + /home/itten/dmf-mxl/mxl-1.0.1/build/Linux-Clang-Release/lib/libmxl.so + /lib64/ld-linux-x86-64.so.2 + /usr/lib/x86_64-linux-gnu/Scrt1.o + /usr/lib/x86_64-linux-gnu/crti.o + /usr/lib/x86_64-linux-gnu/crtn.o + /usr/lib/x86_64-linux-gnu/libSDL3.so + /usr/lib/x86_64-linux-gnu/libc.so + /usr/lib/x86_64-linux-gnu/libgcc_s.so.1 + /usr/lib/x86_64-linux-gnu/libm.so + /usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o + /usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o + /usr/lib/gcc/x86_64-linux-gnu/15/libgcc.a + /usr/lib/gcc/x86_64-linux-gnu/15/libgcc_s.so + /usr/lib/gcc/x86_64-linux-gnu/15/libstdc++.so + /usr/lib/x86_64-linux-gnu/libFLAC.so.14 + /usr/lib/x86_64-linux-gnu/libX11-xcb.so.1 + /usr/lib/x86_64-linux-gnu/libX11.so.6 + /usr/lib/x86_64-linux-gnu/libXau.so.6 + /usr/lib/x86_64-linux-gnu/libXcursor.so.1 + /usr/lib/x86_64-linux-gnu/libXdmcp.so.6 + /usr/lib/x86_64-linux-gnu/libXext.so.6 + /usr/lib/x86_64-linux-gnu/libXfixes.so.3 + /usr/lib/x86_64-linux-gnu/libXi.so.6 + /usr/lib/x86_64-linux-gnu/libXrandr.so.2 + /usr/lib/x86_64-linux-gnu/libXrender.so.1 + /usr/lib/x86_64-linux-gnu/libXss.so.1 + /usr/lib/x86_64-linux-gnu/libXtst.so.6 + /usr/lib/x86_64-linux-gnu/libapparmor.so.1 + /usr/lib/x86_64-linux-gnu/libasound.so.2 + /usr/lib/x86_64-linux-gnu/libasyncns.so.0 + /usr/lib/x86_64-linux-gnu/libc.so.6 + /usr/lib/x86_64-linux-gnu/libc_nonshared.a + /usr/lib/x86_64-linux-gnu/libdbus-1.so.3 + /usr/lib/x86_64-linux-gnu/libdecor-0.so.0 + /usr/lib/x86_64-linux-gnu/libdrm.so.2 + /usr/lib/x86_64-linux-gnu/libexpat.so.1 + /usr/lib/x86_64-linux-gnu/libffi.so.8 + /usr/lib/x86_64-linux-gnu/libfribidi.so.0 + /usr/lib/x86_64-linux-gnu/libgbm.so.1 + /usr/lib/x86_64-linux-gnu/libm.so.6 + /usr/lib/x86_64-linux-gnu/libmp3lame.so.0 + /usr/lib/x86_64-linux-gnu/libmpg123.so.0 + /usr/lib/x86_64-linux-gnu/libmvec.so.1 + /usr/lib/x86_64-linux-gnu/libogg.so.0 + /usr/lib/x86_64-linux-gnu/libopus.so.0 + /usr/lib/x86_64-linux-gnu/libpulse.so.0 + /usr/lib/x86_64-linux-gnu/libsndfile.so.1 + /usr/lib/x86_64-linux-gnu/libsystemd.so.0 + /usr/lib/x86_64-linux-gnu/libvorbis.so.0 + /usr/lib/x86_64-linux-gnu/libvorbisenc.so.2 + /usr/lib/x86_64-linux-gnu/libvulkan.so + /usr/lib/x86_64-linux-gnu/libwayland-client.so.0 + /usr/lib/x86_64-linux-gnu/libwayland-cursor.so.0 + /usr/lib/x86_64-linux-gnu/libwayland-egl.so.1 + /usr/lib/x86_64-linux-gnu/libxcb.so.1 + /usr/lib/x86_64-linux-gnu/libxkbcommon.so.0 + /usr/lib/x86_64-linux-gnu/pulseaudio/libpulsecommon-17.0.so + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o + /home/itten/mxl-multiviewer/build-sdk/CMakeFiles/mxl_multiviewer.dir/main.cpp.o + diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.make b/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.make new file mode 100644 index 0000000..8a5e0ab --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.make @@ -0,0 +1,6223 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.2 + +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o: /home/itten/mxl-multiviewer/AppConfig.cpp \ + /home/itten/mxl-multiviewer/AppConfig.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/optional \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/time.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o: /home/itten/mxl-multiviewer/FeedCreate.cpp \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h \ + /home/itten/mxl-multiviewer/AppConfig.hpp \ + /home/itten/mxl-multiviewer/FeedCreate.hpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/MxlFeed.hpp \ + /home/itten/mxl-multiviewer/MxlSdkFeed.hpp \ + /home/itten/mxl-multiviewer/NoSignalFeed.hpp \ + /home/itten/mxl-multiviewer/SmpteBarsFeed.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/backward/auto_ptr.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/align.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocated_ptr.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/atomic_base.h \ + /usr/include/c++/15/bits/atomic_lockfree_defines.h \ + /usr/include/c++/15/bits/atomic_wait.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_uninitialized.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/shared_ptr.h \ + /usr/include/c++/15/bits/shared_ptr_atomic.h \ + /usr/include/c++/15/bits/shared_ptr_base.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/std_mutex.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_raw_storage_iter.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/unique_ptr.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/climits \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/aligned_buffer.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/concurrence.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/memory \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/optional \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/execution_defs.h \ + /usr/include/c++/15/pstl/glue_memory_defs.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o: /home/itten/mxl-multiviewer/FeedTexture.cpp \ + /home/itten/mxl-multiviewer/FeedTexture.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp \ + /home/itten/mxl-multiviewer/VulkanUtils.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cstring \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/locale.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o: /home/itten/mxl-multiviewer/MxlFeed.cpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/MxlFeed.hpp \ + /home/itten/mxl-multiviewer/PixelFormat.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/locale.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o: /home/itten/mxl-multiviewer/MxlInstanceCache.cpp \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h \ + /home/itten/mxl-multiviewer/MxlInstanceCache.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/algorithm \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_algo.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/execution_defs.h \ + /usr/include/c++/15/pstl/glue_algorithm_defs.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/time.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o: /home/itten/mxl-multiviewer/MxlSdkFeed.cpp \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h \ + /home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/MxlInstanceCache.hpp \ + /home/itten/mxl-multiviewer/MxlSdkFeed.hpp \ + /home/itten/mxl-multiviewer/PixelFormat.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/array \ + /usr/include/c++/15/atomic \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/align.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocated_ptr.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/atomic_base.h \ + /usr/include/c++/15/bits/atomic_lockfree_defines.h \ + /usr/include/c++/15/bits/atomic_timed_wait.h \ + /usr/include/c++/15/bits/atomic_wait.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/chrono.h \ + /usr/include/c++/15/bits/chrono_io.h \ + /usr/include/c++/15/bits/codecvt.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/formatfwd.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_conv.h \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/locale_facets_nonio.h \ + /usr/include/c++/15/bits/locale_facets_nonio.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/monostate.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/parse_numbers.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/quoted_string.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/semaphore_base.h \ + /usr/include/c++/15/bits/shared_ptr.h \ + /usr/include/c++/15/bits/shared_ptr_base.h \ + /usr/include/c++/15/bits/sstream.tcc \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/std_mutex.h \ + /usr/include/c++/15/bits/std_thread.h \ + /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/this_thread_sleep.h \ + /usr/include/c++/15/bits/unicode-data.h \ + /usr/include/c++/15/bits/unicode.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/unique_ptr.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/charconv \ + /usr/include/c++/15/chrono \ + /usr/include/c++/15/climits \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cstring \ + /usr/include/c++/15/ctime \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/aligned_buffer.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/concurrence.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/format \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/iomanip \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/limits \ + /usr/include/c++/15/locale \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/optional \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/ratio \ + /usr/include/c++/15/semaphore \ + /usr/include/c++/15/span \ + /usr/include/c++/15/sstream \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/stop_token \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/thread \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/semaphore.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/semaphore.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/time.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o: /home/itten/mxl-multiviewer/NoSignalFeed.cpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/NoSignalFeed.hpp \ + /home/itten/mxl-multiviewer/PixelFormat.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/locale.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o: /home/itten/mxl-multiviewer/RenderPipeline.cpp \ + /home/itten/mxl-multiviewer/RenderPipeline.hpp \ + /home/itten/mxl-multiviewer/TileLayout.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/array \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/codecvt.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/fstream.tcc \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cstring \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/fstream \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/time.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o: /home/itten/mxl-multiviewer/SmpteBarsFeed.cpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/PixelFormat.hpp \ + /home/itten/mxl-multiviewer/SmpteBarsFeed.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/c++/15/array \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/locale.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o: /home/itten/mxl-multiviewer/Swapchain.cpp \ + /home/itten/mxl-multiviewer/Swapchain.hpp \ + /home/itten/mxl-multiviewer/VulkanContext.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/algorithm \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_algo.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/optional \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/execution_defs.h \ + /usr/include/c++/15/pstl/glue_algorithm_defs.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/time.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o: /home/itten/mxl-multiviewer/TileLayout.cpp \ + /home/itten/mxl-multiviewer/TileLayout.hpp \ + /usr/include/alloca.h \ + /usr/include/c++/15/algorithm \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_algo.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/specfun.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cmath \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/limits \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/pstl/execution_defs.h \ + /usr/include/c++/15/pstl/glue_algorithm_defs.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/tr1/bessel_function.tcc \ + /usr/include/c++/15/tr1/beta_function.tcc \ + /usr/include/c++/15/tr1/ell_integral.tcc \ + /usr/include/c++/15/tr1/exp_integral.tcc \ + /usr/include/c++/15/tr1/gamma.tcc \ + /usr/include/c++/15/tr1/hypergeometric.tcc \ + /usr/include/c++/15/tr1/legendre_function.tcc \ + /usr/include/c++/15/tr1/modified_bessel_func.tcc \ + /usr/include/c++/15/tr1/poly_hermite.tcc \ + /usr/include/c++/15/tr1/poly_laguerre.tcc \ + /usr/include/c++/15/tr1/riemann_zeta.tcc \ + /usr/include/c++/15/tr1/special_function_util.h \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/vector \ + /usr/include/endian.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/math.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdlib.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o: /home/itten/mxl-multiviewer/V210ComputeDecoder.cpp \ + /home/itten/mxl-multiviewer/V210ComputeDecoder.hpp \ + /home/itten/mxl-multiviewer/VulkanUtils.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/codecvt.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/fstream.tcc \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/fstream \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/time.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o: /home/itten/mxl-multiviewer/VulkanContext.cpp \ + /home/itten/mxl-multiviewer/VulkanContext.hpp \ + /usr/include/SDL3/SDL.h \ + /usr/include/SDL3/SDL_assert.h \ + /usr/include/SDL3/SDL_asyncio.h \ + /usr/include/SDL3/SDL_atomic.h \ + /usr/include/SDL3/SDL_audio.h \ + /usr/include/SDL3/SDL_begin_code.h \ + /usr/include/SDL3/SDL_bits.h \ + /usr/include/SDL3/SDL_blendmode.h \ + /usr/include/SDL3/SDL_camera.h \ + /usr/include/SDL3/SDL_clipboard.h \ + /usr/include/SDL3/SDL_close_code.h \ + /usr/include/SDL3/SDL_cpuinfo.h \ + /usr/include/SDL3/SDL_dialog.h \ + /usr/include/SDL3/SDL_dlopennote.h \ + /usr/include/SDL3/SDL_endian.h \ + /usr/include/SDL3/SDL_error.h \ + /usr/include/SDL3/SDL_events.h \ + /usr/include/SDL3/SDL_filesystem.h \ + /usr/include/SDL3/SDL_gamepad.h \ + /usr/include/SDL3/SDL_gpu.h \ + /usr/include/SDL3/SDL_guid.h \ + /usr/include/SDL3/SDL_haptic.h \ + /usr/include/SDL3/SDL_hidapi.h \ + /usr/include/SDL3/SDL_hints.h \ + /usr/include/SDL3/SDL_init.h \ + /usr/include/SDL3/SDL_iostream.h \ + /usr/include/SDL3/SDL_joystick.h \ + /usr/include/SDL3/SDL_keyboard.h \ + /usr/include/SDL3/SDL_keycode.h \ + /usr/include/SDL3/SDL_loadso.h \ + /usr/include/SDL3/SDL_locale.h \ + /usr/include/SDL3/SDL_log.h \ + /usr/include/SDL3/SDL_messagebox.h \ + /usr/include/SDL3/SDL_metal.h \ + /usr/include/SDL3/SDL_misc.h \ + /usr/include/SDL3/SDL_mouse.h \ + /usr/include/SDL3/SDL_mutex.h \ + /usr/include/SDL3/SDL_oldnames.h \ + /usr/include/SDL3/SDL_pen.h \ + /usr/include/SDL3/SDL_pixels.h \ + /usr/include/SDL3/SDL_platform.h \ + /usr/include/SDL3/SDL_platform_defines.h \ + /usr/include/SDL3/SDL_power.h \ + /usr/include/SDL3/SDL_process.h \ + /usr/include/SDL3/SDL_properties.h \ + /usr/include/SDL3/SDL_rect.h \ + /usr/include/SDL3/SDL_render.h \ + /usr/include/SDL3/SDL_scancode.h \ + /usr/include/SDL3/SDL_sensor.h \ + /usr/include/SDL3/SDL_stdinc.h \ + /usr/include/SDL3/SDL_storage.h \ + /usr/include/SDL3/SDL_surface.h \ + /usr/include/SDL3/SDL_system.h \ + /usr/include/SDL3/SDL_thread.h \ + /usr/include/SDL3/SDL_time.h \ + /usr/include/SDL3/SDL_timer.h \ + /usr/include/SDL3/SDL_touch.h \ + /usr/include/SDL3/SDL_tray.h \ + /usr/include/SDL3/SDL_version.h \ + /usr/include/SDL3/SDL_video.h \ + /usr/include/SDL3/SDL_vulkan.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/optional \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/time.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o: /home/itten/mxl-multiviewer/VulkanUtils.cpp \ + /home/itten/mxl-multiviewer/VulkanUtils.hpp \ + /usr/include/alloca.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/linux/errno.h \ + /usr/include/locale.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o: /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp \ + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.h \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /home/itten/mxl-multiviewer/imgui/imgui.h \ + /usr/include/SDL3/SDL.h \ + /usr/include/SDL3/SDL_assert.h \ + /usr/include/SDL3/SDL_asyncio.h \ + /usr/include/SDL3/SDL_atomic.h \ + /usr/include/SDL3/SDL_audio.h \ + /usr/include/SDL3/SDL_begin_code.h \ + /usr/include/SDL3/SDL_bits.h \ + /usr/include/SDL3/SDL_blendmode.h \ + /usr/include/SDL3/SDL_camera.h \ + /usr/include/SDL3/SDL_clipboard.h \ + /usr/include/SDL3/SDL_close_code.h \ + /usr/include/SDL3/SDL_cpuinfo.h \ + /usr/include/SDL3/SDL_dialog.h \ + /usr/include/SDL3/SDL_dlopennote.h \ + /usr/include/SDL3/SDL_endian.h \ + /usr/include/SDL3/SDL_error.h \ + /usr/include/SDL3/SDL_events.h \ + /usr/include/SDL3/SDL_filesystem.h \ + /usr/include/SDL3/SDL_gamepad.h \ + /usr/include/SDL3/SDL_gpu.h \ + /usr/include/SDL3/SDL_guid.h \ + /usr/include/SDL3/SDL_haptic.h \ + /usr/include/SDL3/SDL_hidapi.h \ + /usr/include/SDL3/SDL_hints.h \ + /usr/include/SDL3/SDL_init.h \ + /usr/include/SDL3/SDL_iostream.h \ + /usr/include/SDL3/SDL_joystick.h \ + /usr/include/SDL3/SDL_keyboard.h \ + /usr/include/SDL3/SDL_keycode.h \ + /usr/include/SDL3/SDL_loadso.h \ + /usr/include/SDL3/SDL_locale.h \ + /usr/include/SDL3/SDL_log.h \ + /usr/include/SDL3/SDL_messagebox.h \ + /usr/include/SDL3/SDL_metal.h \ + /usr/include/SDL3/SDL_misc.h \ + /usr/include/SDL3/SDL_mouse.h \ + /usr/include/SDL3/SDL_mutex.h \ + /usr/include/SDL3/SDL_oldnames.h \ + /usr/include/SDL3/SDL_pen.h \ + /usr/include/SDL3/SDL_pixels.h \ + /usr/include/SDL3/SDL_platform.h \ + /usr/include/SDL3/SDL_platform_defines.h \ + /usr/include/SDL3/SDL_power.h \ + /usr/include/SDL3/SDL_process.h \ + /usr/include/SDL3/SDL_properties.h \ + /usr/include/SDL3/SDL_rect.h \ + /usr/include/SDL3/SDL_render.h \ + /usr/include/SDL3/SDL_scancode.h \ + /usr/include/SDL3/SDL_sensor.h \ + /usr/include/SDL3/SDL_stdinc.h \ + /usr/include/SDL3/SDL_storage.h \ + /usr/include/SDL3/SDL_surface.h \ + /usr/include/SDL3/SDL_system.h \ + /usr/include/SDL3/SDL_thread.h \ + /usr/include/SDL3/SDL_time.h \ + /usr/include/SDL3/SDL_timer.h \ + /usr/include/SDL3/SDL_touch.h \ + /usr/include/SDL3/SDL_tray.h \ + /usr/include/SDL3/SDL_version.h \ + /usr/include/SDL3/SDL_video.h \ + /usr/include/assert.h \ + /usr/include/endian.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o: /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.cpp \ + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.h \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /home/itten/mxl-multiviewer/imgui/imgui.h \ + /usr/include/assert.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui.cpp \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /home/itten/mxl-multiviewer/imgui/imgui.h \ + /home/itten/mxl-multiviewer/imgui/imgui_internal.h \ + /usr/include/alloca.h \ + /usr/include/assert.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/specfun.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cmath \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/limits \ + /usr/include/c++/15/math.h \ + /usr/include/c++/15/new \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdlib.h \ + /usr/include/c++/15/tr1/bessel_function.tcc \ + /usr/include/c++/15/tr1/beta_function.tcc \ + /usr/include/c++/15/tr1/ell_integral.tcc \ + /usr/include/c++/15/tr1/exp_integral.tcc \ + /usr/include/c++/15/tr1/gamma.tcc \ + /usr/include/c++/15/tr1/hypergeometric.tcc \ + /usr/include/c++/15/tr1/legendre_function.tcc \ + /usr/include/c++/15/tr1/modified_bessel_func.tcc \ + /usr/include/c++/15/tr1/poly_hermite.tcc \ + /usr/include/c++/15/tr1/poly_laguerre.tcc \ + /usr/include/c++/15/tr1/riemann_zeta.tcc \ + /usr/include/c++/15/tr1/special_function_util.h \ + /usr/include/c++/15/type_traits \ + /usr/include/endian.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/limits.h \ + /usr/include/math.h \ + /usr/include/signal.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/unistd.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/sigaction.h \ + /usr/include/x86_64-linux-gnu/bits/sigcontext.h \ + /usr/include/x86_64-linux-gnu/bits/sigevent-consts.h \ + /usr/include/x86_64-linux-gnu/bits/siginfo-arch.h \ + /usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h \ + /usr/include/x86_64-linux-gnu/bits/siginfo-consts.h \ + /usr/include/x86_64-linux-gnu/bits/signal_ext.h \ + /usr/include/x86_64-linux-gnu/bits/signum-arch.h \ + /usr/include/x86_64-linux-gnu/bits/signum-generic.h \ + /usr/include/x86_64-linux-gnu/bits/sigstack.h \ + /usr/include/x86_64-linux-gnu/bits/sigstksz.h \ + /usr/include/x86_64-linux-gnu/bits/sigthread.h \ + /usr/include/x86_64-linux-gnu/bits/ss_flags.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/idtype_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigval_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/stack_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/sys/ucontext.h \ + /usr/include/x86_64-linux-gnu/sys/wait.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui_draw.cpp \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /home/itten/mxl-multiviewer/imgui/imgui.h \ + /home/itten/mxl-multiviewer/imgui/imgui_internal.h \ + /home/itten/mxl-multiviewer/imgui/imstb_rectpack.h \ + /home/itten/mxl-multiviewer/imgui/imstb_truetype.h \ + /usr/include/alloca.h \ + /usr/include/assert.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/specfun.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cmath \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/limits \ + /usr/include/c++/15/math.h \ + /usr/include/c++/15/new \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdlib.h \ + /usr/include/c++/15/tr1/bessel_function.tcc \ + /usr/include/c++/15/tr1/beta_function.tcc \ + /usr/include/c++/15/tr1/ell_integral.tcc \ + /usr/include/c++/15/tr1/exp_integral.tcc \ + /usr/include/c++/15/tr1/gamma.tcc \ + /usr/include/c++/15/tr1/hypergeometric.tcc \ + /usr/include/c++/15/tr1/legendre_function.tcc \ + /usr/include/c++/15/tr1/modified_bessel_func.tcc \ + /usr/include/c++/15/tr1/poly_hermite.tcc \ + /usr/include/c++/15/tr1/poly_laguerre.tcc \ + /usr/include/c++/15/tr1/riemann_zeta.tcc \ + /usr/include/c++/15/tr1/special_function_util.h \ + /usr/include/c++/15/type_traits \ + /usr/include/endian.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/limits.h \ + /usr/include/linux/limits.h \ + /usr/include/math.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui_tables.cpp \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /home/itten/mxl-multiviewer/imgui/imgui.h \ + /home/itten/mxl-multiviewer/imgui/imgui_internal.h \ + /usr/include/alloca.h \ + /usr/include/assert.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/specfun.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cmath \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/limits \ + /usr/include/c++/15/math.h \ + /usr/include/c++/15/new \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdlib.h \ + /usr/include/c++/15/tr1/bessel_function.tcc \ + /usr/include/c++/15/tr1/beta_function.tcc \ + /usr/include/c++/15/tr1/ell_integral.tcc \ + /usr/include/c++/15/tr1/exp_integral.tcc \ + /usr/include/c++/15/tr1/gamma.tcc \ + /usr/include/c++/15/tr1/hypergeometric.tcc \ + /usr/include/c++/15/tr1/legendre_function.tcc \ + /usr/include/c++/15/tr1/modified_bessel_func.tcc \ + /usr/include/c++/15/tr1/poly_hermite.tcc \ + /usr/include/c++/15/tr1/poly_laguerre.tcc \ + /usr/include/c++/15/tr1/riemann_zeta.tcc \ + /usr/include/c++/15/tr1/special_function_util.h \ + /usr/include/c++/15/type_traits \ + /usr/include/endian.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/limits.h \ + /usr/include/linux/limits.h \ + /usr/include/math.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o: /home/itten/mxl-multiviewer/imgui/imgui_widgets.cpp \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /home/itten/mxl-multiviewer/imgui/imgui.h \ + /home/itten/mxl-multiviewer/imgui/imgui_internal.h \ + /home/itten/mxl-multiviewer/imgui/imstb_textedit.h \ + /usr/include/alloca.h \ + /usr/include/assert.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/specfun.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cmath \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/limits \ + /usr/include/c++/15/math.h \ + /usr/include/c++/15/new \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/stdlib.h \ + /usr/include/c++/15/tr1/bessel_function.tcc \ + /usr/include/c++/15/tr1/beta_function.tcc \ + /usr/include/c++/15/tr1/ell_integral.tcc \ + /usr/include/c++/15/tr1/exp_integral.tcc \ + /usr/include/c++/15/tr1/gamma.tcc \ + /usr/include/c++/15/tr1/hypergeometric.tcc \ + /usr/include/c++/15/tr1/legendre_function.tcc \ + /usr/include/c++/15/tr1/modified_bessel_func.tcc \ + /usr/include/c++/15/tr1/poly_hermite.tcc \ + /usr/include/c++/15/tr1/poly_laguerre.tcc \ + /usr/include/c++/15/tr1/riemann_zeta.tcc \ + /usr/include/c++/15/tr1/special_function_util.h \ + /usr/include/c++/15/type_traits \ + /usr/include/endian.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/limits.h \ + /usr/include/linux/limits.h \ + /usr/include/math.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h + +CMakeFiles/mxl_multiviewer.dir/main.cpp.o: /home/itten/mxl-multiviewer/main.cpp \ + /home/itten/mxl-multiviewer/AppConfig.hpp \ + /home/itten/mxl-multiviewer/FeedCreate.hpp \ + /home/itten/mxl-multiviewer/FeedTexture.hpp \ + /home/itten/mxl-multiviewer/IVideoFeed.hpp \ + /home/itten/mxl-multiviewer/RenderPipeline.hpp \ + /home/itten/mxl-multiviewer/Swapchain.hpp \ + /home/itten/mxl-multiviewer/TileLayout.hpp \ + /home/itten/mxl-multiviewer/V210ComputeDecoder.hpp \ + /home/itten/mxl-multiviewer/VideoFrame.hpp \ + /home/itten/mxl-multiviewer/VulkanContext.hpp \ + /home/itten/mxl-multiviewer/VulkanUtils.hpp \ + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.h \ + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.h \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /home/itten/mxl-multiviewer/imgui/imgui.h \ + /usr/include/SDL3/SDL.h \ + /usr/include/SDL3/SDL_assert.h \ + /usr/include/SDL3/SDL_asyncio.h \ + /usr/include/SDL3/SDL_atomic.h \ + /usr/include/SDL3/SDL_audio.h \ + /usr/include/SDL3/SDL_begin_code.h \ + /usr/include/SDL3/SDL_bits.h \ + /usr/include/SDL3/SDL_blendmode.h \ + /usr/include/SDL3/SDL_camera.h \ + /usr/include/SDL3/SDL_clipboard.h \ + /usr/include/SDL3/SDL_close_code.h \ + /usr/include/SDL3/SDL_cpuinfo.h \ + /usr/include/SDL3/SDL_dialog.h \ + /usr/include/SDL3/SDL_dlopennote.h \ + /usr/include/SDL3/SDL_endian.h \ + /usr/include/SDL3/SDL_error.h \ + /usr/include/SDL3/SDL_events.h \ + /usr/include/SDL3/SDL_filesystem.h \ + /usr/include/SDL3/SDL_gamepad.h \ + /usr/include/SDL3/SDL_gpu.h \ + /usr/include/SDL3/SDL_guid.h \ + /usr/include/SDL3/SDL_haptic.h \ + /usr/include/SDL3/SDL_hidapi.h \ + /usr/include/SDL3/SDL_hints.h \ + /usr/include/SDL3/SDL_init.h \ + /usr/include/SDL3/SDL_iostream.h \ + /usr/include/SDL3/SDL_joystick.h \ + /usr/include/SDL3/SDL_keyboard.h \ + /usr/include/SDL3/SDL_keycode.h \ + /usr/include/SDL3/SDL_loadso.h \ + /usr/include/SDL3/SDL_locale.h \ + /usr/include/SDL3/SDL_log.h \ + /usr/include/SDL3/SDL_messagebox.h \ + /usr/include/SDL3/SDL_metal.h \ + /usr/include/SDL3/SDL_misc.h \ + /usr/include/SDL3/SDL_mouse.h \ + /usr/include/SDL3/SDL_mutex.h \ + /usr/include/SDL3/SDL_oldnames.h \ + /usr/include/SDL3/SDL_pen.h \ + /usr/include/SDL3/SDL_pixels.h \ + /usr/include/SDL3/SDL_platform.h \ + /usr/include/SDL3/SDL_platform_defines.h \ + /usr/include/SDL3/SDL_power.h \ + /usr/include/SDL3/SDL_process.h \ + /usr/include/SDL3/SDL_properties.h \ + /usr/include/SDL3/SDL_rect.h \ + /usr/include/SDL3/SDL_render.h \ + /usr/include/SDL3/SDL_scancode.h \ + /usr/include/SDL3/SDL_sensor.h \ + /usr/include/SDL3/SDL_stdinc.h \ + /usr/include/SDL3/SDL_storage.h \ + /usr/include/SDL3/SDL_surface.h \ + /usr/include/SDL3/SDL_system.h \ + /usr/include/SDL3/SDL_thread.h \ + /usr/include/SDL3/SDL_time.h \ + /usr/include/SDL3/SDL_timer.h \ + /usr/include/SDL3/SDL_touch.h \ + /usr/include/SDL3/SDL_tray.h \ + /usr/include/SDL3/SDL_version.h \ + /usr/include/SDL3/SDL_video.h \ + /usr/include/alloca.h \ + /usr/include/asm-generic/bitsperlong.h \ + /usr/include/asm-generic/errno-base.h \ + /usr/include/asm-generic/errno.h \ + /usr/include/asm-generic/int-ll64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/asm-generic/types.h \ + /usr/include/assert.h \ + /usr/include/c++/15/algorithm \ + /usr/include/c++/15/atomic \ + /usr/include/c++/15/backward/auto_ptr.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/align.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/allocated_ptr.h \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/c++/15/bits/atomic_base.h \ + /usr/include/c++/15/bits/atomic_lockfree_defines.h \ + /usr/include/c++/15/bits/atomic_wait.h \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/char_traits.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/chrono.h \ + /usr/include/c++/15/bits/codecvt.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/bits/erase_if.h \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/fs_dir.h \ + /usr/include/c++/15/bits/fs_fwd.h \ + /usr/include/c++/15/bits/fs_ops.h \ + /usr/include/c++/15/bits/fs_path.h \ + /usr/include/c++/15/bits/fstream.tcc \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/ios_base.h \ + /usr/include/c++/15/bits/istream.tcc \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/locale_classes.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/bits/locale_conv.h \ + /usr/include/c++/15/bits/locale_facets.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/locale_facets_nonio.h \ + /usr/include/c++/15/bits/locale_facets_nonio.tcc \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/c++/15/bits/max_size_type.h \ + /usr/include/c++/15/bits/memory_resource.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/node_handle.h \ + /usr/include/c++/15/bits/ostream.h \ + /usr/include/c++/15/bits/ostream.tcc \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/parse_numbers.h \ + /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/bits/predefined_ops.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/quoted_string.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/ranges_algo.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/ranges_uninitialized.h \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/shared_ptr.h \ + /usr/include/c++/15/bits/shared_ptr_atomic.h \ + /usr/include/c++/15/bits/shared_ptr_base.h \ + /usr/include/c++/15/bits/sstream.tcc \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/std_mutex.h \ + /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/stl_map.h \ + /usr/include/c++/15/bits/stl_multimap.h \ + /usr/include/c++/15/bits/stl_pair.h \ + /usr/include/c++/15/bits/stl_raw_storage_iter.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/stl_tree.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/unique_ptr.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h \ + /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/cctype \ + /usr/include/c++/15/cerrno \ + /usr/include/c++/15/climits \ + /usr/include/c++/15/clocale \ + /usr/include/c++/15/codecvt \ + /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/csignal \ + /usr/include/c++/15/cstddef \ + /usr/include/c++/15/cstdint \ + /usr/include/c++/15/cstdio \ + /usr/include/c++/15/cstdlib \ + /usr/include/c++/15/cstring \ + /usr/include/c++/15/ctime \ + /usr/include/c++/15/cwchar \ + /usr/include/c++/15/cwctype \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/exception \ + /usr/include/c++/15/ext/aligned_buffer.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/ext/atomicity.h \ + /usr/include/c++/15/ext/concurrence.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/ext/string_conversions.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/filesystem \ + /usr/include/c++/15/fstream \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/iomanip \ + /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd \ + /usr/include/c++/15/iostream \ + /usr/include/c++/15/istream \ + /usr/include/c++/15/limits \ + /usr/include/c++/15/locale \ + /usr/include/c++/15/map \ + /usr/include/c++/15/memory \ + /usr/include/c++/15/new \ + /usr/include/c++/15/numbers \ + /usr/include/c++/15/optional \ + /usr/include/c++/15/ostream \ + /usr/include/c++/15/pstl/execution_defs.h \ + /usr/include/c++/15/pstl/glue_algorithm_defs.h \ + /usr/include/c++/15/pstl/glue_memory_defs.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/include/c++/15/ratio \ + /usr/include/c++/15/sstream \ + /usr/include/c++/15/stdexcept \ + /usr/include/c++/15/streambuf \ + /usr/include/c++/15/string \ + /usr/include/c++/15/string_view \ + /usr/include/c++/15/system_error \ + /usr/include/c++/15/tuple \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/typeinfo \ + /usr/include/c++/15/vector \ + /usr/include/ctype.h \ + /usr/include/endian.h \ + /usr/include/errno.h \ + /usr/include/features-time64.h \ + /usr/include/features.h \ + /usr/include/libintl.h \ + /usr/include/limits.h \ + /usr/include/linux/close_range.h \ + /usr/include/linux/errno.h \ + /usr/include/linux/limits.h \ + /usr/include/linux/posix_types.h \ + /usr/include/linux/sched/types.h \ + /usr/include/linux/stddef.h \ + /usr/include/linux/types.h \ + /usr/include/locale.h \ + /usr/include/pthread.h \ + /usr/include/sched.h \ + /usr/include/signal.h \ + /usr/include/stdc-predef.h \ + /usr/include/stdint.h \ + /usr/include/stdio.h \ + /usr/include/stdlib.h \ + /usr/include/string.h \ + /usr/include/strings.h \ + /usr/include/syscall.h \ + /usr/include/time.h \ + /usr/include/unistd.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vulkan/vk_platform.h \ + /usr/include/vulkan/vulkan.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/wchar.h \ + /usr/include/wctype.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/x86_64-linux-gnu/asm/unistd.h \ + /usr/include/x86_64-linux-gnu/asm/unistd_64.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/confname.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/environments.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_core.h \ + /usr/include/x86_64-linux-gnu/bits/getopt_posix.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/local_lim.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/bits/posix1_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix2_lim.h \ + /usr/include/x86_64-linux-gnu/bits/posix_opt.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/sigaction.h \ + /usr/include/x86_64-linux-gnu/bits/sigcontext.h \ + /usr/include/x86_64-linux-gnu/bits/sigevent-consts.h \ + /usr/include/x86_64-linux-gnu/bits/siginfo-arch.h \ + /usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h \ + /usr/include/x86_64-linux-gnu/bits/siginfo-consts.h \ + /usr/include/x86_64-linux-gnu/bits/signal_ext.h \ + /usr/include/x86_64-linux-gnu/bits/signum-arch.h \ + /usr/include/x86_64-linux-gnu/bits/signum-generic.h \ + /usr/include/x86_64-linux-gnu/bits/sigstack.h \ + /usr/include/x86_64-linux-gnu/bits/sigstksz.h \ + /usr/include/x86_64-linux-gnu/bits/sigthread.h \ + /usr/include/x86_64-linux-gnu/bits/ss_flags.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/syscall.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigval_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/stack_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/bits/uio_lim.h \ + /usr/include/x86_64-linux-gnu/bits/unistd_ext.h \ + /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/xopen_lim.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/messages_members.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/time_members.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/x86_64-linux-gnu/sys/syscall.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/sys/ucontext.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h + +mxl_multiviewer: /home/itten/dmf-mxl/mxl-1.0.1/build/Linux-Clang-Release/lib/internal/libmxl-common.so \ + /home/itten/dmf-mxl/mxl-1.0.1/build/Linux-Clang-Release/lib/libmxl.so \ + /lib64/ld-linux-x86-64.so.2 \ + /usr/lib/x86_64-linux-gnu/Scrt1.o \ + /usr/lib/x86_64-linux-gnu/crti.o \ + /usr/lib/x86_64-linux-gnu/crtn.o \ + /usr/lib/x86_64-linux-gnu/libSDL3.so \ + /usr/lib/x86_64-linux-gnu/libc.so \ + /usr/lib/x86_64-linux-gnu/libgcc_s.so.1 \ + /usr/lib/x86_64-linux-gnu/libm.so \ + /usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o \ + /usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o \ + /usr/lib/gcc/x86_64-linux-gnu/15/libgcc.a \ + /usr/lib/gcc/x86_64-linux-gnu/15/libgcc_s.so \ + /usr/lib/gcc/x86_64-linux-gnu/15/libstdc++.so \ + /usr/lib/x86_64-linux-gnu/libFLAC.so.14 \ + /usr/lib/x86_64-linux-gnu/libX11-xcb.so.1 \ + /usr/lib/x86_64-linux-gnu/libX11.so.6 \ + /usr/lib/x86_64-linux-gnu/libXau.so.6 \ + /usr/lib/x86_64-linux-gnu/libXcursor.so.1 \ + /usr/lib/x86_64-linux-gnu/libXdmcp.so.6 \ + /usr/lib/x86_64-linux-gnu/libXext.so.6 \ + /usr/lib/x86_64-linux-gnu/libXfixes.so.3 \ + /usr/lib/x86_64-linux-gnu/libXi.so.6 \ + /usr/lib/x86_64-linux-gnu/libXrandr.so.2 \ + /usr/lib/x86_64-linux-gnu/libXrender.so.1 \ + /usr/lib/x86_64-linux-gnu/libXss.so.1 \ + /usr/lib/x86_64-linux-gnu/libXtst.so.6 \ + /usr/lib/x86_64-linux-gnu/libapparmor.so.1 \ + /usr/lib/x86_64-linux-gnu/libasound.so.2 \ + /usr/lib/x86_64-linux-gnu/libasyncns.so.0 \ + /usr/lib/x86_64-linux-gnu/libc.so.6 \ + /usr/lib/x86_64-linux-gnu/libc_nonshared.a \ + /usr/lib/x86_64-linux-gnu/libdbus-1.so.3 \ + /usr/lib/x86_64-linux-gnu/libdecor-0.so.0 \ + /usr/lib/x86_64-linux-gnu/libdrm.so.2 \ + /usr/lib/x86_64-linux-gnu/libexpat.so.1 \ + /usr/lib/x86_64-linux-gnu/libffi.so.8 \ + /usr/lib/x86_64-linux-gnu/libfribidi.so.0 \ + /usr/lib/x86_64-linux-gnu/libgbm.so.1 \ + /usr/lib/x86_64-linux-gnu/libm.so.6 \ + /usr/lib/x86_64-linux-gnu/libmp3lame.so.0 \ + /usr/lib/x86_64-linux-gnu/libmpg123.so.0 \ + /usr/lib/x86_64-linux-gnu/libmvec.so.1 \ + /usr/lib/x86_64-linux-gnu/libogg.so.0 \ + /usr/lib/x86_64-linux-gnu/libopus.so.0 \ + /usr/lib/x86_64-linux-gnu/libpulse.so.0 \ + /usr/lib/x86_64-linux-gnu/libsndfile.so.1 \ + /usr/lib/x86_64-linux-gnu/libsystemd.so.0 \ + /usr/lib/x86_64-linux-gnu/libvorbis.so.0 \ + /usr/lib/x86_64-linux-gnu/libvorbisenc.so.2 \ + /usr/lib/x86_64-linux-gnu/libvulkan.so \ + /usr/lib/x86_64-linux-gnu/libwayland-client.so.0 \ + /usr/lib/x86_64-linux-gnu/libwayland-cursor.so.0 \ + /usr/lib/x86_64-linux-gnu/libwayland-egl.so.1 \ + /usr/lib/x86_64-linux-gnu/libxcb.so.1 \ + /usr/lib/x86_64-linux-gnu/libxkbcommon.so.0 \ + /usr/lib/x86_64-linux-gnu/pulseaudio/libpulsecommon-17.0.so \ + CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o \ + CMakeFiles/mxl_multiviewer.dir/main.cpp.o + + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/VulkanContext.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/SmpteBarsFeed.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/RenderPipeline.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/NoSignalFeed.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/MxlSdkFeed.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/MxlFeed.cpp.o: + +CMakeFiles/mxl_multiviewer.dir/FeedTexture.cpp.o: + +/usr/lib/x86_64-linux-gnu/pulseaudio/libpulsecommon-17.0.so: + +/usr/lib/x86_64-linux-gnu/libxkbcommon.so.0: + +/usr/lib/x86_64-linux-gnu/libxcb.so.1: + +/usr/lib/x86_64-linux-gnu/libwayland-egl.so.1: + +/usr/lib/x86_64-linux-gnu/libvulkan.so: + +/usr/lib/x86_64-linux-gnu/libvorbisenc.so.2: + +/usr/lib/x86_64-linux-gnu/libsystemd.so.0: + +/usr/lib/x86_64-linux-gnu/libsndfile.so.1: + +/usr/lib/x86_64-linux-gnu/libogg.so.0: + +/usr/lib/x86_64-linux-gnu/libmp3lame.so.0: + +/usr/lib/x86_64-linux-gnu/libffi.so.8: + +/usr/lib/x86_64-linux-gnu/libexpat.so.1: + +/usr/lib/x86_64-linux-gnu/libdrm.so.2: + +/usr/lib/x86_64-linux-gnu/libc_nonshared.a: + +/usr/lib/x86_64-linux-gnu/libasyncns.so.0: + +/usr/lib/x86_64-linux-gnu/libasound.so.2: + +/usr/lib/x86_64-linux-gnu/libapparmor.so.1: + +/usr/lib/x86_64-linux-gnu/libXss.so.1: + +/usr/lib/x86_64-linux-gnu/libXrender.so.1: + +/usr/lib/x86_64-linux-gnu/libXrandr.so.2: + +/usr/lib/x86_64-linux-gnu/libXi.so.6: + +/usr/lib/x86_64-linux-gnu/libXfixes.so.3: + +/usr/lib/x86_64-linux-gnu/libXcursor.so.1: + +/usr/lib/x86_64-linux-gnu/libXau.so.6: + +/usr/lib/x86_64-linux-gnu/libFLAC.so.14: + +/usr/lib/gcc/x86_64-linux-gnu/15/libstdc++.so: + +/usr/lib/gcc/x86_64-linux-gnu/15/libgcc.a: + +/usr/lib/gcc/x86_64-linux-gnu/15/crtendS.o: + +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o: + +/usr/lib/gcc/x86_64-linux-gnu/15/crtbeginS.o: + +/usr/lib/x86_64-linux-gnu/libm.so: + +/usr/lib/x86_64-linux-gnu/libSDL3.so: + +/usr/lib/x86_64-linux-gnu/crtn.o: + +/usr/lib/x86_64-linux-gnu/crti.o: + +/usr/lib/x86_64-linux-gnu/libc.so: + +/usr/lib/x86_64-linux-gnu/Scrt1.o: + +/home/itten/dmf-mxl/mxl-1.0.1/build/Linux-Clang-Release/lib/internal/libmxl-common.so: + +/usr/include/c++/15/filesystem: + +/usr/include/c++/15/bits/node_handle.h: + +/usr/include/c++/15/bits/fs_path.h: + +/usr/include/c++/15/bits/fs_fwd.h: + +/usr/lib/x86_64-linux-gnu/libX11-xcb.so.1: + +/usr/include/c++/15/bits/fs_dir.h: + +/home/itten/mxl-multiviewer/imgui/imstb_textedit.h: + +/usr/lib/x86_64-linux-gnu/libpulse.so.0: + +/home/itten/mxl-multiviewer/imgui/imgui_widgets.cpp: + +/home/itten/mxl-multiviewer/imgui/imstb_truetype.h: + +/home/itten/mxl-multiviewer/imgui/imstb_rectpack.h: + +/home/itten/mxl-multiviewer/imgui/imgui_draw.cpp: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/xsavecintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/xmmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/x86gprintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/wbnoinvdintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/vpclmulqdqintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/vaesintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/tsxldtrkintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/sm4intrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/sm3intrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/shaintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/sha512intrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/raointintrin.h: + +/home/itten/dmf-mxl/mxl-1.0.1/build/Linux-Clang-Release/lib/libmxl.so: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/prfchwintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/popcntintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/pkuintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/movrsintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/mmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/lzcntintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/lwpintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/keylockerintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/immintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/gfniintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/fmaintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/f16cintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/enqcmdintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/cmpccxaddintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/clzerointrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/clwbintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/cldemoteintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/cetintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/bmiintrin.h: + +CMakeFiles/mxl_multiviewer.dir/VulkanUtils.cpp.o: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/bmi2intrin.h: + +/usr/include/c++/15/pstl/glue_memory_defs.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniintrin.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/movdirintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/mm_malloc.h: + +/usr/include/SDL3/SDL_power.h: + +/usr/include/c++/15/bits/ranges_util.h: + +/usr/include/x86_64-linux-gnu/asm/unistd_64.h: + +/usr/include/c++/15/bits/shared_ptr_base.h: + +/usr/include/c++/15/bits/stl_uninitialized.h: + +/usr/include/SDL3/SDL_endian.h: + +/usr/include/c++/15/bits/shared_ptr_atomic.h: + +/usr/include/c++/15/bits/exception_defines.h: + +/usr/include/c++/15/bits/stl_heap.h: + +/usr/include/c++/15/bits/stl_construct.h: + +/home/itten/mxl-multiviewer/NoSignalFeed.hpp: + +/usr/include/c++/15/bits/ptr_traits.h: + +/home/itten/mxl-multiviewer/TileLayout.cpp: + +/usr/lib/x86_64-linux-gnu/libXtst.so.6: + +/usr/include/c++/15/ext/numeric_traits.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/float.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp16intrin.h: + +/home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/time.h: + +/usr/include/x86_64-linux-gnu/asm/posix_types.h: + +/home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flow.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h: + +/home/itten/mxl-multiviewer/V210ComputeDecoder.hpp: + +/usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h: + +/home/itten/mxl-multiviewer/IVideoFeed.hpp: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h: + +/usr/include/vk_video/vulkan_video_codec_vp9std.h: + +/usr/lib/x86_64-linux-gnu/libdecor-0.so.0: + +/usr/include/c++/15/pstl/execution_defs.h: + +/usr/include/x86_64-linux-gnu/bits/uio_lim.h: + +/usr/include/x86_64-linux-gnu/bits/waitflags.h: + +/usr/include/x86_64-linux-gnu/bits/types/timer_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_tm.h: + +/usr/include/asm-generic/errno.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h: + +/usr/include/x86_64-linux-gnu/bits/types/clockid_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h: + +/usr/include/x86_64-linux-gnu/bits/wctype-wchar.h: + +/usr/include/c++/15/bits/functexcept.h: + +/usr/include/c++/15/bits/stl_vector.h: + +/usr/include/c++/15/bits/atomic_base.h: + +/usr/include/x86_64-linux-gnu/bits/wchar.h: + +/usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/clock_t.h: + +/usr/include/c++/15/bits/erase_if.h: + +/usr/include/c++/15/bits/std_mutex.h: + +/usr/include/c++/15/charconv: + +/usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h: + +/usr/include/c++/15/tr1/special_function_util.h: + +/usr/include/c++/15/bits/stl_iterator_base_funcs.h: + +/usr/include/x86_64-linux-gnu/bits/struct_mutex.h: + +/usr/include/vk_video/vulkan_video_codec_vp9std_decode.h: + +/usr/include/c++/15/tr1/poly_hermite.tcc: + +/usr/include/x86_64-linux-gnu/bits/uintn-identity.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h: + +/usr/include/c++/15/bits/new_allocator.h: + +/usr/include/SDL3/SDL_bits.h: + +/usr/include/x86_64-linux-gnu/bits/stdio_lim.h: + +/usr/include/x86_64-linux-gnu/bits/timex.h: + +/usr/include/x86_64-linux-gnu/sys/select.h: + +/usr/include/x86_64-linux-gnu/bits/stdint-uintn.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h: + +/usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h: + +/home/itten/mxl-multiviewer/Swapchain.cpp: + +CMakeFiles/mxl_multiviewer.dir/main.cpp.o: + +/usr/include/x86_64-linux-gnu/bits/stdint-least.h: + +/usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h: + +/usr/include/x86_64-linux-gnu/bits/getopt_posix.h: + +/usr/include/x86_64-linux-gnu/bits/select.h: + +/usr/include/x86_64-linux-gnu/bits/time.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h: + +/usr/lib/x86_64-linux-gnu/libwayland-cursor.so.0: + +/usr/include/x86_64-linux-gnu/bits/sched.h: + +/home/itten/mxl-multiviewer/imgui/imconfig.h: + +/home/itten/mxl-multiviewer/VideoFrame.hpp: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlintrin.h: + +/usr/include/c++/15/bits/atomic_lockfree_defines.h: + +/usr/include/c++/15/cstring: + +/usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/hresetintrin.h: + +/usr/include/c++/15/bits/unique_ptr.h: + +/usr/include/c++/15/bits/move.h: + +/home/itten/mxl-multiviewer/MxlFeed.hpp: + +/usr/include/SDL3/SDL_messagebox.h: + +/usr/include/x86_64-linux-gnu/bits/libc-header-start.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h: + +/usr/include/x86_64-linux-gnu/bits/floatn.h: + +/usr/include/x86_64-linux-gnu/bits/endianness.h: + +/usr/lib/x86_64-linux-gnu/libgcc_s.so.1: + +/usr/include/x86_64-linux-gnu/gnu/stubs.h: + +/usr/include/x86_64-linux-gnu/bits/cpu-set.h: + +/usr/include/SDL3/SDL_mutex.h: + +/usr/include/x86_64-linux-gnu/asm/posix_types_64.h: + +/usr/include/c++/15/bits/this_thread_sleep.h: + +/usr/include/x86_64-linux-gnu/bits/byteswap.h: + +/usr/include/x86_64-linux-gnu/bits/time64.h: + +/usr/include/c++/15/ext/aligned_buffer.h: + +/usr/include/x86_64-linux-gnu/asm/types.h: + +/usr/include/SDL3/SDL_log.h: + +/usr/include/stdio.h: + +/usr/include/sched.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/ia32intrin.h: + +/usr/include/wctype.h: + +/usr/include/c++/15/bits/exception.h: + +/usr/include/strings.h: + +/usr/include/asm-generic/bitsperlong.h: + +/usr/include/x86_64-linux-gnu/bits/types/sigset_t.h: + +/usr/include/c++/15/debug/assertions.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h: + +/usr/include/x86_64-linux-gnu/asm/bitsperlong.h: + +/usr/include/SDL3/SDL_surface.h: + +/usr/include/c++/15/typeinfo: + +/usr/include/c++/15/bits/ranges_algo.h: + +/usr/include/x86_64-linux-gnu/bits/signum-arch.h: + +/usr/include/c++/15/bits/ostream_insert.h: + +/usr/include/c++/15/bits/ostream.tcc: + +/home/itten/mxl-multiviewer/NoSignalFeed.cpp: + +/usr/include/c++/15/bits/stl_raw_storage_iter.h: + +/usr/include/c++/15/bits/ostream.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmavlintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/libgcc_s.so: + +/usr/include/x86_64-linux-gnu/bits/long-double.h: + +/usr/include/x86_64-linux-gnu/bits/pthreadtypes.h: + +/usr/include/c++/15/string_view: + +/usr/include/c++/15/bits/basic_string.tcc: + +/usr/include/c++/15/bits/streambuf.tcc: + +/usr/include/x86_64-linux-gnu/gnu/stubs-64.h: + +/usr/include/c++/15/ext/string_conversions.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512cdintrin.h: + +/home/itten/mxl-multiviewer/imgui/imgui_tables.cpp: + +/home/itten/mxl-multiviewer/SmpteBarsFeed.hpp: + +/usr/include/c++/15/bits/stringfwd.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmiintrin.h: + +/usr/include/c++/15/bits/max_size_type.h: + +/usr/include/c++/15/bits/localefwd.h: + +/usr/include/c++/15/bits/iterator_concepts.h: + +/usr/include/vk_video/vulkan_video_codec_av1std_decode.h: + +/usr/include/x86_64-linux-gnu/bits/stdlib-float.h: + +/usr/include/wchar.h: + +/usr/include/c++/15/sstream: + +/usr/include/SDL3/SDL_keycode.h: + +/usr/include/c++/15/bits/ios_base.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/usermsrintrin.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h: + +/usr/include/c++/15/bits/alloc_traits.h: + +/home/itten/mxl-multiviewer/MxlSdkFeed.hpp: + +/usr/include/linux/close_range.h: + +/usr/include/c++/15/bits/locale_classes.tcc: + +/usr/include/c++/15/algorithm: + +/usr/include/x86_64-linux-gnu/bits/math-vector.h: + +/home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.cpp: + +/home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/platform.h: + +/usr/include/c++/15/bits/range_access.h: + +/home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/rational.h: + +/usr/include/c++/15/bits/cxxabi_init_exception.h: + +/usr/include/x86_64-linux-gnu/bits/syscall.h: + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o: + +/usr/include/c++/15/iostream: + +/usr/include/c++/15/climits: + +/usr/include/c++/15/bits/vector.tcc: + +/usr/include/c++/15/bits/cxxabi_forced.h: + +/usr/include/c++/15/compare: + +/usr/include/SDL3/SDL_rect.h: + +/usr/include/c++/15/bits/specfun.h: + +/usr/include/c++/15/cstddef: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/mwaitxintrin.h: + +/usr/include/errno.h: + +/usr/include/c++/15/ostream: + +/usr/include/c++/15/bits/basic_string.h: + +/usr/include/c++/15/bits/cpp_type_traits.h: + +/usr/include/c++/15/bits/ranges_cmp.h: + +/usr/include/SDL3/SDL_thread.h: + +/usr/include/c++/15/bits/fstream.tcc: + +/usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h: + +/usr/include/math.h: + +/usr/include/x86_64-linux-gnu/bits/types/__FILE.h: + +/usr/include/c++/15/bits/locale_classes.h: + +/usr/include/linux/stddef.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/wmmintrin.h: + +/usr/include/c++/15/bit: + +/usr/include/c++/15/bits/allocator.h: + +/usr/include/asm-generic/posix_types.h: + +CMakeFiles/mxl_multiviewer.dir/AppConfig.cpp.o: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint8intrin.h: + +/usr/include/pthread.h: + +/usr/include/x86_64-linux-gnu/bits/waitstatus.h: + +/usr/include/asm-generic/errno-base.h: + +/usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/adxintrin.h: + +/home/itten/mxl-multiviewer/FeedCreate.cpp: + +/usr/include/c++/15/bits/predefined_ops.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/uintrintrin.h: + +/usr/include/c++/15/optional: + +/home/itten/mxl-multiviewer/imgui/imgui_internal.h: + +/home/itten/mxl-multiviewer/V210ComputeDecoder.cpp: + +/home/itten/mxl-multiviewer/AppConfig.cpp: + +/usr/lib/x86_64-linux-gnu/libX11.so.6: + +/usr/include/x86_64-linux-gnu/sys/single_threaded.h: + +/usr/include/c++/15/bits/ranges_base.h: + +/usr/include/c++/15/bits/shared_ptr.h: + +/usr/include/c++/15/iomanip: + +/usr/include/c++/15/bits/stl_iterator_base_types.h: + +/usr/include/ctype.h: + +/usr/include/vk_video/vulkan_video_codec_h265std_encode.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avxintrin.h: + +/usr/include/stdlib.h: + +/usr/include/c++/15/bits/locale_facets.tcc: + +/usr/include/features.h: + +/usr/include/alloca.h: + +/usr/include/stdint.h: + +/usr/include/endian.h: + +/usr/lib/x86_64-linux-gnu/libmpg123.so.0: + +/usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h: + +/usr/include/c++/15/bits/uses_allocator.h: + +/usr/include/c++/15/bits/concept_check.h: + +/usr/include/c++/15/bits/version.h: + +/usr/include/c++/15/bits/fs_ops.h: + +/home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/flowinfo.h: + +/lib64/ld-linux-x86-64.so.2: + +/usr/include/c++/15/bits/istream.tcc: + +/usr/include/c++/15/bits/charconv.h: + +/usr/include/c++/15/pstl/glue_algorithm_defs.h: + +/usr/include/c++/15/tr1/poly_laguerre.tcc: + +/usr/include/SDL3/SDL_begin_code.h: + +/usr/include/x86_64-linux-gnu/sys/wait.h: + +/usr/include/c++/15/type_traits: + +/usr/include/c++/15/map: + +/usr/include/c++/15/bits/refwrap.h: + +/usr/include/x86_64-linux-gnu/bits/types/FILE.h: + +/usr/include/x86_64-linux-gnu/bits/types/time_t.h: + +/usr/include/c++/15/bits/memoryfwd.h: + +/usr/include/c++/15/bits/nested_exception.h: + +/usr/include/SDL3/SDL_dlopennote.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/pconfigintrin.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h: + +/usr/include/x86_64-linux-gnu/asm/errno.h: + +/usr/include/SDL3/SDL_iostream.h: + +/usr/include/c++/15/concepts: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2satcvtintrin.h: + +/usr/include/c++/15/istream: + +/usr/include/x86_64-linux-gnu/bits/types/__locale_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_sigstack.h: + +/usr/include/x86_64-linux-gnu/bits/types/error_t.h: + +/usr/include/c++/15/bits/streambuf_iterator.h: + +/usr/include/c++/15/bits/string_view.tcc: + +/usr/include/c++/15/bits/utility.h: + +/home/itten/mxl-multiviewer/imgui/imgui.h: + +/usr/include/c++/15/bits/ranges_uninitialized.h: + +/usr/include/c++/15/bits/stl_bvector.h: + +/usr/include/x86_64-linux-gnu/bits/fp-fast.h: + +/usr/include/c++/15/bits/char_traits.h: + +/usr/include/c++/15/cctype: + +/usr/include/c++/15/bits/stl_algobase.h: + +/usr/include/c++/15/clocale: + +/usr/include/SDL3/SDL_sensor.h: + +/usr/include/x86_64-linux-gnu/bits/stdint-intn.h: + +/home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/dataformat.h: + +/usr/include/c++/15/bits/stl_pair.h: + +/usr/include/c++/15/cstdint: + +/usr/include/x86_64-linux-gnu/sys/cdefs.h: + +/usr/include/stdc-predef.h: + +/usr/include/c++/15/tr1/ell_integral.tcc: + +/usr/include/c++/15/codecvt: + +/usr/include/c++/15/system_error: + +/usr/include/linux/sched/types.h: + +/usr/include/x86_64-linux-gnu/bits/floatn-common.h: + +/usr/include/x86_64-linux-gnu/bits/wordsize.h: + +/usr/include/c++/15/cstdio: + +/usr/include/SDL3/SDL_vulkan.h: + +/usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h: + +/usr/include/c++/15/bits/locale_facets.h: + +/usr/include/c++/15/bits/requires_hosted.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveintrin.h: + +/usr/include/c++/15/cstdlib: + +/usr/include/c++/15/bits/functional_hash.h: + +/usr/include/c++/15/ext/type_traits.h: + +/usr/include/c++/15/cwchar: + +/usr/include/c++/15/numbers: + +/usr/include/c++/15/backward/binders.h: + +/usr/include/c++/15/exception: + +/usr/include/c++/15/bits/enable_special_members.h: + +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o: + +/usr/lib/x86_64-linux-gnu/libXext.so.6: + +/usr/include/c++/15/initializer_list: + +/home/itten/mxl-multiviewer/VulkanUtils.hpp: + +/usr/include/c++/15/ext/concurrence.h: + +/usr/include/c++/15/ext/atomicity.h: + +/usr/include/asm-generic/types.h: + +/usr/include/SDL3/SDL_locale.h: + +/usr/include/x86_64-linux-gnu/bits/sigevent-consts.h: + +/usr/include/linux/errno.h: + +/usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h: + +/usr/include/c++/15/bits/invoke.h: + +/usr/include/c++/15/bits/basic_ios.tcc: + +/usr/include/c++/15/pstl/pstl_config.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/xsavesintrin.h: + +/usr/include/c++/15/atomic: + +/usr/include/c++/15/bits/stl_map.h: + +/usr/include/c++/15/ratio: + +CMakeFiles/mxl_multiviewer.dir/FeedCreate.cpp.o: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/serializeintrin.h: + +/usr/include/c++/15/string: + +/usr/include/c++/15/bits/stl_tempbuf.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512dqintrin.h: + +/usr/include/c++/15/memory: + +/usr/include/x86_64-linux-gnu/bits/types/sigval_t.h: + +/usr/include/c++/15/vector: + +/usr/include/x86_64-linux-gnu/bits/types/locale_t.h: + +/usr/include/features-time64.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h: + +/usr/include/linux/posix_types.h: + +/home/itten/dmf-mxl/mxl-1.0.1/lib/include/mxl/mxl.h: + +/usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h: + +/usr/include/c++/15/ext/alloc_traits.h: + +/usr/lib/x86_64-linux-gnu/libc.so.6: + +/usr/include/linux/types.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxbf16intrin.h: + +/usr/include/x86_64-linux-gnu/bits/setjmp.h: + +/usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h: + +/usr/include/c++/15/bits/allocated_ptr.h: + +/usr/include/locale.h: + +/usr/include/c++/15/bits/semaphore_base.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/basic_file.h: + +/usr/include/linux/limits.h: + +/usr/lib/x86_64-linux-gnu/libopus.so.0: + +/usr/include/syscall.h: + +/usr/include/unistd.h: + +/usr/include/c++/15/limits: + +/usr/include/x86_64-linux-gnu/asm/unistd.h: + +/usr/include/c++/15/tr1/bessel_function.tcc: + +/usr/include/x86_64-linux-gnu/bits/confname.h: + +/usr/include/x86_64-linux-gnu/bits/environments.h: + +/usr/include/x86_64-linux-gnu/bits/getopt_core.h: + +/usr/include/SDL3/SDL_keyboard.h: + +/usr/include/c++/15/bits/codecvt.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2vlintrin.h: + +/usr/include/x86_64-linux-gnu/bits/locale.h: + +/usr/include/x86_64-linux-gnu/bits/posix1_lim.h: + +/usr/include/x86_64-linux-gnu/bits/posix2_lim.h: + +/usr/include/SDL3/SDL_gamepad.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/pmmintrin.h: + +/usr/include/SDL3/SDL_hidapi.h: + +/usr/include/x86_64-linux-gnu/bits/posix_opt.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/waitpkgintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/limits.h: + +/usr/include/c++/15/bits/monostate.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/syslimits.h: + +/home/itten/mxl-multiviewer/FeedTexture.cpp: + +/usr/include/c++/15/cwctype: + +/usr/include/SDL3/SDL_hints.h: + +/home/itten/mxl-multiviewer/FeedTexture.hpp: + +/usr/include/vk_video/vulkan_video_codec_av1std.h: + +/usr/include/c++/15/csignal: + +/usr/include/asm-generic/int-ll64.h: + +/usr/include/vulkan/vulkan.h: + +/usr/include/c++/15/new: + +/usr/include/vk_video/vulkan_video_codec_h264std.h: + +/usr/include/vk_video/vulkan_video_codec_h264std_decode.h: + +CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o: + +/usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/c++io.h: + +/usr/include/x86_64-linux-gnu/bits/siginfo-consts.h: + +/usr/include/vk_video/vulkan_video_codec_h264std_encode.h: + +/usr/include/c++/15/bits/exception_ptr.h: + +/usr/include/SDL3/SDL_storage.h: + +/usr/include/vk_video/vulkan_video_codec_h265std.h: + +CMakeFiles/mxl_multiviewer.dir/MxlInstanceCache.cpp.o: + +/usr/include/vk_video/vulkan_video_codec_h265std_decode.h: + +/usr/include/vk_video/vulkan_video_codecs_common.h: + +/usr/include/vulkan/vk_platform.h: + +/usr/include/vulkan/vulkan_core.h: + +/home/itten/mxl-multiviewer/MxlFeed.cpp: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/xsaveoptintrin.h: + +/usr/include/SDL3/SDL_pen.h: + +/usr/include/c++/15/bits/postypes.h: + +/home/itten/mxl-multiviewer/PixelFormat.hpp: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/sgxintrin.h: + +/usr/include/c++/15/fstream: + +/home/itten/mxl-multiviewer/VulkanContext.cpp: + +/usr/include/assert.h: + +/home/itten/mxl-multiviewer/MxlInstanceCache.cpp: + +/usr/include/SDL3/SDL_loadso.h: + +/home/itten/mxl-multiviewer/MxlInstanceCache.hpp: + +/usr/include/x86_64-linux-gnu/bits/struct_rwlock.h: + +/usr/include/x86_64-linux-gnu/bits/semaphore.h: + +/usr/include/c++/15/bits/algorithmfwd.h: + +/usr/include/c++/15/bits/stl_algo.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avxifmaintrin.h: + +/usr/include/SDL3/SDL_touch.h: + +/usr/include/x86_64-linux-gnu/bits/unistd_ext.h: + +/usr/include/c++/15/bits/uniform_int_dist.h: + +/home/itten/mxl-multiviewer/MxlSdkFeed.cpp: + +/usr/include/x86_64-linux-gnu/bits/sigcontext.h: + +/usr/include/x86_64-linux-gnu/bits/siginfo-consts-arch.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/smmintrin.h: + +/usr/include/c++/15/bits/uses_allocator_args.h: + +/usr/include/c++/15/bits/chrono.h: + +/usr/include/c++/15/iosfwd: + +/usr/include/c++/15/bits/chrono_io.h: + +/usr/include/c++/15/bits/formatfwd.h: + +/usr/include/SDL3/SDL_clipboard.h: + +/usr/include/c++/15/bits/locale_facets_nonio.tcc: + +/usr/include/SDL3/SDL_oldnames.h: + +/usr/include/c++/15/bits/parse_numbers.h: + +/usr/include/c++/15/bits/locale_facets_nonio.h: + +/usr/include/SDL3/SDL_dialog.h: + +/usr/include/c++/15/bits/quoted_string.h: + +/usr/include/x86_64-linux-gnu/bits/sigstack.h: + +/usr/include/c++/15/bits/sstream.tcc: + +/usr/include/c++/15/bits/unicode.h: + +/usr/include/x86_64-linux-gnu/sys/ucontext.h: + +/usr/include/c++/15/ctime: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectvlintrin.h: + +/usr/include/c++/15/stdlib.h: + +/usr/include/c++/15/streambuf: + +/usr/include/c++/15/format: + +/usr/include/c++/15/locale: + +/usr/include/limits.h: + +/usr/include/c++/15/tr1/gamma.tcc: + +/usr/include/c++/15/stop_token: + +/usr/include/x86_64-linux-gnu/bits/sigstksz.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqintrin.h: + +/usr/include/x86_64-linux-gnu/bits/thread-shared-types.h: + +/usr/include/c++/15/thread: + +/usr/include/libintl.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx2intrin.h: + +/usr/include/semaphore.h: + +/usr/include/c++/15/cmath: + +/usr/include/x86_64-linux-gnu/c++/15/bits/messages_members.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512satcvtintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnniintrin.h: + +/usr/include/c++/15/bits/memory_resource.h: + +/usr/include/c++/15/bits/stl_function.h: + +/usr/include/x86_64-linux-gnu/sys/time.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vnnivlintrin.h: + +/home/itten/mxl-multiviewer/RenderPipeline.cpp: + +/home/itten/mxl-multiviewer/RenderPipeline.hpp: + +/usr/include/SDL3/SDL_audio.h: + +/home/itten/mxl-multiviewer/SmpteBarsFeed.cpp: + +/usr/include/SDL3/SDL_platform.h: + +CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o: + +/home/itten/mxl-multiviewer/Swapchain.hpp: + +/usr/include/x86_64-linux-gnu/bits/xopen_lim.h: + +/usr/include/c++/15/bits/atomic_wait.h: + +/home/itten/mxl-multiviewer/VulkanContext.hpp: + +/usr/include/SDL3/SDL.h: + +/usr/include/c++/15/tr1/beta_function.tcc: + +/usr/include/c++/15/tr1/exp_integral.tcc: + +/usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h: + +/usr/include/c++/15/tr1/modified_bessel_func.tcc: + +/usr/include/x86_64-linux-gnu/bits/signum-generic.h: + +/home/itten/mxl-multiviewer/VulkanUtils.cpp: + +/usr/include/c++/15/tr1/riemann_zeta.tcc: + +/usr/include/SDL3/SDL_guid.h: + +/usr/lib/x86_64-linux-gnu/libwayland-client.so.0: + +/usr/include/x86_64-linux-gnu/bits/flt-eval-method.h: + +/usr/include/c++/15/tuple: + +/usr/include/x86_64-linux-gnu/bits/iscanonical.h: + +/usr/lib/x86_64-linux-gnu/libvorbis.so.0: + +/usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h: + +/usr/include/c++/15/bits/std_abs.h: + +/usr/include/c++/15/ios: + +/usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h: + +/usr/include/x86_64-linux-gnu/bits/endian.h: + +/usr/include/x86_64-linux-gnu/bits/mathcalls.h: + +/usr/include/SDL3/SDL_assert.h: + +/home/itten/mxl-multiviewer/TileLayout.hpp: + +/usr/include/SDL3/SDL_asyncio.h: + +/usr/include/SDL3/SDL_atomic.h: + +/usr/lib/x86_64-linux-gnu/libdbus-1.so.3: + +/usr/include/x86_64-linux-gnu/bits/sigaction.h: + +/home/itten/mxl-multiviewer/FeedCreate.hpp: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512ifmaintrin.h: + +/usr/include/time.h: + +/usr/include/c++/15/tr1/hypergeometric.tcc: + +/usr/include/SDL3/SDL_blendmode.h: + +/usr/include/SDL3/SDL_camera.h: + +/usr/include/SDL3/SDL_close_code.h: + +/usr/include/SDL3/SDL_cpuinfo.h: + +/usr/include/SDL3/SDL_gpu.h: + +/usr/include/c++/15/bits/ranges_algobase.h: + +/usr/include/SDL3/SDL_haptic.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h: + +/usr/include/SDL3/SDL_init.h: + +/usr/include/x86_64-linux-gnu/bits/errno.h: + +/usr/include/c++/15/debug/debug.h: + +/usr/include/SDL3/SDL_joystick.h: + +/usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h: + +/usr/include/SDL3/SDL_metal.h: + +/usr/include/c++/15/bits/basic_ios.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxtransposeintrin.h: + +/usr/include/SDL3/SDL_misc.h: + +/usr/lib/x86_64-linux-gnu/libXdmcp.so.6: + +/home/itten/mxl-multiviewer/main.cpp: + +/usr/include/SDL3/SDL_mouse.h: + +/usr/include/SDL3/SDL_pixels.h: + +/usr/include/SDL3/SDL_platform_defines.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/xtestintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/prfchiintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h: + +/usr/include/c++/15/bits/stl_iterator.h: + +/usr/include/SDL3/SDL_process.h: + +/usr/lib/x86_64-linux-gnu/libm.so.6: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/rdseedintrin.h: + +/usr/include/c++/15/bits/hash_bytes.h: + +/usr/include/SDL3/SDL_properties.h: + +/usr/include/SDL3/SDL_error.h: + +/usr/include/SDL3/SDL_render.h: + +/usr/include/x86_64-linux-gnu/bits/fp-logb.h: + +/usr/include/c++/15/array: + +/usr/include/x86_64-linux-gnu/bits/types/idtype_t.h: + +/usr/include/SDL3/SDL_scancode.h: + +/usr/include/SDL3/SDL_system.h: + +/usr/include/c++/15/cerrno: + +/usr/include/c++/15/span: + +/usr/include/SDL3/SDL_time.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxtf32intrin.h: + +/usr/include/SDL3/SDL_timer.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/clflushoptintrin.h: + +/usr/include/x86_64-linux-gnu/bits/timesize.h: + +/usr/include/SDL3/SDL_tray.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16vlintrin.h: + +/usr/include/SDL3/SDL_version.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/fxsrintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avxvnniint16intrin.h: + +/usr/lib/x86_64-linux-gnu/libmvec.so.1: + +/usr/include/x86_64-linux-gnu/sys/types.h: + +/usr/include/SDL3/SDL_video.h: + +/home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp: + +/home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.h: + +/usr/include/x86_64-linux-gnu/bits/typesizes.h: + +/home/itten/mxl-multiviewer/imgui/backends/imgui_impl_vulkan.h: + +/usr/include/c++/15/bits/locale_conv.h: + +/home/itten/mxl-multiviewer/imgui/imgui.cpp: + +/usr/lib/x86_64-linux-gnu/libgbm.so.1: + +/usr/include/SDL3/SDL_events.h: + +/usr/include/c++/15/chrono: + +/usr/include/c++/15/math.h: + +/usr/include/c++/15/bits/atomic_timed_wait.h: + +/usr/include/x86_64-linux-gnu/bits/siginfo-arch.h: + +/home/itten/mxl-multiviewer/AppConfig.hpp: + +/usr/include/x86_64-linux-gnu/bits/types.h: + +/usr/include/x86_64-linux-gnu/bits/signal_ext.h: + +/usr/include/x86_64-linux-gnu/bits/sigthread.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fp16intrin.h: + +/usr/include/c++/15/bits/align.h: + +/usr/include/x86_64-linux-gnu/sys/syscall.h: + +/usr/include/x86_64-linux-gnu/bits/ss_flags.h: + +/usr/include/x86_64-linux-gnu/bits/types/sig_atomic_t.h: + +/usr/include/c++/15/tr1/legendre_function.tcc: + +/usr/include/x86_64-linux-gnu/bits/types/__sigval_t.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2mediaintrin.h: + +/usr/include/c++/15/bits/stl_multimap.h: + +/usr/include/c++/15/semaphore: + +/usr/include/SDL3/SDL_stdinc.h: + +/usr/include/x86_64-linux-gnu/bits/types/sigevent_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/siginfo_t.h: + +/usr/include/x86_64-linux-gnu/bits/types/stack_t.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxavx512intrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxcomplexintrin.h: + +/usr/include/c++/15/bits/std_thread.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxfp8intrin.h: + +/usr/include/c++/15/stdexcept: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxmovrsintrin.h: + +/usr/lib/x86_64-linux-gnu/libfribidi.so.0: + +/usr/include/c++/15/bits/stl_tree.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxint8intrin.h: + +/usr/include/string.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/amxtileintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512bf16intrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512convertintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512mediaintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2-512minmaxintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/rtmintrin.h: + +/usr/include/SDL3/SDL_filesystem.h: + +/usr/include/vk_video/vulkan_video_codec_av1std_encode.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2bf16intrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/emmintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2convertintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/tbmintrin.h: + +/usr/include/signal.h: + +/usr/include/x86_64-linux-gnu/bits/types/wint_t.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2copyintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx10_2minmaxintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16intrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bf16vlintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bitalgvlintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512bwintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512fintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmi2intrin.h: + +/usr/include/x86_64-linux-gnu/c++/15/bits/time_members.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vbmivlintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vlbwintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/tmmintrin.h: + +/usr/include/c++/15/bits/unicode-data.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vldqintrin.h: + +/usr/include/c++/15/backward/auto_ptr.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vp2intersectintrin.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avx512vpopcntdqvlintrin.h: + +/usr/include/x86_64-linux-gnu/bits/local_lim.h: + +/usr/lib/gcc/x86_64-linux-gnu/15/include/avxneconvertintrin.h: diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts b/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts new file mode 100644 index 0000000..e83f358 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/compiler_depend.ts @@ -0,0 +1,2 @@ +# CMAKE generated file: DO NOT EDIT! +# Timestamp file for compiler generated dependencies management for mxl_multiviewer. diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/depend.make b/build-sdk/CMakeFiles/mxl_multiviewer.dir/depend.make new file mode 100644 index 0000000..12642b1 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for mxl_multiviewer. +# This may be replaced when dependencies are built. diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/flags.make b/build-sdk/CMakeFiles/mxl_multiviewer.dir/flags.make new file mode 100644 index 0000000..47bc061 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/flags.make @@ -0,0 +1,22 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 4.2 + +# compile CXX with /usr/bin/c++ +CXX_DEFINES = -DMXL_MULTIVIEWER_ENABLE_MXL_SDK=1 + +CXX_INCLUDES = -I/usr/include/fribidi -I/usr/include/libdrm -I/usr/include/libdecor-0 -I/home/itten/mxl-multiviewer/imgui -I/home/itten/mxl-multiviewer/imgui/backends -I/home/itten/dmf-mxl/mxl-1.0.1/lib/include -I/home/itten/dmf-mxl/mxl-1.0.1/build/Linux-Clang-Release/lib/include + +CXX_FLAGS = -g -std=gnu++20 -Wall -Wextra -Wpedantic + +# Custom options: CMakeFiles/mxl_multiviewer.dir/imgui/imgui.cpp.o_OPTIONS = -w + +# Custom options: CMakeFiles/mxl_multiviewer.dir/imgui/imgui_draw.cpp.o_OPTIONS = -w + +# Custom options: CMakeFiles/mxl_multiviewer.dir/imgui/imgui_tables.cpp.o_OPTIONS = -w + +# Custom options: CMakeFiles/mxl_multiviewer.dir/imgui/imgui_widgets.cpp.o_OPTIONS = -w + +# Custom options: CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o_OPTIONS = -w + +# Custom options: CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o_OPTIONS = -w + diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..ce0811c3ce2a41b93c795c40ebabfef3f7318878 GIT binary patch literal 270280 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

    bJ>i{roqeq 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 z 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 literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o.d new file mode 100644 index 0000000..b07b59d --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o.d @@ -0,0 +1,74 @@ +CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_sdl3.cpp.o: \ + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.cpp \ + /usr/include/stdc-predef.h /home/itten/mxl-multiviewer/imgui/imgui.h \ + /home/itten/mxl-multiviewer/imgui/imconfig.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/float.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h /usr/include/string.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/strings.h /usr/include/assert.h \ + /home/itten/mxl-multiviewer/imgui/backends/imgui_impl_sdl3.h \ + /usr/include/SDL3/SDL.h /usr/include/SDL3/SDL_stdinc.h \ + /usr/include/SDL3/SDL_platform_defines.h /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/SDL3/SDL_begin_code.h /usr/include/SDL3/SDL_close_code.h \ + /usr/include/SDL3/SDL_assert.h /usr/include/SDL3/SDL_asyncio.h \ + /usr/include/SDL3/SDL_atomic.h /usr/include/SDL3/SDL_audio.h \ + /usr/include/SDL3/SDL_endian.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/SDL3/SDL_error.h /usr/include/SDL3/SDL_mutex.h \ + /usr/include/SDL3/SDL_thread.h /usr/include/SDL3/SDL_properties.h \ + /usr/include/SDL3/SDL_iostream.h /usr/include/SDL3/SDL_bits.h \ + /usr/include/SDL3/SDL_blendmode.h /usr/include/SDL3/SDL_camera.h \ + /usr/include/SDL3/SDL_pixels.h /usr/include/SDL3/SDL_surface.h \ + /usr/include/SDL3/SDL_rect.h /usr/include/SDL3/SDL_clipboard.h \ + /usr/include/SDL3/SDL_cpuinfo.h /usr/include/SDL3/SDL_dialog.h \ + /usr/include/SDL3/SDL_video.h /usr/include/SDL3/SDL_dlopennote.h \ + /usr/include/SDL3/SDL_events.h /usr/include/SDL3/SDL_gamepad.h \ + /usr/include/SDL3/SDL_guid.h /usr/include/SDL3/SDL_joystick.h \ + /usr/include/SDL3/SDL_power.h /usr/include/SDL3/SDL_sensor.h \ + /usr/include/SDL3/SDL_keyboard.h /usr/include/SDL3/SDL_keycode.h \ + /usr/include/SDL3/SDL_scancode.h /usr/include/SDL3/SDL_mouse.h \ + /usr/include/SDL3/SDL_pen.h /usr/include/SDL3/SDL_touch.h \ + /usr/include/SDL3/SDL_filesystem.h /usr/include/SDL3/SDL_gpu.h \ + /usr/include/SDL3/SDL_haptic.h /usr/include/SDL3/SDL_hidapi.h \ + /usr/include/SDL3/SDL_hints.h /usr/include/SDL3/SDL_init.h \ + /usr/include/SDL3/SDL_loadso.h /usr/include/SDL3/SDL_locale.h \ + /usr/include/SDL3/SDL_log.h /usr/include/SDL3/SDL_messagebox.h \ + /usr/include/SDL3/SDL_metal.h /usr/include/SDL3/SDL_misc.h \ + /usr/include/SDL3/SDL_platform.h /usr/include/SDL3/SDL_process.h \ + /usr/include/SDL3/SDL_render.h /usr/include/SDL3/SDL_storage.h \ + /usr/include/SDL3/SDL_system.h /usr/include/SDL3/SDL_time.h \ + /usr/include/SDL3/SDL_timer.h /usr/include/SDL3/SDL_tray.h \ + /usr/include/SDL3/SDL_version.h /usr/include/SDL3/SDL_oldnames.h \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/imgui/backends/imgui_impl_vulkan.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..2de4ef1058e1b40564bea2658bf5e8b42ad831e6 GIT binary patch literal 767800 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≤W3d|pHd_PWE1ec? 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 P{7tnw{|@*^7nA>Qt%vQy literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o.d new file mode 100644 index 0000000..e996e1d --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o.d @@ -0,0 +1,204 @@ +CMakeFiles/mxl_multiviewer.dir/Swapchain.cpp.o: \ + /home/itten/mxl-multiviewer/Swapchain.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/Swapchain.hpp \ + /home/itten/mxl-multiviewer/VulkanContext.hpp \ + /usr/include/vulkan/vulkan.h /usr/include/vulkan/vk_platform.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/vulkan/vulkan_core.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codecs_common.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h264std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std.h \ + /usr/include/vk_video/vulkan_video_codec_h264std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_h265std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_av1std.h \ + /usr/include/vk_video/vulkan_video_codec_av1std_encode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std_decode.h \ + /usr/include/vk_video/vulkan_video_codec_vp9std.h \ + /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h /usr/include/c++/15/iostream \ + /usr/include/c++/15/bits/requires_hosted.h /usr/include/c++/15/ostream \ + /usr/include/c++/15/bits/ostream.h /usr/include/c++/15/ios \ + /usr/include/c++/15/iosfwd /usr/include/c++/15/bits/stringfwd.h \ + /usr/include/c++/15/bits/memoryfwd.h /usr/include/c++/15/bits/postypes.h \ + /usr/include/c++/15/cwchar /usr/include/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdarg.h \ + /usr/include/x86_64-linux-gnu/bits/types/wint_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__mbstate_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/c++/15/exception /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/version.h \ + /usr/include/c++/15/bits/exception_ptr.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cxxabi_init_exception.h \ + /usr/include/c++/15/typeinfo /usr/include/c++/15/bits/hash_bytes.h \ + /usr/include/c++/15/new /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/type_traits \ + /usr/include/c++/15/bits/nested_exception.h \ + /usr/include/c++/15/bits/char_traits.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/localefwd.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++locale.h \ + /usr/include/c++/15/clocale /usr/include/locale.h \ + /usr/include/x86_64-linux-gnu/bits/locale.h /usr/include/c++/15/cctype \ + /usr/include/ctype.h /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/c++/15/bits/ios_base.h /usr/include/c++/15/ext/atomicity.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/gthr-default.h \ + /usr/include/pthread.h /usr/include/sched.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/sched.h \ + /usr/include/linux/sched/types.h /usr/include/linux/types.h \ + /usr/include/x86_64-linux-gnu/asm/types.h \ + /usr/include/asm-generic/types.h /usr/include/asm-generic/int-ll64.h \ + /usr/include/x86_64-linux-gnu/asm/bitsperlong.h \ + /usr/include/asm-generic/bitsperlong.h /usr/include/linux/posix_types.h \ + /usr/include/linux/stddef.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types.h \ + /usr/include/x86_64-linux-gnu/asm/posix_types_64.h \ + /usr/include/asm-generic/posix_types.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_sched_param.h \ + /usr/include/x86_64-linux-gnu/bits/cpu-set.h /usr/include/time.h \ + /usr/include/x86_64-linux-gnu/bits/time.h \ + /usr/include/x86_64-linux-gnu/bits/timex.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_tm.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_itimerspec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h \ + /usr/include/x86_64-linux-gnu/bits/setjmp.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct___jmp_buf_tag.h \ + /usr/include/x86_64-linux-gnu/bits/pthread_stack_min-dynamic.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/atomic_word.h \ + /usr/include/x86_64-linux-gnu/sys/single_threaded.h \ + /usr/include/c++/15/bits/locale_classes.h /usr/include/c++/15/string \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/ostream_insert.h \ + /usr/include/c++/15/bits/cxxabi_forced.h \ + /usr/include/c++/15/bits/stl_iterator.h \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/utility.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/refwrap.h /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/basic_string.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h /usr/include/c++/15/string_view \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/string_view.tcc \ + /usr/include/c++/15/ext/string_conversions.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/sys/types.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/alloca.h /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h /usr/include/c++/15/cstdio \ + /usr/include/stdio.h /usr/include/x86_64-linux-gnu/bits/types/__fpos_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__fpos64_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_FILE.h \ + /usr/include/x86_64-linux-gnu/bits/types/cookie_io_functions_t.h \ + /usr/include/x86_64-linux-gnu/bits/stdio_lim.h \ + /usr/include/c++/15/cerrno /usr/include/errno.h \ + /usr/include/x86_64-linux-gnu/bits/errno.h /usr/include/linux/errno.h \ + /usr/include/x86_64-linux-gnu/asm/errno.h \ + /usr/include/asm-generic/errno.h /usr/include/asm-generic/errno-base.h \ + /usr/include/x86_64-linux-gnu/bits/types/error_t.h \ + /usr/include/c++/15/bits/charconv.h \ + /usr/include/c++/15/bits/basic_string.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h \ + /usr/include/c++/15/bits/locale_classes.tcc \ + /usr/include/c++/15/system_error \ + /usr/include/x86_64-linux-gnu/c++/15/bits/error_constants.h \ + /usr/include/c++/15/stdexcept /usr/include/c++/15/streambuf \ + /usr/include/c++/15/bits/streambuf.tcc \ + /usr/include/c++/15/bits/basic_ios.h \ + /usr/include/c++/15/bits/locale_facets.h /usr/include/c++/15/cwctype \ + /usr/include/wctype.h /usr/include/x86_64-linux-gnu/bits/wctype-wchar.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_base.h \ + /usr/include/c++/15/bits/streambuf_iterator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/ctype_inline.h \ + /usr/include/c++/15/bits/locale_facets.tcc \ + /usr/include/c++/15/bits/basic_ios.tcc \ + /usr/include/c++/15/bits/ostream.tcc /usr/include/c++/15/istream \ + /usr/include/c++/15/bits/istream.tcc /usr/include/c++/15/optional \ + /usr/include/c++/15/bits/enable_special_members.h \ + /usr/include/c++/15/vector /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/vector.tcc /usr/include/c++/15/algorithm \ + /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/stl_tempbuf.h \ + /usr/include/c++/15/bits/ranges_algo.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/pstl/glue_algorithm_defs.h \ + /usr/include/c++/15/pstl/execution_defs.h diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..2f6a0ef577e409aea5df489f26e405e20b308045 GIT binary patch literal 172568 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 literal 0 HcmV?d00001 diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o.d b/build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o.d new file mode 100644 index 0000000..9c3e8e4 --- /dev/null +++ b/build-sdk/CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o.d @@ -0,0 +1,131 @@ +CMakeFiles/mxl_multiviewer.dir/TileLayout.cpp.o: \ + /home/itten/mxl-multiviewer/TileLayout.cpp /usr/include/stdc-predef.h \ + /home/itten/mxl-multiviewer/TileLayout.hpp /usr/include/c++/15/cstdint \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++config.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/os_defines.h \ + /usr/include/features.h /usr/include/features-time64.h \ + /usr/include/x86_64-linux-gnu/bits/wordsize.h \ + /usr/include/x86_64-linux-gnu/bits/timesize.h \ + /usr/include/x86_64-linux-gnu/sys/cdefs.h \ + /usr/include/x86_64-linux-gnu/bits/long-double.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs.h \ + /usr/include/x86_64-linux-gnu/gnu/stubs-64.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/cpu_defines.h \ + /usr/include/c++/15/pstl/pstl_config.h \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stdint.h /usr/include/stdint.h \ + /usr/include/x86_64-linux-gnu/bits/libc-header-start.h \ + /usr/include/x86_64-linux-gnu/bits/types.h \ + /usr/include/x86_64-linux-gnu/bits/typesizes.h \ + /usr/include/x86_64-linux-gnu/bits/time64.h \ + /usr/include/x86_64-linux-gnu/bits/wchar.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-intn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-uintn.h \ + /usr/include/x86_64-linux-gnu/bits/stdint-least.h \ + /usr/include/c++/15/vector /usr/include/c++/15/bits/requires_hosted.h \ + /usr/include/c++/15/bits/stl_algobase.h \ + /usr/include/c++/15/bits/functexcept.h \ + /usr/include/c++/15/bits/exception_defines.h \ + /usr/include/c++/15/bits/cpp_type_traits.h \ + /usr/include/c++/15/bits/version.h /usr/include/c++/15/type_traits \ + /usr/include/c++/15/ext/type_traits.h \ + /usr/include/c++/15/ext/numeric_traits.h \ + /usr/include/c++/15/bits/stl_pair.h /usr/include/c++/15/bits/move.h \ + /usr/include/c++/15/bits/utility.h /usr/include/c++/15/compare \ + /usr/include/c++/15/concepts \ + /usr/include/c++/15/bits/stl_iterator_base_types.h \ + /usr/include/c++/15/bits/iterator_concepts.h \ + /usr/include/c++/15/bits/ptr_traits.h \ + /usr/include/c++/15/bits/ranges_cmp.h \ + /usr/include/c++/15/bits/stl_iterator_base_funcs.h \ + /usr/include/c++/15/bits/concept_check.h \ + /usr/include/c++/15/debug/assertions.h \ + /usr/include/c++/15/bits/stl_iterator.h /usr/include/c++/15/new \ + /usr/include/c++/15/bits/exception.h \ + /usr/include/c++/15/bits/stl_construct.h \ + /usr/include/c++/15/debug/debug.h \ + /usr/include/c++/15/bits/predefined_ops.h /usr/include/c++/15/bit \ + /usr/include/c++/15/bits/allocator.h \ + /usr/include/x86_64-linux-gnu/c++/15/bits/c++allocator.h \ + /usr/include/c++/15/bits/new_allocator.h \ + /usr/include/c++/15/bits/memoryfwd.h \ + /usr/include/c++/15/bits/stl_uninitialized.h \ + /usr/include/c++/15/ext/alloc_traits.h \ + /usr/include/c++/15/bits/alloc_traits.h \ + /usr/include/c++/15/bits/stl_vector.h \ + /usr/include/c++/15/initializer_list \ + /usr/include/c++/15/bits/ranges_base.h \ + /usr/include/c++/15/bits/max_size_type.h /usr/include/c++/15/numbers \ + /usr/include/c++/15/bits/stl_bvector.h \ + /usr/include/c++/15/bits/functional_hash.h \ + /usr/include/c++/15/bits/hash_bytes.h /usr/include/c++/15/bits/refwrap.h \ + /usr/include/c++/15/bits/invoke.h \ + /usr/include/c++/15/bits/stl_function.h \ + /usr/include/c++/15/backward/binders.h \ + /usr/include/c++/15/bits/range_access.h \ + /usr/include/c++/15/bits/vector.tcc \ + /usr/include/c++/15/bits/memory_resource.h /usr/include/c++/15/cstddef \ + /usr/lib/gcc/x86_64-linux-gnu/15/include/stddef.h \ + /usr/include/c++/15/bits/uses_allocator.h \ + /usr/include/c++/15/bits/uses_allocator_args.h /usr/include/c++/15/tuple \ + /usr/include/c++/15/bits/ranges_util.h /usr/include/c++/15/algorithm \ + /usr/include/c++/15/bits/stl_algo.h \ + /usr/include/c++/15/bits/algorithmfwd.h \ + /usr/include/c++/15/bits/stl_heap.h \ + /usr/include/c++/15/bits/uniform_int_dist.h \ + /usr/include/c++/15/bits/stl_tempbuf.h /usr/include/c++/15/cstdlib \ + /usr/include/stdlib.h /usr/include/x86_64-linux-gnu/bits/waitflags.h \ + /usr/include/x86_64-linux-gnu/bits/waitstatus.h \ + /usr/include/x86_64-linux-gnu/bits/floatn.h \ + /usr/include/x86_64-linux-gnu/bits/floatn-common.h \ + /usr/include/x86_64-linux-gnu/bits/types/locale_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__locale_t.h \ + /usr/include/x86_64-linux-gnu/sys/types.h \ + /usr/include/x86_64-linux-gnu/bits/types/clock_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/clockid_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/time_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/timer_t.h /usr/include/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endian.h \ + /usr/include/x86_64-linux-gnu/bits/endianness.h \ + /usr/include/x86_64-linux-gnu/bits/byteswap.h \ + /usr/include/x86_64-linux-gnu/bits/uintn-identity.h \ + /usr/include/x86_64-linux-gnu/sys/select.h \ + /usr/include/x86_64-linux-gnu/bits/select.h \ + /usr/include/x86_64-linux-gnu/bits/types/sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/__sigset_t.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timeval.h \ + /usr/include/x86_64-linux-gnu/bits/types/struct_timespec.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes.h \ + /usr/include/x86_64-linux-gnu/bits/thread-shared-types.h \ + /usr/include/x86_64-linux-gnu/bits/pthreadtypes-arch.h \ + /usr/include/x86_64-linux-gnu/bits/atomic_wide_counter.h \ + /usr/include/x86_64-linux-gnu/bits/struct_mutex.h \ + /usr/include/x86_64-linux-gnu/bits/struct_rwlock.h /usr/include/alloca.h \ + /usr/include/x86_64-linux-gnu/bits/stdlib-float.h \ + /usr/include/c++/15/bits/std_abs.h \ + /usr/include/c++/15/bits/ranges_algo.h \ + /usr/include/c++/15/bits/ranges_algobase.h \ + /usr/include/c++/15/pstl/glue_algorithm_defs.h \ + /usr/include/c++/15/pstl/execution_defs.h /usr/include/c++/15/cmath \ + /usr/include/math.h /usr/include/x86_64-linux-gnu/bits/math-vector.h \ + /usr/include/x86_64-linux-gnu/bits/libm-simd-decl-stubs.h \ + /usr/include/x86_64-linux-gnu/bits/flt-eval-method.h \ + /usr/include/x86_64-linux-gnu/bits/fp-logb.h \ + /usr/include/x86_64-linux-gnu/bits/fp-fast.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-macros.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-helper-functions.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls.h \ + /usr/include/x86_64-linux-gnu/bits/mathcalls-narrow.h \ + /usr/include/x86_64-linux-gnu/bits/iscanonical.h \ + /usr/include/c++/15/bits/specfun.h /usr/include/c++/15/limits \ + /usr/include/c++/15/tr1/gamma.tcc \ + /usr/include/c++/15/tr1/special_function_util.h \ + /usr/include/c++/15/tr1/bessel_function.tcc \ + /usr/include/c++/15/tr1/beta_function.tcc \ + /usr/include/c++/15/tr1/ell_integral.tcc \ + /usr/include/c++/15/tr1/exp_integral.tcc \ + /usr/include/c++/15/tr1/hypergeometric.tcc \ + /usr/include/c++/15/tr1/legendre_function.tcc \ + /usr/include/c++/15/tr1/modified_bessel_func.tcc \ + /usr/include/c++/15/tr1/poly_hermite.tcc \ + /usr/include/c++/15/tr1/poly_laguerre.tcc \ + /usr/include/c++/15/tr1/riemann_zeta.tcc diff --git a/build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o b/build-sdk/CMakeFiles/mxl_multiviewer.dir/V210ComputeDecoder.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..2b08e9f9c6c7a7ad194288e16d3dcf66de2b3810 GIT binary patch literal 758840 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℘A_EJyde}K{qXc0`Hy!$klL85w> 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