Merge branch 'uvgV3CRTP_integration'

Author: MrAsura

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "src/app/dependencies/uvgV3CRTP"]
+	path = src/app/dependencies/uvgV3CRTP
+	url = https://github.com/ultravideo/uvgV3CRTP.git

CMakeLists.txt

@@ -16,6 +16,9 @@ set(TMC2_EP_UPDATE_DISCONNECTED ON)
 
 option(BUILD_SHARED_LIBS "Build using shared uvgVPCCenc library" ON)
 
+# Control if uvgVPCCenc should be build with RTP support
+option(ENABLE_V3CRTP "Enable RTP support" OFF)
+
 project(uvgVPCCenc
   VERSION ${uvgVPCCenc_VER}
   DESCRIPTION ${uvgVPCCenc_DESCR}

CMakePresets.json

@@ -19,7 +19,8 @@
             "ENABLE_TESTING": false,
             "CHECK_PC_MD5": false,
             "ENABLE_CI_TESTING": false,
-            "ENABLE_MY_TESTING": false
+            "ENABLE_MY_TESTING": false,
+			"ENABLE_V3CRTP": false
          }
       },
       {

README.md

@@ -55,6 +55,12 @@ cmake --build --preset=Release
 By default, the build application is located in ```_build/Release/src/app/```.
 Refer to "Using uvgVPCCenc" section to learn how to use the library, and attached application.
 
+#### Compile with V3C RTP support
+To enable sending over RTP run cmake with
+```
+cmake --preset=Release -DENABLE_V3CRTP=ON
+```
+
 ### Test uvgVPCCenc
 To test the encoder, please use following commands:
 ```
@@ -98,6 +104,13 @@ The application option ```--uvgvpcc``` accept a string containing uvgVPCCenc par
 
 The list of uvgVPCCenc parameters that can be modified with the ```--uvgvpcc``` option is defined in the ```parameterMap``` initialized in [parameters.cpp](src/lib/utils/parameters.cpp).
 
+#### V3C RTP Example:
+```
+    uvgVPCCenc -i <path_to_ply> -n 10 --dst-address=127.0.0.1 --dst-port=8890 
+```
+
+Send encoded bitstream over RTP. Destination can be set using ```--dst-address``` and ```--dst-port```. A separate RTP media stream is created for each type of V3C unit and the streames are multiplexed to the same port using SSRC (hardcoded to be ```vuh_unit_type + 1```).
+
 ---
 
 
@@ -113,6 +126,8 @@ The list of uvgVPCCenc parameters that can be modified with the ```--uvgvpcc```
         --uvgvpcc <params>       Encoder configuration parameters (see next section)
         --help                   Show this help message
         --version                Show version information
+		--dst-address <IP>       Destination IP address for an rtp stream (when compiled with V3C RTP support)";
+        --dst-port <number>      Destination port for an rtp stream (when compiled with V3C RTP support)";
 ```
 ---
 

src/app/CMakeLists.txt

@@ -1,5 +1,8 @@
 message(DEBUG "./src/app/cmake")
 
+# Take care of external dependencies (e.g. uvgV3CRTP)
+include(dependencies/FindDependencies.cmake)
+
 add_library(miniplyLibrary STATIC
     extras/miniply.cpp
 )
@@ -21,5 +24,12 @@ target_compile_options(getoptLibrary PRIVATE -fPIC)
 
 target_link_libraries(uvgVPCCenc uvgvpccenc)
 
+# Add uvgV3CRTP to link targets if enabled
+if(ENABLE_V3CRTP)
+    target_link_libraries(uvgVPCCenc uvgv3crtp)
+    # Include define to uvgVPCCenc so uvgV3CRTP code is included
+    target_compile_definitions(uvgVPCCenc PRIVATE ENABLE_V3CRTP)
+endif()
+
 # Define installation destinations
 install(TARGETS uvgVPCCenc DESTINATION bin)

src/app/cli.cpp

@@ -51,7 +51,7 @@ namespace {
 
 // NOLINTNEXTLINE(cert-err58-cpp)
 const std::string short_options = "i:g:l:n:o:s:t:b:d:";
-const std::array<struct option, 11> long_options{{{"input", required_argument, nullptr, 'i'},
+const std::array<struct option, 13> long_options{{{"input", required_argument, nullptr, 'i'},
                                                   {"output", required_argument, nullptr, 'o'},
                                                   {"frames", required_argument, nullptr, 'n'},
                                                   {"start-frame", required_argument, nullptr, 's'},
@@ -61,7 +61,9 @@ const std::array<struct option, 11> long_options{{{"input", required_argument, n
                                                   {"loop-input", required_argument, nullptr, 'l'},
                                                   {"dummy-run", required_argument, nullptr, 'd'},
                                                   {"help", no_argument, nullptr, 0},
-                                                  {"version", no_argument, nullptr, 0}}};
+                                                  {"version", no_argument, nullptr, 0},
+                                                  {"dst-address", required_argument, nullptr, 0},
+                                                  {"dst-port", required_argument, nullptr, 0}}};
 
 /**
  * \brief Try to detect voxel size from file name automatically
@@ -180,6 +182,10 @@ bool opts_parse(cli::opts_t& opts, const int& argc, const std::span<const char*
         } else if (name == "help") {
             cli::print_help();
             return true;
+        } else if (name == "dst-address") {
+            opts.dstAddress = optarg;  // TODO: Check that the address is valid
+        } else if (name == "dst-port") {
+            opts.dstPort = static_cast<uint16_t>(std::stoi(optarg));
         }
     }
 
@@ -189,8 +195,13 @@ bool opts_parse(cli::opts_t& opts, const int& argc, const std::span<const char*
     }
 
     // Check that the required files were defined
-    if (opts.inputPath.empty() || opts.outputPath.empty()) {
-        throw std::runtime_error("Input error: Input or output path is empty\n");
+    if (opts.inputPath.empty()) {
+        throw std::runtime_error("Input error: Input path is empty\n");
+    }
+
+    // Check that at least one output method is defined
+    if (opts.outputPath.empty() && opts.dstAddress.empty()) {
+        throw std::runtime_error("Input error: At least one output should be specified (e.g. 'output' or 'dst-address')\n");
     }
 
     if (opts.inputGeoPrecision == 0) {
@@ -254,7 +265,10 @@ void print_help(void) {
     std::cout << "      --uvgvpcc <params>       Encoder configuration parameters\n";
     std::cout << "      --help                   Show this help message\n";
     std::cout << "      --version                Show version information\n";
-    
+#if defined(ENABLE_V3CRTP)
+    std::cout << "      --dst-address <IP>       Destination IP address for an rtp stream\n";
+    std::cout << "      --dst-port <number>      Destination port for an rtp stream\n";
+#endif
     std::cout << "\nDescription:\n";
     std::cout << "  This tool encodes point cloud video frames using the uvgVPCCenc codec\n";
     std::cout << "  with specified parameters.\n";

src/app/cli.hpp

@@ -39,6 +39,7 @@
 #include <limits>
 #include <string>
 #include <span>
+#include <cstdint>
 
 namespace cli {
 
@@ -65,6 +66,10 @@ struct opts_t {
     size_t nbLoops = 1;
     /** \brief If dummyRun is true, config is verified but no encoding is done */
     bool dummyRun = false;    
+    /** \brief Destination address for rtp streams */
+    std::string dstAddress{};
+    /** \brief Destination port for rtp streams */
+    uint16_t dstPort = 0;
 };
 
 bool opts_parse(cli::opts_t& opts, const int& argc, const std::span<const char* const>& args);

src/app/dependencies/FindDependencies.cmake

@@ -0,0 +1,54 @@
+if(ENABLE_V3CRTP)
+	# Check if uvgV3CRTP is already available
+	find_package(uvgV3CRTP 0.6.0 QUIET) #TODO: update min version to a version with necessary bug fixes etc.
+
+	# Try pkgConfig as well
+	find_package(PkgConfig QUIET)
+	if(PkgConfig_FOUND)
+		if(NOT UVGV3CRTP_FOUND)
+			pkg_search_module(UVGV3CRTP uvgv3crtp>=0.6.0 uvgV3CRTP>=0.6.0)
+		endif()
+	endif()
+
+	# If we did not find uvgV3CRTP build it from source_group
+	if(UVGV3CRTP_FOUND)
+		message(STATUS "Found uvgV3CRTP")
+	else()
+		message(STATUS "uvgV3CRTP not found, building from source...")
+		
+		#include(FetchContent)
+		find_package(Git REQUIRED)
+		
+		option(GIT_SUBMODULE "Check submodules during build" ON)
+		if(GIT_SUBMODULE)
+			message(STATUS "Update submodule")
+			execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive
+							WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+							RESULT_VARIABLE GIT_SUBMOD_RESULT)
+			if(NOT GIT_SUBMOD_RESULT EQUAL "0")
+				message(FATAL_ERROR "git submodule update --init --recursive failed with ${GIT_SUBMOD_RESULT}, please checkout submodule")
+			endif()
+		endif()
+		
+		# Add subdir and specify relevant options
+		set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+
+		set(UVGV3CRTP_DISABLE_TESTS ON CACHE BOOL "" FORCE)
+		set(UVGV3CRTP_DISABLE_EXAMPLES  ON CACHE BOOL "" FORCE)
+		set(UVGV3CRTP_DISABLE_INSTALL OFF CACHE BOOL "" FORCE)
+
+		add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/dependencies/uvgV3CRTP)
+		
+		include_directories(${uvgv3crtp_SOURCE_DIR}/include)
+		link_directories(${uvgv3crtp_SOURCE_DIR})
+		
+		unset(BUILD_SHARED_LIBS)
+
+	endif()
+endif()
+
+# include and link directories for dependencies. 
+# These are needed when the compilation happens a second time and the library 
+# is found so no compilation happens. Not needed in every case, but a nice backup
+include_directories(${CMAKE_BINARY_DIR}/include)
+link_directories(${CMAKE_CURRENT_BINARY_DIR}/lib)

src/app/dependencies/uvgV3CRTP

@@ -60,6 +60,11 @@
 #include "uvgvpcc/log.hpp"
 #include "uvgvpcc/uvgvpcc.hpp"
 
+#if defined(ENABLE_V3CRTP)
+#include <uvgv3crtp/version.h>
+#include <uvgv3crtp/v3c_api.h>
+#endif
+
 namespace {
 
 // Semaphores for synchronization.
@@ -257,6 +262,7 @@ void file_writer(uvgvpcc_enc::API::v3c_unit_stream* chunks, const std::string& o
         if (chunk.data == nullptr && chunk.len == 0) {
             uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::TRACE>("APPLICATION", "All chunks written to file.\n");
             file.close();
+            chunks->io_mutex.unlock();
             break;
         }
         if (chunk.data != nullptr) {
@@ -282,6 +288,118 @@ void file_writer(uvgvpcc_enc::API::v3c_unit_stream* chunks, const std::string& o
     }
 }
 
+/// @brief Application thread for sending output over RTP.
+/// @param chunks
+/// @param output_path
+void v3c_sender(uvgvpcc_enc::API::v3c_unit_stream* chunks, const std::string dst_address, const uint16_t dst_port) {
+#if defined(ENABLE_V3CRTP)
+
+    uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::TRACE>("APPLICATION", "Using uvgV3CRTP lib version " + uvgV3CRTP::get_version() + "\n");
+    
+    // ******** Initialize sample stream with input bitstream ***********
+    //
+    uvgV3CRTP::V3C_State<uvgV3CRTP::V3C_Sender> state(uvgV3CRTP::INIT_FLAGS::VPS | uvgV3CRTP::INIT_FLAGS::AD | uvgV3CRTP::INIT_FLAGS::OVD |
+                                                      uvgV3CRTP::INIT_FLAGS::GVD | uvgV3CRTP::INIT_FLAGS::AVD,
+                                                      dst_address.c_str(), dst_port  // Receiver address and port
+    );                                                                    // Create a new state in a sender configuration
+    state.init_sample_stream(FORCED_V3C_SIZE_PRECISION); // Use the forced precision for now
+    //
+    // ******************************************************************
+    if (state.get_error_flag() != uvgV3CRTP::ERROR_TYPE::OK) {
+        throw std::runtime_error(std::string("V3C Sender : Error initializing state (message: ") + state.get_error_msg() + ")"); 
+    }
+
+    // ******** Send sample stream **********
+    //
+    // TODO: Currently whole bitstream is stored, but should clear the sample stream at certain points
+    // For rate limiting sending
+    auto last_sleep_time = std::chrono::high_resolution_clock::now();
+    while (state.get_error_flag() == uvgV3CRTP::ERROR_TYPE::OK) {
+                
+        // Get chunks and add them to state for sending
+        chunks->available_chunks.acquire();
+        chunks->io_mutex.lock();
+
+        const uvgvpcc_enc::API::v3c_chunk& chunk = chunks->v3c_chunks.front();
+        if (chunk.data == nullptr && chunk.len == 0) {
+            uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::TRACE>("APPLICATION", "All chunks sent.\n");
+            chunks->io_mutex.unlock();
+
+            break;
+        }
+
+        // Add new data to state
+        size_t len = chunk.len;
+        std::ptrdiff_t ptr = 0;  // Keep track of ptr in the V3C unit stream
+        for (const uint64_t current_size : chunk.v3c_unit_sizes) {
+            // Add the V3C unit to existing sample stream
+            // NOLINTNEXTLINE(concurrency-mt-unsafe)
+            state.append_to_sample_stream(std::next(chunk.data.get(), ptr), static_cast<size_t>(current_size));
+            ptr += static_cast<std::ptrdiff_t>(current_size);
+        }
+
+        chunks->v3c_chunks.pop();
+        chunks->io_mutex.unlock();
+
+        // Send newly added data
+        while (state.get_error_flag() == uvgV3CRTP::ERROR_TYPE::OK) {
+            // Send gof if full
+            if(state.cur_gof_is_full()) {
+                uvgV3CRTP::send_gof(&state);
+                state.next_gof();
+
+                uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::TRACE>("APPLICATION",
+                                                                       "Sent one gof " + std::to_string(len) + " bytes.\n");
+            }
+            else
+            {
+            //TODO: track which unit has been sent
+            //    for (uint8_t id = 0; id < uvgV3CRTP::NUM_V3C_UNIT_TYPES; id++) {
+            //    if (!state.cur_gof_has_unit(uvgV3CRTP::V3C_UNIT_TYPE(id))) continue;
+
+            //    // TODO: send side-channel info
+
+            //    uvgV3CRTP::send_unit(&state, uvgV3CRTP::V3C_UNIT_TYPE(id));
+            //}
+                //state.next_gof();
+                break;
+            }
+            // Get difference from last sleep and sleep if needed
+            const auto elapsed_time = std::chrono::high_resolution_clock::now() - last_sleep_time;
+            std::this_thread::sleep_for(std::chrono::nanoseconds((1000000000 / uvgV3CRTP::SEND_FRAME_RATE)) - elapsed_time);
+            last_sleep_time = std::chrono::high_resolution_clock::now();  // Update last send time
+        }
+
+        uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::TRACE>("APPLICATION",
+                                                               "Processed V3C chunk of size " + std::to_string(len) + " bytes.\n");
+
+        if (state.get_error_flag() == uvgV3CRTP::ERROR_TYPE::EOS) {
+            state.reset_error_flag(); //More chunks are added later so reset EOS
+        }
+    }
+
+    // ******** Print info about sample stream **********
+    //
+    // Print state and bitstream info
+    //state.print_state(false);
+
+    //std::cout << "Bitstream info: " << std::endl;
+    //state.print_bitstream_info();
+
+    size_t len = 0;
+    auto info = std::unique_ptr<char, decltype(&free)>(state.get_bitstream_info_string(uvgV3CRTP::INFO_FMT::LOGGING, &len), &free);
+    uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::TRACE>("APPLICATION", "Bitstream info string: \n" + std::string(info.get(), len) + "\n");
+    //
+    //  **************************************
+
+    if (state.get_error_flag() != uvgV3CRTP::ERROR_TYPE::OK && state.get_error_flag() != uvgV3CRTP::ERROR_TYPE::EOS) {
+        throw std::runtime_error(std::string("V3C Sender : Sending error (message: ") + state.get_error_msg() + ")");
+    }
+#else
+    throw std::runtime_error("V3C RTP not enabled, re-run cmake with '-DENABLE_V3CRTP=ON'.");
+#endif
+}
+
 /// @brief Simple application wrapper taking a command string as input to set multiple encoder parameters.
 /// @param parametersCommand
 void setParameters(const std::string& parametersCommand) {
@@ -375,7 +493,10 @@ int main(const int argc, const char* const argv[]) {
 
     uvgvpcc_enc::API::v3c_unit_stream output;  // Each v3c chunk gets appended to the V3C unit stream as they are encoded
     std::thread file_writer_thread;
-    file_writer_thread = std::thread(file_writer, &output, appParameters.outputPath);
+    std::thread v3c_sender_thread;
+
+    if (!appParameters.outputPath.empty()) file_writer_thread = std::thread(file_writer, &output, appParameters.outputPath);
+    if (!appParameters.dstAddress.empty()) v3c_sender_thread = std::thread(v3c_sender, &output, appParameters.dstAddress, appParameters.dstPort);
 
     // Main loop of the application, feeding one frame to the encoder at each iteration
     for (;;) {
@@ -410,7 +531,8 @@ int main(const int argc, const char* const argv[]) {
     output.io_mutex.unlock();
     output.available_chunks.release();
 
-    file_writer_thread.join();
+    if(file_writer_thread.joinable()) file_writer_thread.join();
+    if(v3c_sender_thread.joinable()) v3c_sender_thread.join();
 
     uvgvpcc_enc::Logger::log<uvgvpcc_enc::LogLevel::INFO>("APPLICATION", "Encoded " + std::to_string(frameRead) + " frames.\n");