crosstyan/cvmmap-streamer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a0b9c95d5bf9f35894ebaff4279b3cca928e9000
cvmmap-streamer/CMakeLists.txt
T
crosstyan a0b9c95d5b feat(zed): improve MCAP export batching and defaults 
Default ZED MCAP export to neural_plus depth across the CLI and Python wrappers, and add tail-frame handling plus better corrupted-frame diagnostics in zed_svo_to_mcap.

Add mixed hardware/software worker pools to the batch MCAP wrapper, replace tqdm with progress-table on TTYs, keep text event logging and heartbeats for non-TTY runs, and document the NVENC session-limit rationale for mixed mode in the README.

Also refresh Python dependencies for the batch tooling and move the OpenSSL lookup in CMake so the local workspace build remains compatible with the vendored cnats setup.
2026-03-24 16:02:15 +08:00

499 lines
18 KiB
CMake
Raw Blame History

cmake_minimum_required(VERSION 3.20)
project(cvmmap-streamer LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
include(GNUInstallDirs)
option(
CVMMAP_BUILD_ZED_SVO_GRID_TO_MP4
"Build the OpenCV-based zed_svo_grid_to_mp4 tool"
ON)
find_package(Threads REQUIRED)
find_package(OpenSSL REQUIRED)
if (NOT TARGET OpenSSL::SSL AND DEFINED OPENSSL_SSL_LIBRARY)
add_library(OpenSSL::SSL UNKNOWN IMPORTED)
set_target_properties(OpenSSL::SSL PROPERTIES
IMPORTED_LOCATION "${OPENSSL_SSL_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_INCLUDE_DIR}")
endif()
if (NOT TARGET OpenSSL::Crypto AND DEFINED OPENSSL_CRYPTO_LIBRARY)
add_library(OpenSSL::Crypto UNKNOWN IMPORTED)
set_target_properties(OpenSSL::Crypto PROPERTIES
IMPORTED_LOCATION "${OPENSSL_CRYPTO_LIBRARY}"
INTERFACE_INCLUDE_DIRECTORIES "${OPENSSL_INCLUDE_DIR}")
endif()
find_package(cppzmq QUIET)
if (DEFINED CVMMAP_STREAMER_USE_SYSTEM_CNATS)
message(FATAL_ERROR
"CVMMAP_STREAMER_USE_SYSTEM_CNATS was removed; use CVMMAP_CNATS_PROVIDER=system")
endif()
set(
CVMMAP_CNATS_PROVIDER
"system"
CACHE STRING
"How to resolve cnats: system or workspace")
set_property(CACHE CVMMAP_CNATS_PROVIDER PROPERTY STRINGS system workspace)
set(_CVMMAP_STREAMER_CNATS_PROVIDER_VALUES system workspace)
list(FIND _CVMMAP_STREAMER_CNATS_PROVIDER_VALUES "${CVMMAP_CNATS_PROVIDER}" _CVMMAP_STREAMER_CNATS_PROVIDER_INDEX)
if (_CVMMAP_STREAMER_CNATS_PROVIDER_INDEX EQUAL -1)
message(FATAL_ERROR
"Invalid CVMMAP_CNATS_PROVIDER='${CVMMAP_CNATS_PROVIDER}' (expected: system|workspace)")
endif()
set(CVMMAP_LOCAL_ROOT "${CMAKE_CURRENT_LIST_DIR}/../cv-mmap" CACHE PATH "Path to a local cv-mmap checkout")
set(CVMMAP_LOCAL_BUILD "${CVMMAP_LOCAL_ROOT}/build/core" CACHE PATH "Path to local cv-mmap build artifacts")
set(CVMMAP_LOCAL_CORE_DIR "${CVMMAP_LOCAL_ROOT}/build/core" CACHE PATH "Path to local cvmmap-core package config")
set(CVMMAP_LOCAL_NATS_STATIC "${CVMMAP_LOCAL_ROOT}/build/lib/libnats_static.a" CACHE PATH "Path to local cnats static library")
if (CVMMAP_CNATS_PROVIDER STREQUAL "system")
find_package(cnats CONFIG REQUIRED)
find_package(cvmmap-core CONFIG QUIET)
else()
if (NOT EXISTS "${CVMMAP_LOCAL_NATS_STATIC}")
message(FATAL_ERROR
"workspace cnats provider requires ${CVMMAP_LOCAL_NATS_STATIC}")
endif()
if (NOT TARGET cnats::nats_static)
add_library(cnats::nats_static STATIC IMPORTED GLOBAL)
set_target_properties(cnats::nats_static PROPERTIES
IMPORTED_LOCATION "${CVMMAP_LOCAL_NATS_STATIC}"
INTERFACE_INCLUDE_DIRECTORIES "${CVMMAP_LOCAL_ROOT}/third_party/nats.c/src"
INTERFACE_LINK_LIBRARIES "OpenSSL::SSL;OpenSSL::Crypto;Threads::Threads")
endif()
endif()
find_package(ZeroMQ QUIET)
find_package(spdlog REQUIRED)
find_package(Protobuf REQUIRED)
find_package(PkgConfig REQUIRED)
find_package(rvl CONFIG QUIET)
set(ZED_DIR "/usr/local/zed" CACHE PATH "Path to the local ZED SDK")
find_package(ZED QUIET)
set(CVMMAP_HAS_ZED_SDK OFF)
if (ZED_FOUND)
find_package(CUDA ${ZED_CUDA_VERSION} REQUIRED)
find_library(CVMMAP_STREAMER_LIBUSB_LIBRARY NAMES usb-1.0 libusb-1.0)
if (CVMMAP_STREAMER_LIBUSB_LIBRARY)
set(_CVMMAP_STREAMER_ZED_LIBRARIES "")
foreach(_zed_lib IN LISTS ZED_LIBRARIES)
if (_zed_lib STREQUAL "/usr/lib/x86_64-linux-gnu/libusb-1.0.so")
list(APPEND _CVMMAP_STREAMER_ZED_LIBRARIES "${CVMMAP_STREAMER_LIBUSB_LIBRARY}")
else()
list(APPEND _CVMMAP_STREAMER_ZED_LIBRARIES "${_zed_lib}")
endif()
endforeach()
set(ZED_LIBRARIES "${_CVMMAP_STREAMER_ZED_LIBRARIES}")
endif()
set(CVMMAP_HAS_ZED_SDK ON)
message(STATUS "ZED SDK found: enabling zed_svo_to_mcap and zed_svo_to_mp4")
else()
message(STATUS "ZED SDK not found: skipping ZED conversion tools")
endif()
if (CVMMAP_BUILD_ZED_SVO_GRID_TO_MP4 AND CVMMAP_HAS_ZED_SDK)
find_package(OpenCV REQUIRED COMPONENTS core imgproc)
elseif (CVMMAP_BUILD_ZED_SVO_GRID_TO_MP4)
message(STATUS "CVMMAP_BUILD_ZED_SVO_GRID_TO_MP4=ON but ZED SDK is unavailable; zed_svo_grid_to_mp4 will not be built")
endif()
add_subdirectory(third_party)
pkg_check_modules(FFMPEG REQUIRED IMPORTED_TARGET libavcodec libavformat libavutil libswscale)
pkg_check_modules(PROTOBUF_PKG QUIET IMPORTED_TARGET protobuf)
pkg_check_modules(ZSTD REQUIRED IMPORTED_TARGET libzstd)
pkg_check_modules(LZ4 REQUIRED IMPORTED_TARGET liblz4)
if (NOT TARGET cvmmap::client)
if (
EXISTS "${CVMMAP_LOCAL_ROOT}/core/include/cvmmap/client.hpp"
AND EXISTS "${CVMMAP_LOCAL_BUILD}/libcvmmap_client.a"
AND EXISTS "${CVMMAP_LOCAL_BUILD}/libcvmmap_nats.a"
AND EXISTS "${CVMMAP_LOCAL_BUILD}/libcvmmap_proto.a"
AND EXISTS "${CVMMAP_LOCAL_BUILD}/libcvmmap_ipc.a"
AND EXISTS "${CVMMAP_LOCAL_BUILD}/libcvmmap_target.a")
add_library(cvmmap::nats INTERFACE IMPORTED)
add_library(cvmmap::client INTERFACE IMPORTED)
set_target_properties(cvmmap::nats PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${CVMMAP_LOCAL_ROOT}/core/include"
INTERFACE_LINK_LIBRARIES "${CVMMAP_LOCAL_BUILD}/libcvmmap_nats.a;${CVMMAP_LOCAL_BUILD}/libcvmmap_proto.a;${CVMMAP_LOCAL_BUILD}/libcvmmap_ipc.a;${CVMMAP_LOCAL_BUILD}/libcvmmap_target.a;cnats::nats_static")
set_target_properties(cvmmap::client PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${CVMMAP_LOCAL_ROOT}/core/include"
INTERFACE_LINK_LIBRARIES "${CVMMAP_LOCAL_BUILD}/libcvmmap_client.a;${CVMMAP_LOCAL_BUILD}/libcvmmap_nats.a;${CVMMAP_LOCAL_BUILD}/libcvmmap_proto.a;${CVMMAP_LOCAL_BUILD}/libcvmmap_ipc.a;${CVMMAP_LOCAL_BUILD}/libcvmmap_target.a;cnats::nats_static")
else()
message(FATAL_ERROR "cvmmap::client target is unavailable and local cv-mmap build artifacts were not found")
endif()
endif()
if (NOT TARGET rvl::rvl)
set(RVL_LOCAL_ROOT "${CMAKE_CURRENT_LIST_DIR}/../rvl_impl" CACHE PATH "Path to a local rvl_impl checkout")
set(RVL_LOCAL_BUILD "${RVL_LOCAL_ROOT}/build/core")
if (
EXISTS "${RVL_LOCAL_ROOT}/core/include/rvl/rvl.hpp"
AND EXISTS "${RVL_LOCAL_BUILD}/librvl_core.a")
add_library(rvl::rvl INTERFACE IMPORTED)
set_target_properties(rvl::rvl PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${RVL_LOCAL_ROOT}/core/include"
INTERFACE_LINK_LIBRARIES "${RVL_LOCAL_BUILD}/librvl_core.a")
else()
message(FATAL_ERROR "rvl::rvl target is unavailable and local rvl_impl build artifacts were not found")
endif()
endif()
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/proto")
add_library(cvmmap_streamer_foxglove_proto STATIC)
protobuf_generate(
TARGET cvmmap_streamer_foxglove_proto
LANGUAGE cpp
PROTOC_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}"
PROTOS
"${CMAKE_CURRENT_LIST_DIR}/proto/foxglove/CompressedVideo.proto"
"${CMAKE_CURRENT_LIST_DIR}/proto/foxglove/CameraCalibration.proto"
"${CMAKE_CURRENT_LIST_DIR}/proto/foxglove/PoseInFrame.proto"
"${CMAKE_CURRENT_LIST_DIR}/proto/foxglove/Pose.proto"
"${CMAKE_CURRENT_LIST_DIR}/proto/foxglove/Quaternion.proto"
"${CMAKE_CURRENT_LIST_DIR}/proto/foxglove/Vector3.proto"
IMPORT_DIRS "${CMAKE_CURRENT_LIST_DIR}")
add_library(cvmmap_streamer_depth_proto STATIC)
protobuf_generate(
TARGET cvmmap_streamer_depth_proto
LANGUAGE cpp
PROTOC_OUT_DIR "${CMAKE_CURRENT_BINARY_DIR}"
PROTOS "${CMAKE_CURRENT_LIST_DIR}/proto/cvmmap_streamer/DepthMap.proto"
IMPORT_DIRS "${CMAKE_CURRENT_LIST_DIR}")
add_library(cvmmap_streamer_protobuf INTERFACE)
target_include_directories(cvmmap_streamer_foxglove_proto
PUBLIC
"${CMAKE_CURRENT_BINARY_DIR}"
"${CMAKE_CURRENT_BINARY_DIR}/proto"
${Protobuf_INCLUDE_DIRS})
target_include_directories(cvmmap_streamer_depth_proto
PUBLIC
"${CMAKE_CURRENT_BINARY_DIR}"
"${CMAKE_CURRENT_BINARY_DIR}/proto"
${Protobuf_INCLUDE_DIRS})
target_include_directories(cvmmap_streamer_protobuf
INTERFACE
"${CMAKE_CURRENT_BINARY_DIR}/proto"
${Protobuf_INCLUDE_DIRS})
if (TARGET protobuf::libprotobuf)
target_link_libraries(cvmmap_streamer_protobuf INTERFACE protobuf::libprotobuf)
elseif (TARGET Protobuf::libprotobuf)
target_link_libraries(cvmmap_streamer_protobuf INTERFACE Protobuf::libprotobuf)
else()
target_link_libraries(cvmmap_streamer_protobuf INTERFACE ${Protobuf_LIBRARIES})
endif()
if (TARGET PkgConfig::PROTOBUF_PKG)
target_link_libraries(cvmmap_streamer_protobuf INTERFACE PkgConfig::PROTOBUF_PKG)
endif()
target_link_libraries(cvmmap_streamer_foxglove_proto PUBLIC cvmmap_streamer_protobuf)
target_link_libraries(cvmmap_streamer_depth_proto PUBLIC cvmmap_streamer_protobuf)
add_library(cvmmap_streamer_mcap_runtime STATIC
src/record/mcap_runtime.cpp)
target_include_directories(cvmmap_streamer_mcap_runtime
PUBLIC)
target_link_libraries(cvmmap_streamer_mcap_runtime
PUBLIC
mcap::mcap
PkgConfig::ZSTD
PkgConfig::LZ4)
add_library(cvmmap_streamer_record_support STATIC
src/encode/encoder_backend.cpp
src/encode/ffmpeg_encoder_backend.cpp
src/record/protobuf_descriptor.cpp
src/record/mcap_record_sink.cpp)
target_include_directories(cvmmap_streamer_record_support
PUBLIC
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}")
target_link_libraries(cvmmap_streamer_record_support
PUBLIC
cvmmap_streamer_foxglove_proto
cvmmap_streamer_depth_proto
cvmmap_streamer_mcap_runtime
PkgConfig::FFMPEG
PkgConfig::ZSTD
PkgConfig::LZ4
rvl::rvl
mcap::mcap
msft_proxy4::proxy
cvmmap_streamer_protobuf)
if (TARGET spdlog::spdlog)
target_link_libraries(cvmmap_streamer_record_support PUBLIC spdlog::spdlog)
elseif (TARGET spdlog)
target_link_libraries(cvmmap_streamer_record_support PUBLIC spdlog)
endif()
if (TARGET PkgConfig::PROTOBUF_PKG)
target_link_libraries(cvmmap_streamer_record_support PUBLIC PkgConfig::PROTOBUF_PKG)
endif()
add_library(cvmmap_streamer_common STATIC
src/ipc/help.cpp
src/config/runtime_config.cpp
src/core/frame_source.cpp
src/core/ingest_runtime.cpp
src/ipc/contracts.cpp
src/protocol/wire_codec.cpp
src/metrics/latency_tracker.cpp
src/pipeline/pipeline_runtime.cpp
src/protocol/rtmp_output.cpp
src/protocol/rtp_publisher.cpp)
target_include_directories(cvmmap_streamer_common
PUBLIC
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}")
set(CVMMAP_STREAMER_LINK_DEPS
Threads::Threads
cvmmap_streamer_record_support
PkgConfig::FFMPEG
PkgConfig::ZSTD
PkgConfig::LZ4
cvmmap::client
cvmmap::nats
CLI11::CLI11
tomlplusplus::tomlplusplus
mcap::mcap)
if (TARGET cppzmq::cppzmq)
list(APPEND CVMMAP_STREAMER_LINK_DEPS cppzmq::cppzmq)
elseif (TARGET cppzmq)
list(APPEND CVMMAP_STREAMER_LINK_DEPS cppzmq)
endif()
if (TARGET ZeroMQ::libzmq)
list(APPEND CVMMAP_STREAMER_LINK_DEPS ZeroMQ::libzmq)
elseif (TARGET ZeroMQ::ZeroMQ)
list(APPEND CVMMAP_STREAMER_LINK_DEPS ZeroMQ::ZeroMQ)
endif()
if (TARGET spdlog::spdlog)
list(APPEND CVMMAP_STREAMER_LINK_DEPS spdlog::spdlog)
elseif (TARGET spdlog)
list(APPEND CVMMAP_STREAMER_LINK_DEPS spdlog)
endif()
list(APPEND CVMMAP_STREAMER_LINK_DEPS cvmmap_streamer_protobuf)
if (TARGET PkgConfig::PROTOBUF_PKG)
list(APPEND CVMMAP_STREAMER_LINK_DEPS PkgConfig::PROTOBUF_PKG)
endif()
target_link_libraries(cvmmap_streamer_common PUBLIC ${CVMMAP_STREAMER_LINK_DEPS})
function(add_cvmmap_binary target source)
add_executable(${target} ${source} ${ARGN})
target_include_directories(${target}
PRIVATE
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}")
target_link_libraries(${target}
PRIVATE
cvmmap_streamer_common)
set_target_properties(${target} PROPERTIES
OUTPUT_NAME "${target}"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
endfunction()
add_cvmmap_binary(cvmmap_streamer src/main_streamer.cpp)
add_cvmmap_binary(rtp_receiver_tester src/testers/rtp_receiver_tester.cpp)
add_cvmmap_binary(rtp_output_tester src/testers/rtp_output_tester.cpp)
add_cvmmap_binary(rtmp_stub_tester src/testers/rtmp_stub_tester.cpp)
add_cvmmap_binary(rtmp_output_tester src/testers/rtmp_output_tester.cpp)
add_cvmmap_binary(ipc_snapshot_tester src/testers/ipc_snapshot_tester.cpp)
add_cvmmap_binary(mcap_depth_record_tester src/testers/mcap_depth_record_tester.cpp)
add_cvmmap_binary(mcap_body_record_tester src/testers/mcap_body_record_tester.cpp)
add_cvmmap_binary(mcap_body_inspector src/testers/mcap_body_inspector.cpp)
add_cvmmap_binary(mcap_pose_record_tester src/testers/mcap_pose_record_tester.cpp)
add_cvmmap_binary(mcap_multi_record_tester src/testers/mcap_multi_record_tester.cpp)
add_executable(mcap_reader_tester src/testers/mcap_reader_tester.cpp)
target_include_directories(mcap_reader_tester
PRIVATE
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}")
target_link_libraries(mcap_reader_tester
PRIVATE
CLI11::CLI11
cvmmap_streamer_foxglove_proto
cvmmap_streamer_depth_proto
cvmmap_streamer_mcap_runtime
mcap::mcap
PkgConfig::ZSTD
PkgConfig::LZ4)
if (TARGET spdlog::spdlog)
target_link_libraries(mcap_reader_tester PRIVATE spdlog::spdlog)
elseif (TARGET spdlog)
target_link_libraries(mcap_reader_tester PRIVATE spdlog)
endif()
target_link_libraries(mcap_reader_tester PRIVATE cvmmap_streamer_protobuf)
if (TARGET PkgConfig::PROTOBUF_PKG)
target_link_libraries(mcap_reader_tester PRIVATE PkgConfig::PROTOBUF_PKG)
endif()
set_target_properties(mcap_reader_tester PROPERTIES
OUTPUT_NAME "mcap_reader_tester"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
add_executable(mcap_replay_tester src/testers/mcap_replay_tester.cpp)
target_include_directories(mcap_replay_tester
PRIVATE
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}")
target_link_libraries(mcap_replay_tester
PRIVATE
Threads::Threads
CLI11::CLI11
cvmmap_streamer_foxglove_proto
cvmmap_streamer_mcap_runtime
mcap::mcap
PkgConfig::ZSTD
PkgConfig::LZ4)
if (TARGET spdlog::spdlog)
target_link_libraries(mcap_replay_tester PRIVATE spdlog::spdlog)
elseif (TARGET spdlog)
target_link_libraries(mcap_replay_tester PRIVATE spdlog)
endif()
target_link_libraries(mcap_replay_tester PRIVATE cvmmap_streamer_protobuf)
if (TARGET PkgConfig::PROTOBUF_PKG)
target_link_libraries(mcap_replay_tester PRIVATE PkgConfig::PROTOBUF_PKG)
endif()
set_target_properties(mcap_replay_tester PROPERTIES
OUTPUT_NAME "mcap_replay_tester"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
set(CVMMAP_STREAMER_INSTALL_TARGETS cvmmap_streamer)
if (CVMMAP_HAS_ZED_SDK)
add_library(
cvmmap_streamer_zed_progress_support
STATIC
src/tools/zed_progress_bar.cpp)
target_include_directories(cvmmap_streamer_zed_progress_support
PUBLIC
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}")
add_executable(
zed_svo_to_mcap
src/tools/zed_svo_to_mcap.cpp
src/config/runtime_config.cpp)
target_include_directories(zed_svo_to_mcap
PRIVATE
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}"
${ZED_INCLUDE_DIRS}
${CUDA_INCLUDE_DIRS})
target_link_directories(zed_svo_to_mcap
PRIVATE
${ZED_LIBRARY_DIR}
${CUDA_LIBRARY_DIRS})
target_link_libraries(zed_svo_to_mcap
PRIVATE
cvmmap_streamer_zed_progress_support
cvmmap_streamer_record_support
CLI11::CLI11
tomlplusplus::tomlplusplus
${ZED_LIBRARIES}
${CUDA_CUDA_LIBRARY}
${CUDA_CUDART_LIBRARY})
if (TARGET spdlog::spdlog)
target_link_libraries(zed_svo_to_mcap PRIVATE spdlog::spdlog)
elseif (TARGET spdlog)
target_link_libraries(zed_svo_to_mcap PRIVATE spdlog)
endif()
set_target_properties(zed_svo_to_mcap PROPERTIES
OUTPUT_NAME "zed_svo_to_mcap"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
list(APPEND CVMMAP_STREAMER_INSTALL_TARGETS zed_svo_to_mcap)
add_library(
cvmmap_streamer_zed_svo_mp4_support
STATIC
src/tools/zed_svo_mp4_support.cpp)
target_include_directories(cvmmap_streamer_zed_svo_mp4_support
PUBLIC
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}")
target_link_libraries(cvmmap_streamer_zed_svo_mp4_support
PUBLIC
PkgConfig::FFMPEG)
if (TARGET spdlog::spdlog)
target_link_libraries(cvmmap_streamer_zed_svo_mp4_support PUBLIC spdlog::spdlog)
elseif (TARGET spdlog)
target_link_libraries(cvmmap_streamer_zed_svo_mp4_support PUBLIC spdlog)
endif()
add_executable(
zed_svo_to_mp4
src/tools/zed_svo_to_mp4.cpp)
target_include_directories(zed_svo_to_mp4
PRIVATE
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}"
${ZED_INCLUDE_DIRS}
${CUDA_INCLUDE_DIRS})
target_link_directories(zed_svo_to_mp4
PRIVATE
${ZED_LIBRARY_DIR}
${CUDA_LIBRARY_DIRS})
target_link_libraries(zed_svo_to_mp4
PRIVATE
CLI11::CLI11
cvmmap_streamer_zed_progress_support
cvmmap_streamer_zed_svo_mp4_support
${ZED_LIBRARIES}
${CUDA_CUDA_LIBRARY}
${CUDA_CUDART_LIBRARY})
if (TARGET spdlog::spdlog)
target_link_libraries(zed_svo_to_mp4 PRIVATE spdlog::spdlog)
elseif (TARGET spdlog)
target_link_libraries(zed_svo_to_mp4 PRIVATE spdlog)
endif()
set_target_properties(zed_svo_to_mp4 PROPERTIES
OUTPUT_NAME "zed_svo_to_mp4"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
list(APPEND CVMMAP_STREAMER_INSTALL_TARGETS zed_svo_to_mp4)
if (CVMMAP_BUILD_ZED_SVO_GRID_TO_MP4)
add_executable(
zed_svo_grid_to_mp4
src/tools/zed_svo_grid_to_mp4.cpp)
target_include_directories(zed_svo_grid_to_mp4
PRIVATE
"${CMAKE_CURRENT_LIST_DIR}/include"
"${CMAKE_CURRENT_BINARY_DIR}"
${ZED_INCLUDE_DIRS}
${CUDA_INCLUDE_DIRS}
${OpenCV_INCLUDE_DIRS})
target_link_directories(zed_svo_grid_to_mp4
PRIVATE
${ZED_LIBRARY_DIR}
${CUDA_LIBRARY_DIRS})
target_link_libraries(zed_svo_grid_to_mp4
PRIVATE
CLI11::CLI11
cvmmap_streamer_zed_progress_support
cvmmap_streamer_zed_svo_mp4_support
${ZED_LIBRARIES}
${CUDA_CUDA_LIBRARY}
${CUDA_CUDART_LIBRARY}
${OpenCV_LIBS})
if (TARGET spdlog::spdlog)
target_link_libraries(zed_svo_grid_to_mp4 PRIVATE spdlog::spdlog)
elseif (TARGET spdlog)
target_link_libraries(zed_svo_grid_to_mp4 PRIVATE spdlog)
endif()
set_target_properties(zed_svo_grid_to_mp4 PROPERTIES
OUTPUT_NAME "zed_svo_grid_to_mp4"
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
list(APPEND CVMMAP_STREAMER_INSTALL_TARGETS zed_svo_grid_to_mp4)
endif()
endif()
install(
TARGETS ${CVMMAP_STREAMER_INSTALL_TARGETS}
RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}")
Reference in New Issue View Git Blame Copy Permalink